How to exit from the Jenkins pipeline if a stage sets build fail/unstable status?

Question

I have a declarative Jenkins pipeline with stage1, stage2, stage3 and so on. I want to stop stage2 from running if stage1 sets the build unstable/fail.

I know I can stop the steps in stage1 from running using return when the build is not success but couldn't find a way where I can just exit the pipeline without running the stages below stage1

Here is what I have:

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

If params.name ==~ /z/ stage 3 will be executed skippping stage2

Note: I cannot include the steps in stage2/3/.. in stage1. It should be that way. Based on the build paramters stage2/3/4... will be called after stage1

Answer 1

The easiest way to skip remaining pipeline stages is to set up a variable which will control if following stages should be skipped or not. Something like this:

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

This is very simple example that sets skipRemainingStages to true at Stage 1 and Stage 2 and Stage 3 get skipped because expression in the when block does not evaluates to true.

Alternatively you can call error(String message) step to stop the pipeline and set its status to FAILED. For example, if your stage 1 calls error(msg) step like:

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

In this case pipeline stops whenever error(msg) step is found and all remaining stages are ignored (when blocks are not even checked).

Of course you can call error(msg) depending on some condition to make it FAILED only if specific conditions are met.