访问上一个Jenkins构建中失败的阶段

我已经编写了一个Jenkinsfile脚本，该脚本获取当前Github提交中是否更新了文档或代码，并相应地启动所有阶段。如果只更新文档，我不会再次运行代码测试阶段

因此，如果以前的构建失败，而现在在当前的Git提交中，只更新文档，那么它将不会运行代码测试阶段。因此，我需要一种方法/方式来知道在上一次Jenkins构建期间哪个阶段失败，如果需要，运行当前Jenkins构建

---

例如，如果代码测试阶段在上一个版本中失败，我需要为此版本运行代码测试阶段，否则我可以只运行文档压缩阶段。

我认为它适合。使用上一次生成中的

buildVariables

，

timeout

\

input

如果需要更改某些内容，请尝试获取设置阶段状态。代码示例：

//你的工作
//使用try/catch块
def stageOneStatus；
def-stageTwoStatus；
def stageThreeStatus；
管道{
任何代理人
舞台{
阶段（“第一阶段”）{
//每个阶段的初始运行
当{expression{params.stageOne==“FAILURE”}
台阶{
剧本{
试一试{
//制造东西
}捕获（例外e）{
stageOneStatus=“失败”；
}
}
}
}
第二阶段（“第二阶段”）{
当{expression{params.stageTwo==“FAILURE”}
台阶{
剧本{
试一试{
//制造东西
}捕获（例外e）{
stageTwoStatus=“失败”；
}
}
}
}
第三阶段（“第三阶段”）{
当{expression{params.stageThree==“FAILURE”}
台阶{
剧本{
试一试{
//制造东西
}捕获（例外e）{
stageThreeStatus=“失败”；
}
}
}
}
}
}
//检查工作
def-pJob；
管道{
任何代理人
舞台{
//使用从生成中继承的变量运行作业
阶段（“继承作业”）{
台阶{
剧本{
pJob=build（作业：“yourJob”），参数：[
[$class:'StringParameterValue'，名称：'stageOne'，值：'FAILURE']，
[$class:'StringParameterValue'，名称：'StageTo'，值：'FAILURE']，
[$class:'StringParameterValue'，名称：'stageThree'，值：'FAILURE']
]，传播：false）
如果（pJob.result=='FAILURE'）{
错误（${pJob.projectName}失败）
}
}
}
}
//等待修复，然后重新运行作业
阶段（'等待修复'）{
超时（时间：24，单位：小时）{
输入“准备重新运行吗？”
}
}
//更改代码后重新运行作业
阶段（“重新运行作业”）{
台阶{
剧本{
建造(
工作：“你的工作”，
参数：[
[$class:'StringParameterValue'，名称：'stageOne'，值：pJob.buildVariables.stageOneStatus]，
[$class:'StringParameterValue'，name:'StageTo'，value:pJob.buildVariables.StageToStatus]，
[$class:'StringParameterValue'，名称：'stageThree'，值：pJob.buildVariables.stageThreeStatus]
]
)
}
}
}
}
}

作为从Jenkins build获取失败阶段的解决方法，可以使用此函数。我找不到比这更简单的方法了。但是这段代码需要在没有Groovy sandbox的情况下运行，或者需要将许多Jenkins方法签名列为白名单（这是不推荐的）。还必须安装blueocean插件

import io.jenkins.blueocean.rest.impl.pipeline.PipelineNodeGraphVisitor                                                                                                                                            
import io.jenkins.blueocean.rest.impl.pipeline.FlowNodeWrapper                                                                                                                                                     
import org.jenkinsci.plugins.workflow.flow.FlowExecution                                                                                                                                                           
import org.jenkinsci.plugins.workflow.graph.FlowNode                                                                                                                                                               
import org.jenkinsci.plugins.workflow.job.WorkflowRun                                                                                                                                                              

@NonCPS                                                                                                                                                                                                            
List getFailedStages(WorkflowRun run) {                                                                                                                                                                            
    List failedStages = []                                                                                                                                                                                         
    FlowExecution exec = run.getExecution()                                                                                                                                                                        
    PipelineNodeGraphVisitor visitor = new PipelineNodeGraphVisitor(run)                                                                                                                                           
    def flowNodes = visitor.getPipelineNodes()                                                                                                                                                                     

    for (node in flowNodes) {                                                                                                                                                                                      
        if (node.getType() != FlowNodeWrapper.NodeType.STAGE ) { continue; }                                                                                                                                       
        String nodeName = node.getDisplayName()                                                                                                                                                                    
        def nodeResult = node.getStatus().getResult()                                                                                                                                                              
        println String.format('{"displayName": "%s", "result": "%s"}',                                                                                                                                             
                              nodeName, nodeResult)                                                                                                                                                                
        def resultSuccess = io.jenkins.blueocean.rest.model.BlueRun$BlueRunResult.SUCCESS                                                                                                                          
        if (nodeResult != resultSuccess) {                                                                                                                                                                         
            failedStages.add(nodeName)                                                                                                                                                                             
        }                                                                                                                                                                                                          
    }                                                                                                                                                                                                              
    return failedStages                                                                                                                                                                                            
}                                                                                                                                                                                                                  

// Ex. Get last build of "test_job"                                                                                                                                                                                
WorkflowRun run = Jenkins.instance.getItemByFullName("test_job")._getRuns()[0]                                                                                                                                     
failedStages = getFailedStages(run)