webentwicklung-frage-antwort-db.com.de

Wie kann die Jenkins-Pipeline verlassen werden, wenn der Build-Status einer Stufe fehlerhaft/instabil ist?

Ich habe eine deklarative Jenkins-Pipeline mit stage1, stage2, stage3 und so weiter. Ich möchte stage2 von der Ausführung abhalten, wenn stage1 den Build instabil/fail setzt.

Ich weiß, ich kann die Ausführung von stage1 mit return stoppen, wenn der Build nicht erfolgreich ist, aber keinen Weg finden konnte, auf dem ich einfach die Pipeline beenden kann, ohne die folgenden Schritte auszuführen. stage1

Folgendes habe ich:

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

Wenn params.name ==~ /z/ Stufe 3 ausgeführt wird, wird Sprungstufe2 ausgeführt

Hinweis: Ich kann die Schritte in stage2/3/.. nicht in stage1 aufnehmen. Es sollte so sein. Basierend auf den Build-Parametern wird stage2/3/4 ... nach stage1 aufgerufen

jenkinsgroovyjenkins-pipelinejenkins-groovy
4
user6348718

Der einfachste Weg, die verbleibenden Pipeline-Stufen zu überspringen, besteht darin, eine Variable einzurichten, die steuert, ob die folgenden Stufen übersprungen werden sollen oder nicht. Etwas wie das:

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

Dies ist ein sehr einfaches Beispiel, bei dem skipRemainingStages bei Stage 1 auf wahr gesetzt wird und Stage 2 und Stage 3 get übersprungen werden, da der Ausdruck im when-Block nicht als wahr ausgewertet wird.

 enter image description here

Alternativ können Sie error(String message) step aufrufen, um die Pipeline anzuhalten und ihren Status auf FAILED zu setzen. Zum Beispiel, wenn Ihre Stufe 1 den Schritt error(msg) wie folgt aufruft:

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

In diesem Fall wird die Pipeline angehalten, wenn error(msg) step gefunden wird und alle verbleibenden Stufen ignoriert werden (when-Blöcke werden nicht einmal geprüft).

 enter image description here

Natürlich können Sie error(msg) abhängig von einer bestimmten Bedingung aufrufen, um FAILED nur dann festzulegen, wenn bestimmte Bedingungen erfüllt sind.

2
Szymon Stepniak

Sie können auch einfach eine Ausnahme auslösen. Dadurch wird der Build abgebrochen. Das einfache Festlegen des Buildstatus in einer catch-Klausel funktioniert ziemlich gut .. Sie können auch eine benutzerdefinierte Logik in den finally-Block zum Senden von Benachrichtigungen für Buildstatusänderungen (E-Mail, Slack-Nachricht) einfügen usw)

Also vielleicht so etwas wie das Folgende. HINWEIS: Ich habe einige davon aus einer vorhandenen Jenkins-Datei kopiert. Also nicht 100% sicher, dass dies die gleiche Syntax ist, die Sie verwendet haben:

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

Sie können post in einer Phase wie folgt verwenden: 

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

Dadurch wird der Build abgebrochen und der Job wird nicht weiter ausgeführt.

0
awefsome