如何在Jenkins Pipeline中设置并行步骤结果？解决Blue Ocean显示异常

我太懂你这种头疼的情况了——用全局类和变量搞定了最终构建结果的逻辑，但Blue Ocean的UI就是不买账，并行步骤的状态死活不对。本质上这是因为你只修改了顶层构建的全局结果，但每个并行分支的独立状态并没有同步更新，Blue Ocean是靠每个stage的本地上下文状态来渲染UI的，根本不会自动从全局结果反向同步分支状态。

给你两个核心解决思路，附修改后的示例：

1. 每个并行分支单独设置本地状态 #

不要只在全局汇总时改结果，要在每个分支执行完后，直接在分支上下文里更新currentBuild.result，这样Blue Ocean能实时捕获到该步骤的状态。

修改后的流水线示例：

pipeline {
    agent any
    // 全局变量用来汇总分支结果（可选）
    def testResults = [:]

    stages {
        stage('Parallel Test Suite') {
            parallel {
                stage('Unit Tests') {
                    steps {
                        script {
                            try {
                                sh 'echo "Running unit tests..." && exit 1' // 模拟测试失败
                                testResults['unit'] = true
                                currentBuild.result = 'SUCCESS' // 标记当前分支成功
                            } catch (Exception e) {
                                testResults['unit'] = false
                                currentBuild.result = 'FAILURE' // 标记当前分支失败
                                echo "Unit tests failed: ${e.getMessage()}"
                                // 可选：如果不想让全局构建直接失败，可以去掉throw e
                                throw e
                            }
                        }
                    }
                }
                stage('Integration Tests') {
                    steps {
                        script {
                            try {
                                sh 'echo "Running integration tests..."'
                                testResults['integration'] = true
                                currentBuild.result = 'SUCCESS'
                            } catch (Exception e) {
                                testResults['integration'] = false
                                currentBuild.result = 'FAILURE'
                                echo "Integration tests failed: ${e.getMessage()}"
                                throw e
                            }
                        }
                    }
                }
            }
            post {
                always {
                    script {
                        // 全局汇总逻辑：只要有一个分支失败，全局标记失败
                        def allPassed = testResults.values().every { it }
                        currentBuild.result = allPassed ? 'SUCCESS' : 'FAILURE'
                    }
                }
            }
        }
    }
}

2. 封装重复逻辑减少冗余 #

如果并行分支很多，不想写重复的try-catch，可以把测试执行和状态设置封装成函数：

def runTest(String testLabel, String testCmd) {
    try {
        sh "${testCmd}"
        currentBuild.result = 'SUCCESS'
        return true
    } catch (Exception e) {
        currentBuild.result = 'FAILURE'
        echo "${testLabel} failed: ${e.getMessage()}"
        return false
    }
}

pipeline {
    agent any
    def testResults = [:]

    stages {
        stage('Parallel Tests') {
            parallel {
                stage('Test A') {
                    steps {
                        script {
                            testResults['A'] = runTest('Test A', 'echo "Running Test A..." && exit 1')
                        }
                    }
                }
                stage('Test B') {
                    steps {
                        script {
                            testResults['B'] = runTest('Test B', 'echo "Running Test B..."')
                        }
                    }
                }
            }
            post {
                always {
                    script {
                        currentBuild.result = testResults.values().every { it } ? 'SUCCESS' : 'FAILURE'
                    }
                }
            }
        }
    }
}

关键提醒 #

Blue Ocean的并行步骤状态完全绑定到每个stage的currentBuild上下文，全局的currentBuild.result只会影响顶层构建的最终状态，不会回溯修改分支的状态。所以必须在每个分支里明确设置currentBuild.result，UI才会正确显示该步骤是成功还是失败，同时你依然可以通过全局变量汇总结果来控制最终构建状态。

内容的提问来源于stack exchange，提问作者Felyppe Rodrigues