Jenkins: Ignore failure in pipeline build step

In addition to simply making the stage pass, it is now also possible to fail the stage, but continue the pipeline and pass the build:

pipeline {
    agent any
    stages {
        stage('1') {
            steps {
                sh 'exit 0'
            }
        }
        stage('2') {
            steps {
                catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                    sh "exit 1"
                }
            }
        }
        stage('3') {
            steps {
                sh 'exit 0'
            }
        }
    }
}

In the example above, all stages will execute, the pipeline will be successful, but stage 2 will show as failed:

As you might have guessed, you can freely choose the buildResult and stageResult, in case you want it to be unstable or anything else. You can even fail the build and continue the execution of the pipeline.

Just make sure your Jenkins is up to date, since this feature is only available since "Pipeline: Basic Steps" 2.16 (May 14, 2019). Before that, catchError is still available but without parameters:

        steps {
            catchError {
                sh "exit 1"
            }
        }

I was looking for an answer for a long time and I found a hack for it! I put the try/catch block on the whole stage:

 try {
   stage('some-stage') {
         //do something
   }
 } catch (Exception e) {
    echo "Stage failed, but we continue"  
 }
 try {
   stage("some-other-stage") {  // do something }
 } catch (Exception e) {
    echo "Stage failed, but we still continue"
 }

As result you will get something like this:

This is still not ideal, but it gives the necessary results.

In recent versions it's possible to pass propogate=false option to build step.

link: https://jenkins.io/doc/pipeline/steps/pipeline-build-step/

example: build job:"jobName", propagate:false

Try this example:

stage('StageName1')
{
    steps
    {
        catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE')
        {
            SomeCodeThatCanBeErrored
        }
    }
}
stage('StageName2')
{
    steps
    {
        ContinueOtherCode
    }
}

For my decalartive pipeline I have found another solution:

stage('Deploy test')
 {
  steps
   {      
    bat returnStatus: true, script: 'sc stop Tomcat9'
    // The return value of the step will be the status code!
    // evaluate return status yourself, or ignore it
   }
 }

The same works for the sh command to execute scripts on Unix platforms.

The example ignores the return status, because the tomcat might be already stopped, because of a previously failed pipeline run.

See this post for a full discussion.

pipeline {
    agent any

    stages {
                stage('Stage') {
                    steps{
                        script{
                            jobresult = build(job: './failing-job',propagate:false).result
                            if(jobresult != 'SUCCESS'){
                                catchError(stageResult: jobresult, buildResult: 'UNSTABLE'){
                                    error("Downstream job failing-job failed.")
                                }
                            }
                        }
                    }
                }
    }
}

For all those that are wondering about how to set the result of a downstream job to the stage/build) Not the most graceful solution, but it gets the job done. Funny thing is that if this stageResult variable was available as a global variable or as a variable outside the catchError block these kinds of solutions would not be needed. Sadly it isn't, and the only way to set the stage result in a pipeline that I thought of is this way. The error() block is needed, otherwise catchError will not set the stageResult/buildResult(the catchError block requires an error, ofcourse).

you could put the step script inside "post" step, if if it's a teardown like step

code as below:

    post {
    always {
        script {
            try{
                echo 'put your alway need run scripts here....if it's a teardown like step'
            }catch (err) {
                echo 'here failed'
        }
        script{
            emailext (
                xxxx
            )
        }
    }

The cleanest and latest way would be:

stage('Integration Tests') {
    steps {
        script {
            warnError(message: "${STAGE_NAME} stage was unstable.", catchInterruptions: false) {
                // your scripts   
            }
        }
    }
}

Reference: https://www.jenkins.io/doc/pipeline/steps/workflow-basic-steps/#warnerror-catch-error-and-set-build-and-stage-result-to-unstable