¿Cómo elimino las compilaciones 11 a 1717 en Jenkins?

Debido a una configuración incorrecta, tengo más de 1700 compilaciones fallidas en un trabajo de Jenkins.

¿Cómo puedo limpiarlos eficientemente?

Tienes varias opciones:

• Establezca temporalmente el número de compilaciones para mantener en la configuración del trabajo ( Descartar compilaciones antiguas ) para que esas compilaciones se eliminen cuando finalice la próxima compilación. Si la próxima compilación es 1800, configúrela para mantener la 85 más reciente más o menos. Marque todas las compilaciones anteriores (es decir, de 1 a 10) como Mantener esta compilación para siempre antes de comenzar la próxima compilación. Esta opción no eliminará algunas compilaciones si tiene un trabajo en sentido descendente que evita que se eliminen las compilaciones en sentido ascendente (aunque no es un problema en su situación si todas fallaron).

• Use la consola de script en Manage Jenkins . Si es un trabajo de nivel superior (no en una carpeta), lo siguiente hará el truco:

  Jenkins.instance.getItemByFullName('JobName').builds.findAll { it.number > 10 && it.number < 1717 }.each { it.delete() }

  Por supuesto, este enfoque generalmente requiere buenas copias de seguridad. Hay muchas cosas que puedes romper usando la consola de script.

• Elimine las carpetas de compilaciones del disco (de forma predeterminada $JENKINS_HOME/jobs/JobName/builds/, utilizando la marca de tiempo de inicio como nombre de la carpeta) y reinicie Jenkins o Vuelva a cargar la configuración desde el disco . Esta opción no permitirá complementos que, por ejemplo, mantengan el historial SVN en orden moviendo cualquier cambio a la compilación posterior para hacer su trabajo.

Simplemente haga una llamada API:

curl -X POST http://jenkinUser:jenkinAPIToken@yourJenkinsURl.com/job/theJob/[11-1717]/doDelete

Para obtener APIToken: inicie sesión en Jenkins> Configuración> Mostrar token de API.

Como Aaron dijo correctamente, también puede usar la CLI de Jenkins para este propósito:

java -jar jenkins-cli.jar -s http://yourserver.com delete-builds <JobName> 11-1717

Plantilla para ejecutar un script en Jenkins Script-Console. Use la bandera reallyDeletepara probarlo antes de eliminar realmente:

// Jenkins job
def jobName = 'foo'
// Range of builds to delete
def rs = Fingerprint.RangeSet.fromString("11-1717", false);
// Set to true to actually delete. Use false to test the script.
def reallyDelete = false;

// ----------------------------------
def job = Jenkins.instance.getItemByFullName(jobName);
println("Job: ${job.fullName}");

def builds = Jenkins.instance.getItemByFullName(jobName).getBuilds(rs);
println("Found ${builds.size()} builds");
builds.each{ b-> 
  if (reallyDelete) {
    println("Deleting ${b}");
    b.delete();
  } else {
    println("Found match ${b}");
  }
}

Me enfrenté a la misma tarea cuando me hice cargo de un servidor Jenkins, donde hay más de 150 trabajos con hasta 3000 compilaciones antiguas, así que escribí un pequeño script bash que solo mantiene las últimas 10 compilaciones:

#! /bin/bash

initialPath=$(pwd);

find /var/lib/jenkins/ -type d -name builds | while read jobs
 do

    #############################################################
    ## Enter build-directory of current job and get some numbers
    #############################################################
    cd "$jobs" ;
    ls -d [[:digit:]]* &>/dev/null ;
    rc=$? ;
    if [[ $rc -eq 0 ]] ;
     then
        buildName=$(ls -d [[:digit:]]*)  ;
        latestBuild=$(echo $buildName | awk '{print $NF}') ; # highest number
        oldestBuild=$(echo $buildName | awk '{print $1}') ; # lowest number
        amountOfBuilds=$(echo $buildName | wc -w ) ;
        lastBuildToKeep=$(echo "${latestBuild} 9" | awk '{print $1 - $2}') ;

        ############################################################
        ## Skip Folder if it contains less than 10 builds
        ############################################################
        if [ ${amountOfBuilds} -le 10 ] ;
         then
            echo "Skipping $(pwd) --> less than 10 builds";
         else
            ############################################################
            ## Delete all build-directories except the last 10
            ############################################################
            for (( i=$oldestBuild; i<$lastBuildToKeep; i++))
             do
                echo "Deleting $(pwd)/${i} ..."
                rm -r "$i" ;
            done ;
        fi ;
     else
        echo "Skipping $(pwd) --> Zero builds";
    fi ;
done ;

############################################################
## go back to $initialPath
############################################################
cd "$initialPath" ;

Reiniciar Jenkins después es muy recomendable para evitar problemas. Gracias @Aaron Digulla

He creado un pequeño script de Python que serviría para este propósito. El siguiente es el guión:

delete_jenkins_builds.py

from os import listdir, path
import shutil


job_build_fullpath = '/var/lib/jenkins/jobs/My-Jenkins-Project/builds'
print listdir(job_build_fullpath)

for build_dir in listdir(job_build_fullpath):
        if build_dir.isdigit() and int(build_dir) in range(11, 1718):
                build_dir_fullpath = path.join(job_build_fullpath, build_dir)
                print "Deleting: " + build_dir_fullpath
                shutil.rmtree(build_dir_fullpath)

• job_build_fullpath - Ruta del directorio de compilación del trabajo

• range (start_build_no, end_build_no) - range (11, 1718) busca todas las compilaciones que van desde la compilación no. 11 para construir no. 1717. Por favor configúrelo en consecuencia.

• shutil.rmtree (build_dir_fullpath): elimina cada directorio de compilación que se encuentre en el rango.

Versión de Python: 2.7