não falhe a construção de jenkins se a execução do shell falhar

Como parte do meu processo de construção, estou executando um commit do git como uma etapa de execução do shell. No entanto, se não houver alterações no espaço de trabalho, o Jenkins falhará na compilação. Isso ocorre porque o git está retornando um código de erro quando não há alterações a serem confirmadas. Gostaria de abortar a compilação ou marcá-la como instável, se esse for o caso. Alguma ideia?

Para parar a execução adicional quando o comando falhar:

command || exit 0

Para continuar a execução quando o comando falhar:

command || true

Jenkins está executando as etapas de construção do shell usando /bin/sh -xepor padrão. -xsignifica imprimir todos os comandos executados. -esignifica sair com falha se algum dos comandos no script falhar.

Então, acho que o que aconteceu no seu caso é o comando git exit com 1 e, devido ao -eparâmetro padrão , o shell pega o código de saída diferente de 0, ignora o restante do script e marca a etapa como uma falha. Podemos confirmar isso se você puder postar seu script da etapa de construção aqui.

Se for esse o caso, você pode tentar colocar #!/bin/shpara que o script seja executado sem opção; ou faça uma set +ecoisa semelhante na etapa de compilação para substituir esse comportamento.

Editado: Outra coisa a ser observada é que, se o último comando no seu script de shell retornar código diferente de 0 , toda a etapa de compilação ainda será marcada como falha, mesmo com esta configuração. Nesse caso, você pode simplesmente colocar um echocomando no final para evitar isso.

Outra questão relacionada

Se não houver nada a ser enviado, o git retorna o status de saída 1. A etapa de execução da construção do shell é marcada como falha, respectivamente. Você pode usar a instrução OR || (tubo duplo).

git commit -m 'some messasge' || echo 'Commit failed. There is probably nothing to commit.'

Isto significa, execute o segundo argumento se falhar primeiro (status de saída retornado> 0). O segundo comando sempre retorna 0. Quando não há nada para pressionar (status de saída 1 -> execute o segundo comando), echo retornará 0 e a etapa de construção continuará.

Para marcar a compilação como instável, você pode usar a etapa de pós-compilação Jenkins Text Finder. Ele pode passar pela saída do console, corresponder ao padrão (seu eco) e marcar a construção como instável.

Há outra maneira fácil de dizer a Jenkins para não falhar. Você pode isolar seu commit em uma etapa de construção e configurar o shell para não falhar:

set +e
git commit -m "Bla."
set -e

Jenkins determina o sucesso / falha de uma etapa pelo valor de retorno da etapa. Para o caso de um shell, deve ser o retorno do último valor. Para os shells do Windows CMD e (POSIX) Bash, você deve poder definir o valor de retorno manualmente usando exit 0como o último comando.

Consegui fazer isso funcionar usando a resposta encontrada aqui:

Como git cometer nada sem um erro?

git diff --quiet --exit-code --cached || git commit -m 'bla'

Na pergunta (mais geral) do título - para impedir que Jenkins falhe, você pode impedir que ele veja o código de saída 1. Exemplo para ping:

bash -c "ping 1.2.3.9999 -c 1; exit 0"

E agora você pode, por exemplo, obter a saída do ping:

output=`bash -c "ping 1.2.3.9999 -c 1; exit 0"`

Claro que em vez de ping ...Você pode usar qualquer comando (s) - inclusive git commit.

https://jenkins.io/doc/pipeline/steps/workflow-durable-task-step/#sh-shell-script

se você incluir uma propriedade returnStatus: true, o retorno do shell será ignorado.

Você pode usar o plug-in Localizador de texto . Isso permitirá que você verifique se há uma expressão de sua escolha no console de saída e marque a compilação como Unstable.

Para vários comandos do shell, eu ignoro as falhas adicionando:

set +e commands true

Se você colocar esses comandos no bloco de shell:

false
true

sua compilação será marcada como falha (pelo menos 1 código de saída diferente de zero), para que você possa adicionar (defina + e) ​​para ignorá-la:

set +e
false
true

não falhará. No entanto, isso falhará mesmo com o (conjunto + e) ​​instalado:

set +e
false

porque o último comando do shell deve sair com 0.

O seguinte funciona para mercurial apenas confirmando se houver alterações. Portanto, a construção falha apenas se a confirmação falhar.

hg id | grep "+" || exit 0
hg commit -m "scheduled commit"

Outra resposta, com algumas dicas, pode ser útil para alguém:

lembre-se de separar seus comandos com a seguinte regra :

command1 && command2 - meios, que command2 será executado, somente se o sucesso command1

command1 ;command2 - significa que o comando 2 será executado apesar do resultado do comando1

por exemplo:

String run_tests = sh(script: "set +e && cd ~/development/tests/ && gmake test ;set -e;echo 0 ", returnStdout: true).trim()
println run_tests 

será executado com êxito set -ee com os echo 0comandos se gmake testfalharem (seus testes falharam), enquanto o seguinte código cortou:

String run_tests = sh(script: "set +e && cd ~/development/tests/ && gmake test && set -e && echo 0 ", returnStdout: true).trim()
println run_tests 

um pouco errado e comandos set -ee echo 0in && gmake test && set -e && echo 0serão ignorados, com a println run_testsdeclaração, porque falha gmake testabortará a construção de jenkins. Como solução alternativa, você pode alternar para returnStatus:true, mas perderá a saída do seu comando.

Esta resposta está correta, mas não especifica o || exit 0ou || trueentra no comando do shell . Aqui está um exemplo mais completo:

sh "adb uninstall com.example.app || true"

O acima funcionará, mas o seguinte falhará:

sh "adb uninstall com.example.app" || true

Talvez seja óbvio para os outros, mas perdi muito tempo antes de perceber isso.