Jenkins DSL 泛型多重促销

Question

我在没有任何 groovy 经验的情况下用 DSL 编写了我们项目的大部分 jobs/pipelines，但现在我陷入了无法解决的更高级问题。

我正在尝试实施一种方法，该方法可为工作增加 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])
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

它的工作方式，但是，如果我像这样添加另一个 'promotion' 闭包，这个例子将生成几乎相同的（名称和名称-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)

Jenkins DSL 泛型多重促销

Jenkins DSL generic multiple promotions

groovy

jenkins-job-dsl