webentwicklung-frage-antwort-db.com.de

Wie kann ein Pipeline-Job auf alle ausgelösten parallelen Jobs warten?

Ich habe ein Groovy-Skript als Teil des Pipeline-Jobs in Jenkins wie folgt:

node {
    stage('Testing') {
        build job: 'Test', parameters: [string(name: 'Name', value: 'Foo1')], quietPeriod: 2, wait: false
        build job: 'Test', parameters: [string(name: 'Name', value: 'Bar1')], quietPeriod: 2, wait: false
        build job: 'Test', parameters: [string(name: 'Name', value: 'Baz1')], quietPeriod: 2, wait: false
        build job: 'Test', parameters: [string(name: 'Name', value: 'Foo2')], quietPeriod: 2, wait: false
        build job: 'Test', parameters: [string(name: 'Name', value: 'Bar2')], quietPeriod: 2, wait: false
        build job: 'Test', parameters: [string(name: 'Name', value: 'Baz2')], quietPeriod: 2, wait: false
    }
}

dadurch werden mehrere andere Freestyle-Jobs parallel ausgeführt, da das Flag wait auf false gesetzt ist. Ich möchte jedoch, dass der Anruferauftrag beendet wird, wenn alle Aufträge abgeschlossen sind. Momentan löst der Pipeline-Job alle Jobs aus und beendet sich nach wenigen Sekunden selbst. Dies ist nicht das, was ich will, da ich die Gesamtzeit nicht verfolgen kann und ich nicht alle ausgelösten Jobs auf einmal abbrechen kann.

Wie kann ich das obige Skript korrigieren, damit der Pipeline-Job abgeschlossen ist, wenn alle parallelen Jobs abgeschlossen sind?

Ich habe versucht, Build-Jobs in waitUntil {}-Block zu packen, aber es hat nicht funktioniert.

7
kenorb

Sie sollten den Ausdruck pipeline parallel verwenden, der wartet, bis alle erzeugten Jobs/Unteraufgaben abgeschlossen sind:

stage('testing') {
    def branches = [:]

    for(i = 0; i < params.size(); i += 1) {
        def param = params[i]

        branches["Test${i}"] = {
            build job: 'Test', parameters: [string(name: 'Name', value: param)], quietPeriod: 2
        }
    }
    parallel branches
}

Weitere Beispiele finden Sie in Pipeline-Dokumenten unter jenkins.io

14
agg3l

Das funktioniert bei mir. Löst 3 Aufträge aus. Warten Sie, bis sie fertig sind. Achten Sie auf das zusätzliche "->", um den Groovy Closure festzulegen. Ich habe eine -> auf jeder Schleife und eine auf der parallelen Linie. Dies bedeutet, dass der Wert beim Ausführen des parallelen Abschnitts ausgewertet wird.

def jobsString = "job1,job2,job3"
ArrayList jobsList = jobsString.split('\\,')

def parallelJobs2Run = [:]
jobsList.each { job ->
    echo "Going to parallel for job ${job}"
    parallelJobs2Run["${job}"] = { ->
        echo "Calling job ${job}"
        jobResults=build job: "${pathJenkinsFolder}${job}",
        parameters: [
            string(name: 'param1', value: "${value1}"),
            string(name: 'param2', value: "${value2}")
        ],
        propagate: true,
        wait: true

        // List of values: https://stackoverflow.com/questions/46262862/how-to-i-get-the-url-of-build-triggered-with-build-step-on-jenkins
        buildNumber = ${jobResults.number}
        echo "${job} Build number |${buildNumber}| result: |${jobResults.result}|"
        echo "See details on: |${jobResults.absoluteUrl}|"
    }
};
parallel parallelJobs2Run
4
hagits

Laufen Sie einfach in das gleiche Problem und finden Sie eine funktionierende Lösung. Verwenden Sie einfach foreach.

stage('testing') {
    def jobs = [:]

    [1,2,3,4,5].each{
        i -> jobs["Test${i}"] = {
            build job: 'Test', 
            parameters: [string(name: 'theparam', value: "${i}")],
            quietPeriod: 2
        }
    }
    parallel jobs
}
3
hEngi

@ agg3l's Beispiel funktioniert jedoch nicht mit mehreren Jobs.

Map jobResults = [:]

Boolean failedJobs = false
def buildJobWithParams(def jobs_list, Map results) {
  def branches = [:]    
  for(job in jobs_list)
  {
    print job
    branches["Test-${job}"] = {
       def jobBuild = build job: job, propagate: false
       def jobResult = jobBuild.getResult()
       echo "Build of '${job}' returned result: ${jobResult}"
       results[job] = jobResult
    }
  }    
  return branches
}

stage('Run integration tests') {
      steps {
            def job_branch = buildJobWithParams(item_list, jobResults)
            print job_branch
            parallel job_branch
          }
}

Der item_list hat mehr als einen Job, er wird jedoch nur den letzten Job mehrmals ausführen.

2
GOGS K