如何检测Jenkins声明式流水线中失败的并行阶段及异常post块问题

这其实是Jenkins Pipeline的默认设计行为，并不是你的配置有问题。我来给你拆解原因和解决办法：

为什么会出现这个现象？ #

当并行阶段里有任何一个子阶段失败时，整个父并行阶段的状态会被标记为FAILURE，而Jenkins默认情况下，每个阶段的post块判断条件是基于全局构建状态（currentBuild.result），而不是当前子阶段自身的状态。

简单说：只要整个并行阶段失败了，不管某个子阶段实际是成功还是失败，它的failure post块都会被触发——因为Jenkins认为“整个构建失败了”，所以所有绑定failure条件的post逻辑都会执行。

怎么让post块只在当前子阶段失败时触发？ #

核心思路是：让post块的判断逻辑基于当前子阶段的实际状态，而不是全局构建状态。这里有两种常用的实现方式：

方式1：直接查询阶段的实际状态 #

利用Jenkins提供的currentBuild.getStageResults()方法，获取所有阶段的运行状态，然后精准匹配当前子阶段的状态：

pipeline { 
    agent any 
    stages { 
        stage('Parallel steps') { 
            parallel { 
                stage('Successful stage') { 
                    steps { 
                        script { sleep 10 } 
                    } 
                    post { 
                        failure { 
                            script {
                                // 查找当前子阶段的实际状态
                                def currentStageStatus = currentBuild.getStageResults().find { 
                                    it.name == env.STAGE_NAME 
                                }.status
                                // 只有当子阶段真的失败时才执行逻辑
                                if (currentStageStatus == 'FAILURE') {
                                    echo('detected failure: Successful stage...')
                                }
                            }
                        } 
                    } 
                }
                stage('Failed stage') {
                    steps {
                        script { bat('exit /b 1') }
                    }
                    post {
                        failure {
                            script {
                                def currentStageStatus = currentBuild.getStageResults().find { 
                                    it.name == env.STAGE_NAME 
                                }.status
                                if (currentStageStatus == 'FAILURE') {
                                    echo('detected failure: Failed stage...')
                                }
                            }
                        }
                    }
                }
            } 
        } 
    } 
}

方式2：手动记录子阶段状态 #

在每个子阶段内部捕获运行结果，存入环境变量，然后在post块里检查这个变量：

pipeline { 
    agent any 
    stages { 
        stage('Parallel steps') { 
            parallel { 
                stage('Successful stage') { 
                    steps { 
                        script {
                            // 初始化阶段状态为成功
                            def stageStatus = 'SUCCESS'
                            try {
                                sleep 10
                                // 如果是失败场景，比如：bat('exit /b 1')
                            } catch (Exception e) {
                                stageStatus = 'FAILURE'
                                throw e // 抛出异常保持全局构建状态
                            } finally {
                                // 将状态存入唯一的环境变量（避免并行阶段变量冲突）
                                env["STAGE_STATUS_${env.STAGE_NAME}"] = stageStatus
                            }
                        }
                    } 
                    post { 
                        failure { 
                            script {
                                // 检查当前子阶段的记录状态
                                if (env["STAGE_STATUS_${env.STAGE_NAME}"] == 'FAILURE') {
                                    echo('detected failure: Successful stage...')
                                }
                            }
                        } 
                    } 
                }
                stage('Failed stage') {
                    steps {
                        script {
                            def stageStatus = 'SUCCESS'
                            try {
                                bat('exit /b 1')
                            } catch (Exception e) {
                                stageStatus = 'FAILURE'
                                throw e
                            } finally {
                                env["STAGE_STATUS_${env.STAGE_NAME}"] = stageStatus
                            }
                        }
                    }
                    post {
                        failure {
                            script {
                                if (env["STAGE_STATUS_${env.STAGE_NAME}"] == 'FAILURE') {
                                    echo('detected failure: Failed stage...')
                                }
                            }
                        }
                    }
                }
            } 
        } 
    } 
}

这两种方式都能让你实现“只有子阶段自身失败时，才执行对应的failure post块”的需求。

内容的提问来源于stack exchange，提问作者Jay Spang