Jenkins DSL通用多重晋升

Question

我用DSL编写了我们项目的大部分作业/管道，没有任何以前的常规经验，但现在我陷入了更高级的问题，我无法解决。

我正在尝试实现一种方法，可以在工作中增加1,2，n个晋升。在下面你可以看到一种完全有效的方法，它可以添加一个升级，我期望它能以这样的方式工作，如果我需要另一个方法的话，我只会调用两次这个方法，但是后来我遇到了我的问题--只有创建了最新版本的升级才会产生。

/** 
    * @param job           DSL job object
    * @param promotionName Name of the promotion
    * @param nextJobs      Comma seperated string of jobs to trigger when promotion is executed
    * @param deployers     Comma seperated string IDs that can execute promotion
    * @param params        Array of parameters to pass to the next job [0] = key, [1] = value.
*/
static void addPromotion(def job, String promotionName, String nextJobs, String deployers, String[][] params){
        job.properties {
            promotions {
                promotion {
                    name(promotionName)
                    icon("star-gold")
                    conditions {
                        manual(deployers)
                    }
                    actions {
                        downstreamParameterized {
                            trigger(nextJobs) {
                                parameters {
                                    for (String[] param : params){
                                        predefinedProp(param[0]+"=",param[1])
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

然而，如果我添加了另一个像这样的“促销”闭包，那么它的工作方式将产生几乎相同的促销(名称和名称-1)：

static void addPromotion(def job, String promotionName, String nextJobs, String deployers, String[][] params){
        job.properties {
            promotions {
                promotion {
                    name(promotionName)
                    icon("star-gold")
                    conditions {
                        manual(deployers)
                    }
                    actions {
                        downstreamParameterized {
                            trigger(nextJobs) {
                                parameters {
                                    for (String[] param : params){
                                        predefinedProp(param[0]+"=",param[1])
                                    }
                                }
                            }
                        }
                    }
                }
                promotion {
                    name("${promotionName}-1")
                    icon("star-gold")
                    conditions {
                        manual(deployers)
                    }
                    actions {
                        downstreamParameterized {
                            trigger(nextJobs) {
                                parameters {
                                    for (String[] param : params){
                                        predefinedProp(param[0]+"=",param[1])
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

是否有可能以某种方式重用闭包并从不同的方法中填充变量？或者其他的想法？

Answer 1

我就是这样解决的。

通用推广对象部分：

/**
* Adds 'promoted-builds' plugin configuration to job
**/
class Promotions {


    public def    job
    public String promotionName
    public String nextJobs
    public String deployers
    public String [][] params

     /** 
    * @param job           DSL job object
    * @param promotionName Name of the promotion
    * @param nextJobs      Comma seperated string of jobs to trigger when promotion is executed
    * @param deployers     Comma seperated string IDs that can execute promotion
    * @param params        Array of parameters to pass to the next job [0] = key, [1] = value.
    */

    public Promotions(Object jobName, String promotionName, String nextJobs, String deployers, String[][] params){
        this.job = jobName
        this.promotionName = promotionName
        this.nextJobs = nextJobs
        this.deployers = deployers
        this.params = params
    }

    static void addPromotions(Promotions ... jobPromotions){
        // Assuming the same job is provided as arguments
        jobPromotions[0].job.properties {
            promotions {
                for (Promotions jobPromotion : jobPromotions){
                    promotion {
                        name(jobPromotion.promotionName)
                        // star-gold, star-silver
                        icon("star-gold")
                        conditions {
                            manual(jobPromotion.deployers)
                        }
                        actions {
                            downstreamParameterized {
                                trigger(jobPromotion.nextJobs) {
                                    parameters {
                                        for (String[] param : jobPromotion.params){
                                            predefinedProp(param[0],param[1])
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

然后准备参数并将它们传递给升级构造函数，最后调用addPromotions()并将所有构造的对象传递给它：

    def nextJobs   = "${Configuration.repoName}-${branchName}-deploy-to-perf"        
    def deployers  = "developer"
    def params     = [["VERSION", "\${VERSION}"],
                     ["SOURCE_GIT_COMMIT", "\${SOURCE_GIT_COMMIT}"]] as String[][]
    def promo1 = new Promotions(job, "Promote to PERF", nextJobs, deployers, params)


    def nextJobs2   = "../master/${Configuration.repoName}-${branchName}-to-prod-dtr"        
    def deployers2  = "admin"
    def params2     = [["VERSION", "\${VERSION}"],
                      ["SOURCE_GIT_COMMIT", "\${SOURCE_GIT_COMMIT}"]] as String[][]
    def promo2 = new Promotions(job, "Promote to PROD", nextJobs2, deployers2, params2)

    Promotions.addPromotions(promo1, promo2)