Zugriff erstellt von parallele Ausführung in Jenkins 2.0 Pipeline

Question

Ich verwende derzeit das Build Flow Plugin, das zugunsten von Pipelines in Jenkins 2.0 aufgegeben wurde.

In einige Probleme laufen, unsere bestehenden Arbeitsplätze mit den neuen Pipelines wieder aufzubauen.

Derzeit habe ich Code wie folgt aus:

ignore(FAILURE) { 
    join = parallel([ 
    job1: {build('job1')}, 
    job2: {build('job2')}, 
    job3: {build('job3')} 
    ]) 
} 
results = [join.job1.result.toString(), join.job2.result.toString(), join.job2.result.toString()] 

if(join.job1.result.toString() == 'SUCCESS') { 
    buildList << join.job1.lastBuild.getDisplayName() 
} 

Das Ziel hier ist es, mehrere bestehende Aufträge parallel und dann Zugriff auf Informationen über die Builds, die abgeschlossen zu laufen. Dies hat ohne Probleme im Build Flow Plugin funktioniert.

Ich konnte keine Möglichkeit finden, mit den neuen Pipelines auf diese Daten zuzugreifen.

echo 'Checking streams for latest builds' 
join = [:] 

join['Job1'] = { build job: 'Job1', parameters: [[$class: 'StringParameterValue', name: 'TimeWindow', value: '1200']], propagate: false} 
join['Job2'] = { build job: 'Job2', parameters: [[$class: 'StringParameterValue', name: 'TimeWindow', value: '1200']], propagate: false} 
join['Job3'] = { build job: 'Job3', parameters: [[$class: 'StringParameterValue', name: 'TimeWindow', value: '1200']], propagate: false} 

parallel join 

A Dump join [ 'Job1'] gibt keinen Zugang zu einem AbstractBuild oder ähnlichen, die Art und Weise der Build-Flow-Plugin macht. Stattdessen zeigt es:

<org.jenkinsci.plugins.workflow.cps.CpsClosure2@2eac6ed9 
def=com.cloudbees.groovy.cps.impl.CpsClosureDef@59647704 
delegate=WorkflowScript@3aa1807f 
owner=WorkflowScript@3aa1807f 
thisObject=WorkflowScript@3aa1807f 
resolveStrategy=0 
directive=0 
parameterTypes=null 
maximumNumberOfParameters=0 
bcw=null> 

die neuen Pipelines verwenden, ist es eine Möglichkeit, den Zugriff auf Daten wie job1.result, job1.lastBuild, job1.lastBuild.getDisplayName()?

Answer 1

können Sie diese Daten zugreifen, indem Sie die Jenkins API nach dem parallel Schritt mit:

Jenkins.instance.getItemByFullName('Job1').lastBuild 

Answer 2

ein wenig spät, aber Sie können auch die runWrapper Objekt durch build Befehl in der Schließung und legen Sie sie in einer Karte zurück definieren außerhalb des Befehls parallel definiert.

Hier ist ein Beispiel. Hinweis: Ich verwende propagate: false, so dass Ausnahmen (JUnit Testfehler usw.) nicht ausgelöst werden. Sie müssten entscheiden, wie Sie Ausnahmen behandeln wollen, try/catch/finally usw.

Beispiel Pipeline Job (muss mit einem String param commandStr parametriert werden) auszuführen:

env.PASSED_CMD="${params.commandStr}" 
stage('command-exec') { 
    node { 
     sh "${commandStr}" 
    } 
} 

Ausführen Job (config):

buildRuns = [:] 
buildResults = [:] 
def buildClosure(String jobKey, String paramAValue) { 
    return { 
     def runWrapper = build(
      job: 'command-test-job', 
      propagate: false, 
      parameters: [[$class: 'StringParameterValue', name: 'commandStr', value: paramAValue]] 
     ) 
     buildResults."$jobKey" = runWrapper 
    } 
} 
buildRuns."job1" = buildClosure("job1", "echo 'HI' && exit 0") 
buildRuns."job2" = buildClosure("job2", "echo 'HO' && exit 0") 
parallel buildRuns 
for(k in buildRuns.keySet()) { 
    def runResult = buildResults."$k" 
    echo "$k -> ${runResult.result}" 
    echo "$k -> ${runResult.buildVariables.PASSED_CMD}" 
} 

Die Build-Protokoll zeigt:

[Pipeline] parallel 
[Pipeline] [job1] { (Branch: job1) 
[Pipeline] [job2] { (Branch: job2) 
[Pipeline] [job1] build (Building command-test-job) 
[job1] Scheduling project: command-test-job 
[Pipeline] [job2] build (Building command-test-job) 
[job2] Scheduling project: command-test-job 
[job1] Starting building: command-test-job #7 
[job2] Starting building: command-test-job #8 
[Pipeline] [job2] } 
[Pipeline] [job1] } 
[Pipeline] // parallel 
[Pipeline] echo 
job1 -> SUCCESS 
[Pipeline] echo 
job1 -> echo 'HI' && exit 0 
[Pipeline] echo 
job2 -> SUCCESS 
[Pipeline] echo 
job2 -> echo 'HO' && exit 0 
[Pipeline] End of Pipeline 
Finished: SUCCESS 

Answer 3

Th ist sehr ähnlich zu Steve-B's Answer, aber Sie müssen den Runwrapper nicht wirklich explizit definieren oder ihn vorher in der zusätzlichen Map platzieren.

tl; dr können Sie einfach speichern die parallel Build auf eine HashMap und Zugriff auf diese Karte durch direktes Schleifen über es keySet statt

---

diese Antwort Nehmen Sie mit einem Körnchen Salz, ich eine bin mit ältere Version der Pipeline (Jenkins 2.7.2 und Pipeline 2.2).

Sie können die parallelen Build-Ergebnisse in einer hashMap speichern und eine Schleife über den keySet der Karte ausführen, um Informationen über den Build zu erhalten.

def create_build_job(job_name, pool_label="master", propagate=false) { 
    build job: job_name, parameters: [[$class: 'LabelParameterValue', name: "node_label", label: "${pool_label}"]], propagate: propagate, wait:true 
} 

def buildmap = [:] 
def build_results 

stage 'Perform Build' 
    //test1 is set to fail, test2 is set to succeed 
    buildmap['test1'] = {create_build_job('test1', "your_node_label")} 
    buildmap['test2'] = {create_build_job('test2', "your_node_label")} 

    build_results = parallel buildmap 

    for(k in build_results.keySet()){ 
     println build_results["${k}"].getProperties() 
    } 

Für diese Pipeline Ich bin nur alle Eigenschaften des RunWrapper gespeichert in Punkt in der Karte Dumping, jedoch können Sie jedes Objekt direkt zugreifen, so dass Sie nur tun können, wenn Sie das Ergebnis des Build wollen :

build_results["${k}"].result 

Die Konsolenausgabe durch diese Pipeline (mit jeder potentiell identifizierende Informationen erzeugt geschwärzt ist:

Started by user <user> 
[Pipeline] stage (Perform Build) 
Entering stage Perform Build 
Proceeding 
[Pipeline] parallel 
[Pipeline] [test1] { (Branch: test1) 
[Pipeline] [test2] { (Branch: test2) 
[Pipeline] [test1] build (Building test1) 
[test1] Scheduling project: test1 
[test1] Starting building: test1 #11 
[Pipeline] [test2] build (Building test2) 
[test2] Scheduling project: test2 
[test2] Starting building: test2 #11 
[Pipeline] } 
[Pipeline] } 
[Pipeline] // parallel 
[Pipeline] echo 
{rawBuild=test1 #11, class=class org.jenkinsci.plugins.workflow.support.steps.build.RunWrapper, absoluteUrl=<jenkins_url>/job/test1/11/, buildVariables={}, previousBuild=org.jenkinsci.plugins.workflow.support.steps.build.RunWrapper@1480013a, id=11, nextBuild=null, changeSets=[], result=FAILURE, description=null, startTimeInMillis=1509667550519, timeInMillis=1509667550510, duration=956, number=11, displayName=#11} 
[Pipeline] echo 
{rawBuild=test2 #11, class=class org.jenkinsci.plugins.workflow.support.steps.build.RunWrapper, absoluteUrl=<jenkins_url>/job/test2/11/, buildVariables={}, previousBuild=org.jenkinsci.plugins.workflow.support.steps.build.RunWrapper@2d9c7128, id=11, nextBuild=null, changeSets=[], result=SUCCESS, description=null, startTimeInMillis=1509667550546, timeInMillis=1509667550539, duration=992, number=11, displayName=#11} 
[Pipeline] End of Pipeline 
Finished: SUCCESS