Nosso servidor Jenkins tem um trabalho em execução há três dias, mas não está fazendo nada. Clicar no pequeno X no canto não faz nada, e o log de saída do console também não mostra nada. Eu verifiquei nossos servidores de compilação e o trabalho não parece estar em execução.

Existe uma maneira de dizer a Jenkins que o trabalho está "concluído", editando algum arquivo ou bloqueio ou algo assim? Como temos muitos trabalhos, não queremos realmente reiniciar o servidor.

Vá para "Gerenciar Jenkins"> "Console de scripts" para executar um script no servidor para interromper o encadeamento.

Você pode obter todos os threads ativos Thread.getAllStackTraces()e interromper o que está pendurado.

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

ATUALIZAR:

A solução acima usando threads pode não funcionar nas versões mais recentes do Jenkins. Para interromper pipelines congelados, consulte esta solução (por alexandru-bantiuc ) e execute:

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

Eu também tive o mesmo problema e o corrigi via Jenkins Console.

Vá para "Gerenciar Jenkins"> "Console de scripts" e execute um script:

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

Você terá que especificar seu JobName e JobNumber.

Caso você tenha um emprego de Pipeline Multibranch (e você seja um administrador da Jenkins), use no Jenkins Script Console 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

Se você não tiver certeza de qual é o nome completo (caminho) do trabalho, use o seguinte snippet para listar o nome completo de todos os itens:

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

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

Eu uso o plug - in de monitoramento para esta tarefa. Após a instalação do plugin

1. Vá para Gerenciar Jenkins> Monitoramento do mestre Hudson / Jenkins
2. Expanda os Detalhes dos Encadeamentos, o pequeno link azul no lado direito

3. Procure o nome do trabalho suspenso

   O nome do segmento começará assim

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

4. Clique no botão redondo e vermelho à direita na tabela da linha que o trabalho desejado possui

Uma vez encontrei uma compilação que não podia ser interrompida pelo "Script Console". Finalmente, resolvi o problema com estas etapas:

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

A primeira solução proposta está bem próxima. Se você usar stop () em vez de interrupção (), ele mata threads em fuga, que são executados infinitamente em um script de sistema groovy. Isso matará qualquer construção executada para um trabalho. Aqui está o código:

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

Se você tiver um trabalho de pipeline imparável, tente o seguinte:

1. Interrompa o trabalho clicando no X vermelho ao lado da barra de progresso da construção
2. Clique em "Pausar / retomar" na compilação para pausar
3. Clique em "Pausar / retomar" novamente para retomar a compilação

Jenkins perceberá que o trabalho deve ser encerrado e interrompe a construção

Sem ter que usar o console de script ou plugins adicionais, você pode simplesmente abortar uma compilação digitando /stop, /termou /killapós o URL de construção no seu browser.

Citando literalmente a partir do link acima:

Os trabalhos de pipeline podem ser interrompidos enviando uma solicitação HTTP POST aos pontos de extremidade da URL de uma construção.

• <BUILD ID URL> / stop - interrompe um pipeline.
• <BUILD ID URL> / term - finaliza forçosamente uma compilação (só deve ser usada se stop não funcionar.
• <BUILD ID URL> / kill - mata com força um pipeline. Essa é a maneira mais destrutiva de interromper um pipeline e deve ser usada apenas como último recurso.

O plug-in de tempo limite de compilação pode ser útil para esses casos. Ele matará o trabalho automaticamente se demorar demais.

Eu acho que é tarde demais para responder, mas minha ajuda a algumas pessoas.

1. Instale o plug-in de monitoramento. ( http://wiki.jenkins-ci.org/display/JENKINS/Monitoring )
2. Acesse jenkinsUrl / Monitoring / Nodes
3. Vá para a seção Threads na parte inferior
4. Clique no botão de detalhes à esquerda do mestre
5. Classificar por Tempo do usuário (ms)
6. Então olhe para o nome do thread, você terá o nome e o número da compilação
7. Mate isso

Não tenho reputação suficiente para postar imagens, desculpe.

Espero que possa ajudar

A resposta principal quase funcionou para mim, mas eu tinha um grande problema: eu tinha um número muito grande (~ 100) de trabalhos de zumbi devido a um reinício Jenkins particularmente em um período de tempo insuficiente, encontrando manualmente o nome do trabalho e o número de compilação de cada um. todo trabalho de zumbi e depois matá-los manualmente era inviável. Veja como eu automaticamente encontrei e matei os trabalhos de zumbi:

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

Esse script faz um loop em todas as compilações de todos os trabalhos e usa getResult().equals(null)para determinar se o trabalho foi ou não concluído. Uma construção que está na fila, mas ainda não foi iniciada, não será repetida (uma vez que essa construção não estará job.builds), e uma construção concluída já retornará algo diferente de nullpara build.getResult(). Um trabalho legitimamente em execução também terá um resultado de compilação null, portanto, verifique se você não possui trabalhos em execução que não deseja eliminar antes de executá-lo.

Os vários loops aninhados são principalmente necessários para descobrir todas as ramificações / PR de todos os repositórios em um projeto Multibranch Pipeline; se você não estiver usando pipelines multibranch, poderá percorrer todos os seus trabalhos diretamente com algo parecido Jenkins.instance.getItems().each.

Eu olhei para a fonte Jenkins e parece que o que estou tentando fazer é impossível, porque a interrupção de um trabalho parece ser feita através de uma interrupção do Thread. Eu não tenho idéia do porquê o trabalho está pendurado ..

Editar:

Possíveis razões para trabalhos imparáveis:

• se Jenkins estiver preso em um loop infinito, nunca poderá ser abortado.
• se o Jenkins estiver executando uma E / S de rede ou de arquivo na Java VM (como cópia longa do arquivo ou atualização do SVN), ela não poderá ser abortada.

Eu costumo usar Jenkins-cli nesses casos. Você pode baixar o jar de uma páginahttp://your-jenkins-host:PORT/cli . Então corra

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

Informações auxiliares:

Você também pode passar por várias versões, como 350:400 . Ajuda geral disponível executando

java -jar jenkins-cli.jar help

Ajuda de comando de contexto para delete-buildspor

java -jar jenkins-cli.jar delete-builds

A resposta de Alexandru Bantiuc funcionou bem para eu interromper a compilação, mas meus executores ainda estavam aparecendo como ocupados. Consegui limpar o status de executor ocupado usando o seguinte

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

Teve esse mesmo problema, mas não havia thread de pilha. Excluímos o trabalho usando esse snippet no Jenkins Console. Substitua jobname e construa dnumber pelo seu.

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

Recentemente, deparei com um nó / agente que tinha um executor ocupado por dias por uma compilação "X" de uma tarefa de pipeline, embora a página de tarefas reivindicasse a compilação "X" não existisse mais (descartada após 10 compilações subsequentes (!), Como configurado no trabalho de pipeline). Verificou que no disco: a compilação "X" se foi realmente.

A solução: foi o agente / nó que relatou erroneamente que o executor ocupado estava ocupado executando a compilação "X". A interrupção do encadeamento do executor a liberou imediatamente.

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

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

Outras respostas consideradas:

• A resposta do @cheffe: não funcionou (veja o próximo ponto e atualize abaixo).
• As respostas com Thread.getAllStackTraces(): nenhum tópico correspondente.
• A resposta de @ levente-holló e todas as respostas com getBuildByNumber(): não se aplicaram, pois a compilação não estava mais lá!
• A resposta de @austinfromboston: chegou perto das minhas necessidades, mas também teria destruído qualquer outra compilação em execução no momento.

Atualização:
Experimentei novamente uma situação semelhante, em que um Executor foi ocupado por dias por uma construção de pipeline concluída (ainda existente). Esse trecho de código foi a única solução funcional.

Eu tive o mesmo problema na última meia hora ...

Não foi possível excluir uma compilação de zumbis em execução no meu pipeline de várias ramificações. Mesmo o servidor reinicia pela interface do usuário ou mesmo pela linha de comando via sudo service jenkins restart bloqueou a execução ... A compilação não foi interrompida ... Sempre reapareceu.

Versão usada: Jenkins ver 2.150.2

Fiquei muito chateado, mas ... ao olhar para o log da compilação, encontrei algo interessante no final do log:

As partes marcadas em vermelho são as "partes frustrantes" ... Como você pode ver, eu sempre quis abortar a construção da interface do usuário, mas não funcionou ...

Mas existe um hiperlink com texto Click here to forcibly terminate running steps... (primeiro verde) Agora eu pressionei o link ...) Após a execução do link, uma mensagem Still pausedapareceu com outro Link Click here to forcibily kill entire build(segundo verde) Depois de pressionar esse link, a construção finalmente ficou difícil morto ...

Portanto, isso parece funcionar sem nenhum plug-in especial (exceto o próprio plug-in de compilação multibranch-pipeline).

Eu tinha muitos empregos de zombi, então usei o seguinte 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"))
}

Isso funciona para mim sempre:

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

Obrigado ao funql.org

Já tive o mesmo problema duas vezes agora, o único sofá de correção foi reiniciar o servidor tomcat e reiniciar a compilação.

Um utilitário que escrevi chamado jkillthread pode ser usado para interromper qualquer encadeamento em qualquer processo Java, desde que você possa efetuar login na máquina que está executando o serviço na mesma conta.

SOLUÇÃO MUITO SIMPLES

O motivo pelo qual eu estava vendo esse problema era um httplink incorreto na página, em vez de httpsinterromper o trabalho. Tudo o que você precisa fazer é editar o onclickatributo na página html, seguindo

1. Abra um log do console do trabalho (pipeline) que foi interrompido
2. Clique no que estiver disponível para eliminar o trabalho (ícone x, "Clique aqui para terminar forçosamente as etapas em execução" etc.) para obter o link "Clique aqui para eliminar forçosamente a compilação inteira" visível ( NÃO é será possível clicar no momento)
3. Abra o console do navegador ( use qualquer um dos três no chrome: F12; ctrl + shift + i; menu-> mais ferramentas-> ferramentas de desenvolvedor )
4. Localize o link "Clique aqui para eliminar forçosamente toda a compilação" manualmente ou usando o botão "selecionar um elemento na página" do console
5. Clique duas vezes em onclick atributo para editar seu valor
6. Anexar sa httpterhttps
7. Pressione Enter para enviar as alterações
8. Clique no link "Clique aqui para matar à força a compilação inteira"

Usar captura de tela para referência

Usando o console Script em 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)
    }
  }
}

Nenhuma dessas soluções funcionou para mim. Eu tive que reiniciar a máquina em que o servidor estava instalado. O trabalho inábil agora se foi.

Você pode simplesmente copiar o trabalho e excluir o antigo. Se não importa que você tenha perdido os logs de compilação antigos.

Aqui está como eu corrigi esse problema na versão 2.100com Blue Ocean

• Os únicos plugins que eu instalei são para o bitbucket.
• Eu só tenho um único nó.

sshna minha caixa Jenkins
cd ~/.jenkins(onde eu mantenho Jenkins)
cd job/<job_name>/branches/<problem_branch_name>/builds
rm -rf <build_number>

Depois disso, é possível alterar opcionalmente o número em nextBuildNumber(fiz isso).

Finalmente, reiniciei o jenkins ( brew services restart jenkins) Esta etapa obviamente será diferente dependendo de como você gerencia e instala o Jenkins.

Digite a interface do usuário do blue-ocean. Tente parar o trabalho a partir daí.