Nuestro servidor Jenkins tiene un trabajo que se ha estado ejecutando durante tres días, pero no está haciendo nada. Hacer clic en la pequeña X en la esquina no hace nada, y el registro de salida de la consola tampoco muestra nada. He revisado nuestros servidores de compilación y el trabajo no parece estar ejecutándose en absoluto.

¿Hay alguna manera de decirle a Jenkins que el trabajo está "hecho", editando algún archivo o bloqueo o algo así? Como tenemos muchos trabajos, realmente no queremos reiniciar el servidor.

Vaya a "Manage Jenkins"> "Script Console" para ejecutar un script en su servidor para interrumpir el hilo colgante.

Puede obtener todos los hilos en vivo Thread.getAllStackTraces()e interrumpir el que está colgando.

Thread.getAllStackTraces().keySet().each() {
  t -> if (t.getName()=="YOUR THREAD NAME" ) {   t.interrupt();  }
}

ACTUALIZAR:

La solución anterior que utiliza subprocesos puede no funcionar en las versiones más recientes de Jenkins. Para interrumpir las tuberías congeladas, consulte esta solución (por alexandru-bantiuc ) y ejecute:

Jenkins.instance.getItemByFullName("JobName")
                .getBuildByNumber(JobNumber)
                .finish(
                        hudson.model.Result.ABORTED,
                        new java.io.IOException("Aborting build")
                );

También tuve el mismo problema y lo solucioné a través de la consola Jenkins.

Vaya a "Administrar Jenkins"> "Consola de script" y ejecute un script:

 Jenkins .instance.getItemByFullName("JobName")
        .getBuildByNumber(JobNumber)
        .finish(hudson.model.Result.ABORTED, new java.io.IOException("Aborting build")); 

Solo tendrá que especificar su JobName y JobNumber.

En caso de que tenga un trabajo Multibranch Pipeline (y usted es un administrador de Jenkins), use en la consola de Jenkins Script este script:

Jenkins.instance
.getItemByFullName("<JOB NAME>")
.getBranch("<BRANCH NAME>")
.getBuildByNumber(<BUILD NUMBER>)
.finish(hudson.model.Result.ABORTED, new java.io.IOException("Aborting build"));

De https://issues.jenkins-ci.org/browse/JENKINS-43020

Si no está seguro de cuál es el nombre completo (ruta) del trabajo, puede usar el siguiente fragmento para enumerar el nombre completo de todos los elementos:

  Jenkins.instance.getAllItems(AbstractItem.class).each {
    println(it.fullName)
  };

Desde https://support.cloudbees.com/hc/en-us/articles/226941767-Groovy-to-list-all-jobs

Yo uso el complemento de monitoreo para esta tarea. Después de la instalación del complemento

1. Vaya a Administrar Jenkins> Monitoreo del maestro Hudson / Jenkins
2. Expanda los Detalles de hilos, el pequeño enlace azul en el lado derecho

3. Busque el nombre del trabajo que está colgado

   El nombre del hilo comenzará así

   Executor #2 for master : executing <your-job-name> #<build-number>

4. Haga clic en el botón rojo redondo a la derecha de la tabla de la línea que tiene su trabajo deseado

Una vez encontré una versión que no podía ser detenida por la "Consola de Script" Finalmente resolví el problema con estos pasos:

ssh onto the jenkins server
cd to .jenkins/jobs/<job-name>/builds/
rm -rf <build-number>
restart jenkins

La primera solución propuesta está bastante cerca. Si usa stop () en lugar de interrupt (), incluso mata los hilos fuera de control, que se ejecutan sin fin en un script de sistema maravilloso. Esto matará cualquier compilación que se ejecute para un trabajo. Aquí está el código:

Thread.getAllStackTraces().keySet().each() {
    if (it.name.contains('YOUR JOBNAME')) {  
      println "Stopping $it.name"
      it.stop()
    }
}

Sin tener que utilizar la consola de comandos o plugins adicionales, simplemente puede abortar una acumulación mediante la introducción de /stop, /termo /killdespués de la URL de construcción en su navegador.

Citando textualmente desde el enlace de arriba:

Los trabajos de canalización se pueden detener enviando una solicitud HTTP POST a los puntos finales de URL de una compilación.

• <BUILD ID URL> / stop - aborta una canalización.
• <URL DE IDENTIFICACIÓN DE CONSTRUCCIÓN> / term : finaliza por la fuerza una compilación (solo debe usarse si stop no funciona.
• <BUILD ID URL> / kill - mata con fuerza una tubería. Esta es la forma más destructiva de detener una tubería y solo debe usarse como último recurso.

Si tiene un trabajo de tubería imparable, intente lo siguiente:

1. Anule el trabajo haciendo clic en la X roja junto a la barra de progreso de la compilación
2. Haga clic en "Pausar / reanudar" en la compilación para pausar
3. Haga clic en "Pausar / reanudar" nuevamente para reanudar la compilación

Jenkins se dará cuenta de que el trabajo debe finalizar y detiene la compilación

El complemento Build-timeout puede ser útil para tales casos. Eliminará el trabajo automáticamente si tarda demasiado.

Supongo que es demasiado tarde para responder, pero ayudo a algunas personas.

1. Instale el complemento de monitoreo. ( http://wiki.jenkins-ci.org/display/JENKINS/Monitoring )
2. Vaya a jenkinsUrl / tracking / nodos
3. Vaya a la sección Hilos en la parte inferior.
4. Haga clic en el botón de detalles a la izquierda del maestro
5. Ordenar por tiempo de usuario (ms)
6. Luego mire el nombre del hilo, tendrá el nombre y el número de la compilación
7. Mátalo

No tengo suficiente reputación para publicar imágenes, lo siento.

Espero que pueda ayudar

La respuesta principal casi funcionó para mí, pero tuve un problema importante: tuve un número muy grande (~ 100) de trabajos de zombies debido a un reinicio de Jenkins particularmente mal programado, por lo que encontrar manualmente el nombre del trabajo y el número de compilación de cada uno y cada trabajo zombie y luego matarlos manualmente no era factible. Así es como encontré y maté automáticamente los trabajos de zombies:

Jenkins.instance.getItemByFullName(multibranchPipelineProjectName).getItems().each { repository->
  repository.getItems().each { branch->
    branch.builds.each { build->
      if (build.getResult().equals(null)) {
        build.doKill()
      }
    }
  }
}

Este script recorre todas las compilaciones de todos los trabajos y lo utiliza getResult().equals(null)para determinar si el trabajo ha finalizado o no. Una compilación que está en la cola pero que aún no se inició no se repetirá (ya que esa compilación no estará en job.builds), y una compilación que ya está terminada devolverá algo más que nullpara build.getResult(). Un trabajo en ejecución legítimo también tendrá un resultado de compilación null, así que asegúrese de no tener trabajos en ejecución que no desee eliminar antes de ejecutar esto.

Los múltiples bucles anidados son principalmente necesarios para descubrir cada rama / PR para cada repositorio en un proyecto de tubería multibranch; Si no está utilizando tuberías de múltiples ramas, simplemente puede recorrer todos sus trabajos directamente con algo como Jenkins.instance.getItems().each.

Miré la fuente de Jenkins y parece que lo que estoy tratando de hacer es imposible, porque la detención de un trabajo parece hacerse a través de una interrupción de Thread. Sin embargo, no tengo idea de por qué el trabajo está colgando ...

Editar:

Posibles razones para trabajos imparables:

• Si Jenkins está atrapado en un bucle infinito, nunca se puede abortar.
• si Jenkins está haciendo una red o E / S de archivo dentro de la máquina virtual Java (como una copia de archivo larga o una actualización SVN), no se puede cancelar.

Usualmente uso jenkins-cli en tales casos. Puedes descargar el jar desde una página http://your-jenkins-host:PORT/cli. Entonces corre

java -jar jenkins-cli.jar delete-builds name_of_job_to_delete hanging_job_number

Información auxiliar:

También puede pasar una variedad de compilaciones como 350:400. Ayuda general disponible ejecutando

java -jar jenkins-cli.jar help

Ayuda de comando de contexto para delete-buildspor

java -jar jenkins-cli.jar delete-builds

La respuesta de Alexandru Bantiuc funcionó bien para que detuviera la construcción, pero mis ejecutores seguían apareciendo ocupados. Pude borrar el estado de ejecutor ocupado usando lo siguiente

server_name_pattern = /your-servers-[1-5]/
jenkins.model.Jenkins.instance.getComputers().each { computer ->
  if (computer.getName().find(server_name_pattern)) {
    println computer.getName()
    execList = computer.getExecutors()      
    for( exec in execList ) {
      busyState = exec.isBusy() ? ' busy' : ' idle'
      println '--' + exec.getDisplayName() + busyState
      if (exec.isBusy()) {
        exec.interrupt()
      }
    }
  }
}

Tuve este mismo problema pero no había hilo de pila. Eliminamos el trabajo usando este fragmento en la consola de Jenkins. Reemplace el nombre del trabajo y construya el número con el suyo.

def jobname = "Main/FolderName/BuildDefinition"
def buildnum = 6
Jenkins.instance.getItemByFullName(jobname).getBuildByNumber(buildnum).delete(); 

Recientemente me encontré con un nodo / agente que tenía un ejecutor ocupado durante días por una compilación "X" de un trabajo de canalización, aunque esa página de trabajos afirmaba que la compilación "X" ya no existía (descartada después de 10 compilaciones posteriores (!), Como configurado en el trabajo de canalización). Verificó eso en el disco: la compilación "X" realmente había desaparecido.

La solución: fue el agente / nodo el que informó erróneamente que el ejecutor ocupado estaba ocupado ejecutando la compilación "X". Interrumpir el hilo de ese ejecutor lo ha liberado inmediatamente.

def executor = Jenkins.instance.getNode('NODENAME').computer.executors.find {
    it.isBusy() && it.name.contains('JOBNAME')
}

println executor?.name
if (executor?.isBusy()) executor.interrupt()

Otras respuestas consideradas:

• La respuesta de @cheffe: no funcionó (vea el siguiente punto y actualice a continuación).
• Las respuestas con Thread.getAllStackTraces() : sin hilo coincidente.
• La respuesta de @ levente-holló y todas las respuestas con getBuildByNumber() : no se aplicaron ya que la compilación ya no estaba allí.
• La respuesta de @austinfromboston: eso estuvo cerca de mis necesidades, pero también habría destruido cualquier otra versión que se esté ejecutando en este momento.

Actualización:
Experimenté nuevamente una situación similar, donde un Ejecutor estuvo ocupado durante días por una construcción de tubería terminada (aún existente). Este fragmento de código fue la única solución de trabajo.

Tuve el mismo problema en la última media hora ...

No pude eliminar una construcción zombie que se ejecuta en mi canalización de varias sucursales. Incluso el servidor se reinicia por la interfaz de usuario o incluso desde la línea de comandos a través de sudo service jenkins restart bloquear la ejecución ... La compilación no se podía detener ... Siempre reapareció.

Versión utilizada: Jenkins ver 2.150.2

Estaba muy molesto, pero ... al mirar el registro de la construcción, encontré algo interesante al final del registro:

Las partes marcadas en rojo son las "partes frustrantes" ... Como puede ver, siempre quise Abortar la construcción desde la interfaz de usuario, pero no funcionó ...

Pero hay un hipervínculo con texto Click here to forcibly terminate running steps... (primero verde) Ahora presioné el enlace ...) Después de la ejecución del enlace, Still pausedapareció un mensaje sobre otro enlaceClick here to forcibily kill entire build (segundo verde) Después de presionar este enlace también la construcción finalmente fue difícil delicado...

Entonces, esto parece funcionar sin ningún complemento especial (excepto el complemento de compilación multibranch-pipeline).

Tenía muchos trabajos de zombis, así que usé el siguiente script:

for(int x = 1000; x < 1813; x = x + 1) {
    Jenkins .instance.getItemByFullName("JOBNAME/BRANCH")
    .getBuildByNumber(x)
    .finish(hudson.model.Result.ABORTED, new java.io.IOException("Aborting build"))
}

Esto funciona para mí cada vez:

Thread.getAllStackTraces().keySet().each() {
if (it.name.contains('YOUR JOBNAME')) {  
  println "Stopping $it.name"
  it.stop()
}

Gracias a funql.org

Me ha sucedido el mismo problema dos veces, la única solución ha sido reiniciar el servidor Tomcat y reiniciar la compilación.

Una utilidad que escribí llamada jkillthread se puede usar para detener cualquier subproceso en cualquier proceso de Java, siempre que pueda iniciar sesión en la máquina que ejecuta el servicio con la misma cuenta.

SOLUCION MUY SIMPLE

La razón por la que veía este problema era un httpenlace incorrecto en la página, en lugar de httpseso debería detener el trabajo. Todo lo que necesita hacer es editar el onclickatributo en la página html, siguiendo

1. Abra un registro de consola del trabajo (canalización) que se bloqueó
2. Haga clic en lo que esté disponible para eliminar el trabajo (icono x, "Haga clic aquí para finalizar por la fuerza los pasos en ejecución", etc.) para obtener el enlace "Haga clic aquí para eliminar por completo la construcción completa" ( NO se podrá hacer clic en este momento)
3. Abra la consola del navegador ( use cualquiera de los tres para Chrome: F12; ctrl + shift + i; menú-> más herramientas-> herramientas de desarrollador )
4. Localice el enlace "Haga clic aquí para matar a la fuerza la construcción completa" manualmente o usando el botón "seleccionar un elemento en la página" de la consola
5. Haga doble clic en el onclickatributo para editar su valor.
6. Anexar sa httptenerhttps
7. Presione enter para enviar los cambios
8. Haga clic en el enlace "Haga clic aquí para matar por la fuerza la construcción completa"

Use la captura de pantalla como referencia

Usando la consola de Script en https: // my-jenkins / script

import hudson.model.Job
import org.jenkinsci.plugins.workflow.job.WorkflowRun

Collection<Job> jobs = Jenkins.instance.getItem('My-Folder').getAllJobs()
for (int i = 0; i < jobs.size(); i++) {
  def job = jobs[i]
  for (int j = 0; j < job.builds.size(); j++) {
    WorkflowRun build = job.builds[j]
    if (build.isBuilding()) {
      println("Stopping $job ${build.number}")
      build.setResult(Result.FAILURE)
    }
  }
}

Ninguna de estas soluciones funcionó para mí. Tuve que reiniciar la máquina en la que estaba instalado el servidor. El trabajo imposible de matar ya no existe.

Simplemente puede copiar el trabajo y eliminar el anterior. Si no importa que haya perdido los viejos registros de compilación.

Así es como solucioné este problema en la versión 2.100con Blue Ocean

• Los únicos complementos que he instalado son para bitbucket.
• Solo tengo un solo nodo.

sshen mi caja de Jenkins
cd ~/.jenkins(donde guardo Jenkins )
cd job/<job_name>/branches/<problem_branch_name>/builds
rm -rf <build_number>

Después de esto, puede cambiar opcionalmente el número en nextBuildNumber(Hice esto)

Finalmente, reinicié jenkins ( brew services restart jenkins) Este paso obviamente será diferente dependiendo de cómo administre e instale Jenkins.

Ingrese a la interfaz de usuario del océano azul. Intenta detener el trabajo desde allí.