Notre serveur Jenkins a un travail en cours depuis trois jours, mais ne fait rien. Cliquer sur le petit X dans le coin ne fait rien, et le journal de sortie de la console n'affiche rien non plus. J'ai vérifié nos serveurs de build et le travail ne semble pas du tout en cours d'exécution.

Existe-t-il un moyen de dire à jenkins que le travail est "terminé", en éditant un fichier ou un verrou ou quelque chose? Comme nous avons beaucoup de travaux, nous ne voulons pas vraiment redémarrer le serveur.

Allez dans "Gérer Jenkins"> "Console de script" pour exécuter un script sur votre serveur pour interrompre le fil suspendu.

Vous pouvez obtenir tous les threads en direct avec Thread.getAllStackTraces()et interrompre celui qui est suspendu.

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

METTRE À JOUR:

La solution ci-dessus utilisant des threads peut ne pas fonctionner sur les versions plus récentes de Jenkins. Pour interrompre les pipelines gelés, reportez-vous à cette solution (par alexandru-bantiuc ) et exécutez:

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

J'ai également eu le même problème et je l'ai résolu via Jenkins Console.

Allez dans «Gérer Jenkins»> «Console de script» et exécutez un script:

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

Vous aurez juste à spécifier votre JobName et JobNumber.

Dans le cas où vous avez un travail de pipeline multibranch (et que vous êtes un administrateur Jenkins), utilisez ce script dans la console de script Jenkins :

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

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

Si vous n'êtes pas sûr du nom complet (chemin) de la tâche, vous pouvez utiliser l'extrait de code suivant pour répertorier le nom complet de tous les éléments:

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

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

J'utilise le plugin de surveillance pour cette tâche. Après l'installation du plugin

1. Allez dans Gérer Jenkins> Surveillance du maître Hudson / Jenkins
2. Développez les détails de Threads, le petit lien bleu sur le côté droit

3. Recherchez le nom de la tâche bloquée

   Le nom du fil commencera comme ceci

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

4. Cliquez sur le bouton rond rouge à l'extrême droite dans le tableau de la ligne de la tâche souhaitée

Une fois que j'ai rencontré une construction qui ne pouvait pas être arrêtée par la "console de script". Enfin, j'ai résolu le problème avec ces étapes:

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

La première solution proposée est assez proche. Si vous utilisez stop () au lieu d'interruption (), cela tue même les threads emballés, qui s'exécutent à l'infini dans un script système groovy. Cela tuera toute construction exécutée pour un travail. Voici le code:

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

Sans avoir à utiliser la console de script ou plugins supplémentaires, vous pouvez simplement faire avorter une construction en entrant /stop, /termou/kill après l'URL de construction dans votre navigateur.

Citant textuellement à partir du lien ci-dessus:

Les tâches de pipeline peuvent être arrêtées en envoyant une requête HTTP POST aux points de terminaison d'URL d'une génération.

• <URL de l'ID BUILD> / stop - abandonne un pipeline.
• <URL ID BUILD> / terme - met fin de force à une construction (ne doit être utilisé que si stop ne fonctionne pas.
• <BUILD ID URL> / kill - arrête dur un pipeline. C'est le moyen le plus destructeur d'arrêter un pipeline et ne doit être utilisé qu'en dernier recours.

Si vous avez un travail de pipeline imparable, essayez ce qui suit:

1. Annulez le travail en cliquant sur le X rouge à côté de la barre de progression de la construction
2. Cliquez sur "Pause / Reprendre" sur la compilation pour mettre en pause
3. Cliquez à nouveau sur "Pause / Reprendre" pour reprendre la construction

Jenkins se rendra compte que le travail doit être terminé et arrête la construction

Le plugin Build-timeout peut être utile dans de tels cas. Cela supprimera automatiquement le travail si cela prend trop de temps.

Je suppose qu'il est trop tard pour répondre mais mon aide à certaines personnes.

1. Installez le plugin de surveillance. ( http://wiki.jenkins-ci.org/display/JENKINS/Monitoring )
2. Accédez à jenkinsUrl / monitoring / nodes
3. Accédez à la section Threads en bas
4. Cliquez sur le bouton Détails à gauche du master
5. Trier par temps utilisateur (ms)
6. Regardez ensuite le nom du thread, vous aurez le nom et le numéro de la construction
7. Tue le

Je n'ai pas assez de réputation pour publier des images désolé.

J'espère que ça peut aider

La meilleure réponse a presque fonctionné pour moi, mais j'avais un problème majeur: j'avais un très grand nombre (~ 100) de tâches zombies en raison d'un redémarrage de Jenkins particulièrement mal chronométré, donc trouver manuellement le nom du travail et le numéro de build de chacun et chaque travail de zombie, puis les tuer manuellement était irréalisable. Voici comment j'ai automatiquement trouvé et tué les emplois zombies:

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

Ce script effectue une boucle sur toutes les générations de tous les travaux et utilise getResult().equals(null)pour déterminer si le travail est terminé ou non. Une build qui est dans la file d'attente mais pas encore démarrée ne sera pas répétée (puisque cette build ne sera pas incluse job.builds), et une build qui est déjà terminée renverra autre chose que nullfor build.getResult(). Une tâche en cours d'exécution légitime aura également un résultat de construction null, alors assurez-vous que vous n'avez pas de tâches en cours d'exécution que vous ne voulez pas tuer avant de l'exécuter.

Les multiples boucles imbriquées sont principalement nécessaires pour découvrir chaque branche / PR pour chaque référentiel dans un projet Multibranch Pipeline; si vous n'utilisez pas de pipelines multibranches, vous pouvez simplement parcourir tous vos travaux directement avec quelque chose comme Jenkins.instance.getItems().each.

J'ai regardé la source Jenkins et il semble que ce que j'essaie de faire est impossible, car l'arrêt d'un travail semble se faire via une interruption de thread. Je n'ai aucune idée de la raison pour laquelle le travail est suspendu.

Éditer:

Raisons possibles des tâches imparables:

• si Jenkins est bloqué dans une boucle infinie, il ne peut jamais être abandonné.
• si Jenkins effectue une E / S réseau ou fichier dans la machine virtuelle Java (comme une longue copie de fichier ou une mise à jour SVN), il ne peut pas être abandonné.

J'utilise habituellement jenkins-cli dans de tels cas. Vous pouvez télécharger le pot à partir d'une page http://your-jenkins-host:PORT/cli. Puis cours

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

Infos auxiliaires:

Vous pouvez également passer une gamme de builds comme 350:400. Aide générale disponible en exécutant

java -jar jenkins-cli.jar help

Aide des commandes contextuelles pour delete-buildspar

java -jar jenkins-cli.jar delete-builds

La réponse d'Alexandru Bantiuc a bien fonctionné pour que j'arrête la construction, mais mes exécuteurs testamentaires étaient toujours aussi occupés. J'ai pu effacer le statut de l'exécuteur occupé en utilisant ce qui suit

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()
      }
    }
  }
}

Eu ce même problème mais il n'y avait pas de thread de pile. Nous avons supprimé le travail en utilisant cet extrait de code dans la console Jenkins. Remplacez jobname et buil dnumber par le vôtre.

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

Récemment, je suis tombé sur un nœud / agent qui avait un exécuteur occupé pendant des jours par une construction "X" d'un travail de pipeline, bien que cette page d'emplois déclarée que la construction "X" n'existait plus (abandonnée après 10 versions suivantes (!), Comme configuré dans le travail de pipeline). Vérifié que sur le disque: la construction "X" était vraiment partie.

La solution: c'est l'agent / le nœud qui a signalé à tort que l'exécuteur occupé était occupé à exécuter la construction "X". L'interruption du thread de cet exécuteur l'a immédiatement libéré.

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

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

Autres réponses envisagées:

• La réponse de @cheffe: n'a pas fonctionné (voir point suivant et mise à jour ci-dessous).
• Les réponses avec Thread.getAllStackTraces() : aucun fil correspondant.
• La réponse de @ levente-holló et toutes les réponses avec getBuildByNumber() : ne s'appliquaient pas car la construction n'était plus vraiment là!
• La réponse de @austinfromboston: cela s'est rapproché de mes besoins, mais cela aurait également détruit toutes les autres versions en cours d'exécution pour le moment.

Mise à jour:
J'ai de nouveau vécu une situation similaire, où un exécuteur était occupé pendant des jours par une construction de pipeline terminée (toujours existante). Cet extrait de code était la seule solution fonctionnelle.

J'ai eu le même problème au cours de la dernière demi-heure ...

Impossible de supprimer une version zombie exécutée dans mon pipeline multi-branches. Même le serveur redémarre par l'interface utilisateur ou même à partir de la ligne de commande via sudo service jenkins restart a bloqué l'exécution ... La construction n'était pas arrêtable ... Elle a toujours été récoltée.

Version utilisée: Jenkins ver 2.150.2

J'étais très ennuyé, mais ... en regardant dans le journal de la construction, j'ai trouvé quelque chose d'intéressant à la fin du journal:

Les parties marquées en rouge sont les "parties frustrantes" ... Comme vous pouvez le voir, j'ai toujours voulu abandonner la construction depuis l'interface utilisateur mais cela n'a pas fonctionné ...

Mais il y a un lien hypertexte avec du texte Click here to forcibly terminate running steps... (premier vert) Maintenant, j'ai appuyé sur le lien ...) Après l'exécution du lien, un message sur Still pausedest apparu avec un autre lienClick here to forcibily kill entire build (deuxième vert) Après avoir appuyé sur ce lien, la construction était finalement difficile tué...

Cela semble donc fonctionner sans plugins spéciaux (à l'exception du plugin de construction multibranch-pipeline lui-même).

J'avais beaucoup de tâches zombi, j'ai donc utilisé le script suivant:

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"))
}

Cela fonctionne pour moi à chaque fois:

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

Merci à funql.org

J'ai eu le même problème deux fois maintenant, le seul canapé correct a été de redémarrer le serveur tomcat et de redémarrer la construction.

Un utilitaire que j'ai écrit appelé jkillthread peut être utilisé pour arrêter n'importe quel thread dans n'importe quel processus Java, à condition que vous puissiez vous connecter à la machine exécutant le service sous le même compte.

SOLUTION TRÈS SIMPLE

La raison pour laquelle je voyais ce problème était un httplien incorrect sur la page au lieu de httpscela devrait arrêter le travail. Tout ce que vous avez à faire est de modifier l' onclickattribut dans la page html, en suivant

1. Ouvrez un journal de console du travail (pipeline) qui s'est bloqué
2. Cliquez sur ce qui est disponible pour tuer le travail (icône x, "Cliquez ici pour forcer l'arrêt des étapes en cours", etc.) pour obtenir le lien "Cliquez ici pour tuer de force toute la construction" visible (il ne sera PAS cliquable pour le moment)
3. Ouvrez la console du navigateur ( utilisez l'un des trois pour chrome: F12; ctrl + shift + i; menu-> plus d'outils-> outils de développement )
4. Recherchez manuellement le lien "Cliquez ici pour tuer de force toute la construction" ou utilisez le bouton "Sélectionnez un élément dans la page" de la console
5. Double-cliquez sur onclick attribut pour modifier sa valeur
6. Append sà httpavoirhttps
7. Appuyez sur Entrée pour soumettre les modifications
8. Cliquez sur le lien «Cliquez ici pour tuer de force toute la construction»

Utilisez une capture d'écran pour référence

Utilisation de la console de script sur 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)
    }
  }
}

Aucune de ces solutions n'a fonctionné pour moi. J'ai dû redémarrer la machine sur laquelle le serveur était installé. Le travail impossible à tuer est maintenant terminé.

Vous pouvez simplement copier le travail et supprimer l'ancien. Si cela n'a pas d'importance que vous ayez perdu les anciens journaux de construction.

Voici comment j'ai résolu ce problème dans la version 2.100avec Blue Ocean

• Les seuls plugins que j'ai installés sont pour bitbucket.
• Je n'ai qu'un seul nœud.

sshdans ma boîte Jenkins
cd ~/.jenkins(où je garde jenkins)
cd job/<job_name>/branches/<problem_branch_name>/builds
rm -rf <build_number>

Après cela, vous pouvez éventuellement changer le nombre dans nextBuildNumber(j'ai fait ceci)

Enfin, j'ai redémarré jenkins ( brew services restart jenkins) Cette étape sera évidemment différente selon la façon dont vous gérez et installez Jenkins.

Entrez dans l'interface utilisateur blue-ocean. Essayez d'arrêter le travail à partir de là.