web-dev-qa-db-fra.com

Comment quitter le pipeline Jenkins si une étape définit le statut échec/instable de la construction?

J'ai un pipeline déclaratif Jenkins avec stage1, stage2, stage3 et ainsi de suite. Je veux arrêter l'exécution de stage2 si stage1 définit la construction unstable/fail.

Je sais que je peux empêcher les étapes de stage1 de fonctionner à l'aide de return lorsque la construction échoue, mais je ne trouve pas le moyen de quitter le pipeline sans exécuter les étapes ci-dessous stage1

Voici ce que j'ai

    stage('stage1') {
            steps {
                script{
                    //somesteps
                    if ("${stdout}" == "1"){
                    currentBuild.result = 'UNSTABLE'
                    return
                    } //if
                    //somesteps
            } //script
        } //steps
    } //stage

    // run only when stage1 is success
    stage('stage2'){
        when {
            expression { 
             params.name ==~ /x|y/
            }
        }
        steps {
            script{
                    //stage2 steps
            }
        }
    }

Si params.name ==~ /z/ stage 3 sera exécuté en sautant stage2

Remarque: je ne peux pas inclure les étapes de stage2/3/.. dans stage1. Ce devrait être comme ça. Basé sur les paramètres de construction stage2/3/4 ... sera appelé après stage1

jenkinsgroovyjenkins-pipelinejenkins-groovy
4
user6348718

Le moyen le plus simple d'ignorer les étapes restantes du pipeline consiste à définir une variable permettant de déterminer si les étapes suivantes doivent être ignorées ou non. Quelque chose comme ça:

def skipRemainingStages = false

pipeline {
    agent any

    stages {
        stage("Stage 1") {
            steps {
                script {
                    skipRemainingStages = true

                    println "skipRemainingStages = ${skipRemainingStages}"
                }
            }
        }

        stage("Stage 2") {
            when {
                expression {
                    !skipRemainingStages
                }
            }

            steps {
                script {
                    println "This text wont show up...."
                }
            }
        }

        stage("Stage 3") {
            when {
                expression {
                    !skipRemainingStages
                }
            }

            steps {
                script {
                    println "This text wont show up...."
                }
            }
        }
    }
}

Ceci est un exemple très simple qui définit skipRemainingStages sur true à Stage 1 et que Stage 2 et Stage 3 sont ignorés, car l'expression du bloc when n'est pas évaluée à true.

 enter image description here

Sinon, vous pouvez appeler error(String message) pour arrêter le pipeline et définir son statut sur FAILED. Par exemple, si votre étape 1 appelle error(msg) étape comme suit:

stage("Stage 1") {
    steps {
        script {
            error "This pipeline stops here!"
        }
    }
}

Dans ce cas, le pipeline s’arrête chaque fois que l’étape error(msg) est trouvée et que toutes les étapes restantes sont ignorées (les blocs when ne sont même pas vérifiés).

 enter image description here

Vous pouvez bien entendu appeler error(msg) en fonction de certaines conditions pour la rendre FAILED uniquement si des conditions spécifiques sont remplies.

2
Szymon Stepniak

Vous pouvez également simplement lancer une exception. Cela annulera la construction . En fait, définir simplement le statut de la construction dans une clause catch fonctionnera plutôt bien . Vous pouvez également ajouter une logique personnalisée dans le bloc finally pour l'envoi de notifications pour les modifications de l'état de la construction etc)

Alors peut-être quelque chose comme ce qui suit. NOTE: J'ai copié une partie de cela à partir d'un fichier Jenkins existant. Donc, pas tout à fait sûr que c'est la même syntaxe que vous utilisiez:

pipeline {
   try {
      stages {
         stage("stage1") {
             if (something) {
               throw new RuntimeException("Something went wrong")
             }
         }

         stage("stage2") {

         }

      } 
  } catch (e) {
     currentBuild.result = "FAILED"
     throw e
  } 
}
1
Steve Sowerby

Vous pouvez utiliser post dans une étape pour sortir comme suit: 

pipeline {
    stages {
        stage('stage 1') {
            steps {
                 //step 1
            }
        }
        stage('stage 2') {
            steps {
                script{ 
                    //step 2
                }
            }
            post{
                success {
                }
                failure {
                    script{
                        sh "exit 1"
                        //or
                        error "Failed, exiting now..."
                    }
                }
                aborted {
                }
                unstable {
                    script{
                           sh "exit 1"
                          //or
                          error "Unstable, exiting now..."                    
                     }
                }
            }
        }
    }
}

Cela annulera la construction et le travail ne sera plus exécuté.

0
awefsome