Jenkinsfile Pipeline DSL:如何在作业仪表板 GUI 中显示多列 - 对于所有动态创建的阶段 - 在 PIPELINE 部分中时 [英] Jenkinsfile Pipeline DSL: How to Show Multi-Columns in Jobs dashboard GUI - For all Dynamically created stages - When within PIPELINE section
问题描述
Jenkins 2.89.4 滚动
我看到了几乎所有的 stackoverflow 帖子，这些帖子展示了我们如何成功地运行并行步骤/阶段(使用列表/地图等)——或者直接对它们进行硬编码——或者甚至为 Jenkinsfile 创建动态阶段(如本文所示:脚本化jenkinsfile并行阶段)
我的要求是:
在BUILD"步骤下构建 N 个项目的管道，即在每个项目上并行构建.即它在所有 N 个项目上运行 Gradle.在这里，我有一个由声明性 JOB DSL Groovy 创建的 Jenkinsfile.这里我的 Gradle 项目没有设置为多项目，所以我不能调用顶级 gradle 说，Gradle 请做你的并行魔法(在 Gradle 内).
我想在 jenkins 作业的仪表板中看到的 自己单独的并行动态创建阶段(GUI 列) 中运行这 N 个项目的构建.p>
我想分别查看(Gradle 构建/控制台)每个项目构建的输出，即 我不想混合每个项目构建的控制台输出，它们在只有一列(即名为
BUILD的列).在此网址中 https://jenkins.io/blog/2017/09/25/declarative-1/ 我明白了，您如何运行并行阶段/步骤，但这样做，要么将这些并行步骤的输出混合在一列中(我的意思是在 BUILD 列)--或者如果您希望它在单独的阶段/列下(即帖子说 在 Linux 或 Windows 上测试 单独那么您仍然在早期对 Jenkinsfile 中的所有阶段/步骤进行硬编码(而不是仅使用列表或数组哈希，我更愿意对其进行更新以添加更多或更少的阶段/并行步骤，在我的情况下，它们都遵循相同的标准).我想要的只是在一个地方更新多少步骤以及一个地方的所有阶段(列表/数组).
- 我不使用 Jenkins暂时是蓝海.
通常，如果您在一个阶段中有并行步骤，则当您单击查看该给定并行步骤/阶段的控制台输出时，所有步骤的控制台标准输出将混合到一个控制台输出/阶段/列中；当您将鼠标悬停在作业仪表板中的 BUILD 列(假设在 BUILD 阶段有并行步骤)时(所有这些步骤的标准输出混合在一起，很难看到单个项目步骤的控制台输出只是为了给定的步骤/阶段).
如果我们想(动态)创建单独的阶段，那么 Jenkins 应该能够在并行部分中显示给定步骤/动态阶段的控制台输出(即每列都应该显示他们自己项目的构建控制台输出).
使用上述 URL，我可以在尝试此脚本后执行以下操作:
//主脚本块//可以使用例如.params.parallel 构建参数来选择并行/串行def runParallel = truedef buildStages节点('主'){stage('初始化并行动态阶段') {//设置列表<Map<String,Closure>>描述构建buildStages = prepareBuildStages()println("初始化管道.")}for(在 buildStages 中构建){如果(运行并行){并行(构建)} 别的 {//串行运行(注意，地图是无序的！)for (build in builds.values()) {build.call()}}}阶段(完成"){println('整个深子完成了.')}}//创建适合的构建阶段列表def prepareBuildStages() {定义构建列表 = []对于 (i=1; i<4; i++) {def buildStages = [:]对于(['Alpha'，'Tango'，'Chyarli']中的名称){def n = "${name} ${i}"buildStages.put(n, prepareOneBuildStage(n))}buildList.add(buildStages)}返回构建列表}def prepareOneBuildStage(字符串名称){def proj_name = name.split(' ')[0]def proj_parallel_sub_step = name.split(' ')[1]//返回整个chunkoni返回 {阶段(构建
项目-${proj_name}
步骤${proj_parallel_sub_step}"){println("建筑 ${proj_name} - ${proj_parallel_sub_step}")sh(脚本:'睡眠 15'，返回状态:真)}}}当我将上述 Groovy 脚本(用于创建 DYNAMIC 阶段)放入 Pipeline Script 或 SCM 中的Pipeline Script 时(即 .groovy 文件)——它成功运行并在 BUILD 步骤下为 3 个项目中的每一个创建动态阶段，并为所有 3 个项目并行运行 3 个步骤(第 N 个)，然后为所有 3 个项目启动下一个第 N 个步骤，依此类推.
如果您在下面看到，我们还在 Jenkins 作业仪表板中为他们提供了单独的列.
现在，当我将上述脚本放入 Jenkinsfile (Pipeline DSL) 我有 pipeline { .... } 部分时，它不起作用并给了我以下错误.
使用我的 JOB DSL，我创建了一个新的 Jenkins 管道作业，其中 SCM 中的管道脚本 调用了一个 groovy 文件(现在包含):
//----------------------------------------------------//两者 - JF Jenkins 作业中的并行运行和 GUI 视图.//----------------------------------------------------def runParallel = truedef buildStagesdef wkspace =/var/lib/jenkins/workspaces/ignore_this_variale_or_its_value_for_now//创建适合的构建阶段列表def prepareBuildStages() {定义构建列表 = []对于 (i=1; i<3; i++) {def buildStages = [:]对于(['Alpha'，'Tango'，'Chyarli']中的名称){def n = "${name} ${i}"buildStages.put(n, prepareOneBuildStage(n))}buildList.add(buildStages)}返回构建列表}//---def prepareOneBuildStage(字符串名称){def proj_name = name.split(' ')[0]def proj_parallel_sub_step = name.split(' ')[1]//返回整个 chunkoni(即对于给定阶段) - 将动态命名.返回 {阶段(构建
项目-${proj_name}
步骤${proj_parallel_sub_step}"){println("建筑 ${proj_name} - ${proj_parallel_sub_step}")sh(脚本:'睡眠 15'，返回状态:真)}}}//设置列表<Map<String,Closure>>描述构建buildStages = prepareBuildStages()//---------------------字符串詹金斯基线//现在看 --- 我们有这个部分叫做管道"管道{代理人 {节点{标签'rhat6'customWorkspace wkspace}}选项 {ansiColor('xterm')超时(时间:8，单位:'HOURS')跳过默认签出()时间戳()}环境 {someEnvVar = 'aValue'}//------------- 阶段阶段{stage('初始化并行动态阶段') {//设置列表<Map<String,Closure>>描述构建println("初始化管道.")}for(在 buildStages 中构建){如果(运行并行){并行(构建)} 别的 {//串行运行(注意，地图是无序的！)for (build in builds.values()) {build.call()}}}阶段(完成"){println('整个深子完成了.')}}//---------------------}运行 Jenkinsfile Jenkins 作业现在给我这个错误:
[BFA] 扫描已知原因的构建...[BFA] 未找到故障原因[博鳌亚洲论坛] 完成.1sorg.codehaus.groovy.control.MultipleCompilationErrorsException:启动失败:WorkflowScript:69:不是有效的阶段部分定义:buildStages = prepareBuildStages()".需要一些额外的配置.@ 第 69 行，第 5 列.stage('初始化并行动态阶段') {^WorkflowScript:69:未知阶段部分println".从 0.5 版开始，阶段中的步骤必须在步骤块中.@ 第 69 行，第 5 列.stage('初始化并行动态阶段') {^WorkflowScript:75:预计第 75 行第 5 列的阶段.for(在 buildStages 中构建){^WorkflowScript:86:未知的阶段部分println".从 0.5 版开始，阶段中的步骤必须在步骤块中.@ 第 86 行，第 5 列.阶段(完成"){^WorkflowScript:69:在第 69 行第 5 列的初始化并行动态阶段"阶段内没有步骤"或并行"执行.stage('初始化并行动态阶段') {^WorkflowScript:86:在第 86 行第 5 列的完成"阶段内没有步骤"或并行"执行.阶段(完成"){^6 个错误在 org.codehaus.groovy.control.ErrorCollector.failIfErrors(ErrorCollector.java:310)在 org.codehaus.groovy.control.CompilationUnit.applyToPrimaryClassNodes(CompilationUnit.java:1085)在 org.codehaus.groovy.control.CompilationUnit.doPhaseOperation(CompilationUnit.java:603)在 org.codehaus.groovy.control.CompilationUnit.processPhaseOperations(CompilationUnit.java:581)在 org.codehaus.groovy.control.CompilationUnit.compile(CompilationUnit.java:558)在 groovy.lang.GroovyClassLoader.doParseClass(GroovyClassLoader.java:298)在 groovy.lang.GroovyClassLoader.parseClass(GroovyClassLoader.java:268)在 groovy.lang.GroovyShell.parseClass(GroovyShell.java:688)在 groovy.lang.GroovyShell.parse(GroovyShell.java:700)在 org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.doParse(CpsGroovyShell.java:133)在 org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.reparse(CpsGroovyShell.java:127)在 org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.parseScript(CpsFlowExecution.java:557)在 org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.start(CpsFlowExecution.java:518)在 org.jenkinsci.plugins.workflow.job.WorkflowRun.run(WorkflowRun.java:290)在 hudson.model.ResourceController.execute(ResourceController.java:97)在 hudson.model.Executor.run(Executor.java:429)完成:失败我怎样才能在 Jenkinsfile pipeline 部分中运行它，并且仍然能够为给定项目 N 和步骤 M 获取每个动态创建的阶段的各个列?
尝试了以下方式，仍然错误的方式.
//------------- 阶段阶段{stage('初始化并行动态阶段') {//设置列表<Map<String,Closure>>描述构建buildStages = prepareBuildStages()println("初始化管道.")//也试过这种方式.一个阶段内buildStages.each { bld -->并行(无)}}阶段(完成"){println('整个深子完成了.')}}//---------------------所以我对此做了一些研究并让它工作了.
Jenkinsfile 中的新代码(用于STAGES)现在是:
//------------- 阶段阶段{阶段(启动管道"){脚步 {脚本 {sh 回声 HELLO moto razr！"}}}stage('初始化并行动态阶段'){脚步 {脚本 {//并行运行所有项目的所有第 N 步.buildStages.each { bs ->并行(bs)}//或者取消注释以下代码(如果以布尔变量为条件)./*for(在 buildStages 中构建){如果(运行并行){并行(构建)} 别的 {//串行运行(注意，地图是无序的！)for (build in builds.values()) {build.call()}}}*/}}}阶段(完成"){println('整个深子完成了.')}}//---------------------这就是工作所需要的一切.
为了清晰的消息/阶段名称，我也调整了函数，我们不会在 pipeline { ... } 中设置这个变量 buildStages
//---def prepareOneBuildStage(字符串名称){def proj_name = name.split(' ')[0]def proj_parallel_sub_step = name.split(' ')[1]//返回整个 chunkoni(即对于给定阶段) - 将动态命名.返回 {stage("BUILD Project-${proj_name} Parallel_Step_${proj_parallel_sub_step}") {println("Parallel_Step # ${proj_parallel_sub_step} of Project => ${proj_name}")sh(script:"echo "Parallel_Step # ${proj_parallel_sub_step} of Project => ${proj_name}" && sleep 20", returnStatus:true)//-- 或者 -- 您可以在这里调用 Gradle 任务，即 rpm/任何其他/任何其他命令.}}}//设置列表<Map<String,Closure>>描述构建.现在部分.buildStages = prepareBuildStages()//---------------------此实现现在正在创建 N 否.并行阶段，即每个项目有一个单独的列，用于给定的第 N 步(查看 Jenkinsfile 作业的仪表板时)对于 P 号的项目.
- 它将为给定的第 N 步并行运行 所有 P 项目.
它将等待所有项目的第 N 步首先完成，然后跳转到下一个第 N 步.
这意味着，如果 Project ALPHA Step #1 完成，它仍然会等待其他 2 个项目的所有 Step #1，然后并行启动所有项目的 Step #2.
挑战:我们如何让 ALPHA 项目的第 2 步在 ALPHA 项目的第 1 步完成后立即开始，即它不会等待其他 2 个项目的第 1 步完成并可能与其他项目的第 N(=1) 步或 N+1 步并行运行 ALPHA 项目 1 的第 2 步.
这假设所有项目都是相互独立的，并且项目不共享由给定项目/它们的阶段/步骤在任何其他项目/阶段/步骤中生成的内容.
根据您自己的要求，您可能需要等待(即在所有项目的第 1 步完全完成之前不要运行所有项目的第 2 步)--或者-- 你可能想运行 第 2 步的 ALPHA 项目，比如说 - 第 2 步的 TANGO 项目 而项目 CHYARLI 的第 1 步仍在进行中.
由于这篇文章的主要范围是为每个项目获取单独的动态创建的列/阶段(在 pipeline { ... } 部分中并行运行)，我想，我明白了正在寻找.
注意:如果您想运行管道的并发构建，请轻松使用并行.有关 running parallel 构建操作 concurrently 相关问题的更多信息，请参阅此处:Jenkins - java.lang.IllegalArgumentException:最后一个单元没有足够的有效位&Gradle 错误:在根项目中找不到任务null"
Jenkins 2.89.4 rolling
I saw almost all stackoverflow posts which show how we can successfully run parallel steps/stages (using list/maps etc) --OR hardcoding them directly --OR even create dynamic stages for Jenkinsfile (as seen in this post: Scripted jenkinsfile parallel stage)
My requirements are:
A pipeline which builds N. no of projects under "BUILD" steps i.e. parallel builds on each of those projects. i.e. it runs Gradle on all N projects. Here I have a Jenkinsfile which was created by a declarative JOB DSL Groovy. Here my Gradle projects are not set as multi-projects so I can't call the top level gradle and say, Gradle please do your parallel magic (within Gradle).
I want to run build of these N projects in their own separate parallel dynamically created stages (GUI Columns) as seen in jenkins job's dashboard.
I want to see the output of (Gradle build/console) each project's build separately i.e. I don't want to mix the console output of each projects build which are running in parallel in just ONE COLUMN (i.e. column named
BUILD).In this URL https://jenkins.io/blog/2017/09/25/declarative-1/ I see, how you can run parallel stages/steps but in doing so, either it's mixing those parallel step's output in just one column (I mean under BUILD column) --OR if you want it under separate stages/columns (i.e. the post says Test on Linux or Windows separately then you are still hard-coding all the stages/steps in Jenkinsfile early on (rather than using just a list or array hash which I'd prefer to update for adding more or less stages / parallel steps as in my case, they all follow the same standard). What I want is to just update in one place How many steps and what are all of the stages in just one place (list/array).
- I'm not using Jenkins Blue Ocean for now.
Usually if you have parallel steps within a stage, their console std output for all steps gets mixed into one console output / stage/column when you click to see the console output for that given parallel step/stage; When you hover over the BUILD column (assuming there were parallel steps in BUILD stage) in job's dashboard (std output for all those steps is mixed up and very hard to see individual project step's console output just for a given step/stage).
If we want to create separate stages (dynamically) then Jenkins should be able to show console output of a given step/dynamic stage within the parallel section (i.e. each column should show their own project's build console output).
Using the above URL, I'm able to do the following after trying this script:
// main script block
// could use eg. params.parallel build parameter to choose parallel/serial
def runParallel = true
def buildStages
node('master') {
stage('Initializing Parallel Dynamic Stages') {
// Set up List<Map<String,Closure>> describing the builds
buildStages = prepareBuildStages()
println("Initialised pipeline.")
}
for (builds in buildStages) {
if (runParallel) {
parallel(builds)
} else {
// run serially (nb. Map is unordered! )
for (build in builds.values()) {
build.call()
}
}
}
stage('Done') {
println('The whole SHENZI is complete.')
}
}
// Create List of build stages to suit
def prepareBuildStages() {
def buildList = []
for (i=1; i<4; i++) {
def buildStages = [:]
for (name in [ 'Alpha', 'Tango', 'Chyarli' ] ) {
def n = "${name} ${i}"
buildStages.put(n, prepareOneBuildStage(n))
}
buildList.add(buildStages)
}
return buildList
}
def prepareOneBuildStage(String name) {
def proj_name = name.split(' ')[0]
def proj_parallel_sub_step = name.split(' ')[1]
//Return the whole chunkoni
return {
stage("Build
Project-${proj_name}
Step ${proj_parallel_sub_step}") {
println("Building ${proj_name} - ${proj_parallel_sub_step}")
sh(script:'sleep 15', returnStatus:true)
}
}
}
When I'm putting the above Groovy Script (which is creating DYNAMIC Stages) inside Pipeline Script or Pipeline Script from SCM (i.e. the same code available in a .groovy file) -- it runs successfully and creates dynamic stages under BUILD step for each of the 3 projects and runs 3 steps (Nth) for all 3 projects in parallel and then starts the next Nth step for all 3 projects and so on.
If you see below, we also got individual columns in Jenkins job dashboard for them.
Now, When I put the above script in Jenkinsfile (Pipeline DSL) where I have pipeline { .... } section, it's not working and giving me the following error.
Using my JOB DSL, I created a new Jenkins Pipeline job where Pipeline Script from SCM calls a groovy file (which now contains):
//----------------------------------------------------
// Both - Parallel Run and GUI View in JF Jenkins job.
//----------------------------------------------------
def runParallel = true
def buildStages
def wkspace = /var/lib/jenkins/workspaces/ignore_this_variale_or_its_value_for_now
// Create List of build stages to suit
def prepareBuildStages() {
def buildList = []
for (i=1; i<3; i++) {
def buildStages = [:]
for (name in [ 'Alpha', 'Tango', 'Chyarli' ] ) {
def n = "${name} ${i}"
buildStages.put(n, prepareOneBuildStage(n))
}
buildList.add(buildStages)
}
return buildList
}
//---
def prepareOneBuildStage(String name) {
def proj_name = name.split(' ')[0]
def proj_parallel_sub_step = name.split(' ')[1]
// return the whole chunkoni (i.e. for a given stage) - will be named dynamically.
return {
stage("Build
Project-${proj_name}
Step ${proj_parallel_sub_step}") {
println("Building ${proj_name} - ${proj_parallel_sub_step}")
sh(script:'sleep 15', returnStatus:true)
}
}
}
// Set up List<Map<String,Closure>> describing the builds
buildStages = prepareBuildStages()
//---------------------
String jenkinsBaselines
// SEE NOW --- we have this section called 'pipeline'
pipeline {
agent {
node {
label 'rhat6'
customWorkspace wkspace
}
}
options {
ansiColor('xterm')
timeout(time: 8, unit: 'HOURS')
skipDefaultCheckout()
timestamps()
}
environment {
someEnvVar = 'aValue'
}
//------------- Stages
stages {
stage('Initializing Parallel Dynamic Stages') {
// Set up List<Map<String,Closure>> describing the builds
println("Initialised pipeline.")
}
for (builds in buildStages) {
if (runParallel) {
parallel(builds)
} else {
// run serially (nb. Map is unordered! )
for (build in builds.values()) {
build.call()
}
}
}
stage('Done') {
println('The whole SHENZI is complete.')
}
}
//---------------------
}
Running the Jenkinsfile Jenkins job now gives me this error:
[BFA] Scanning build for known causes...
[BFA] No failure causes found
[BFA] Done. 1s
org.codehaus.groovy.control.MultipleCompilationErrorsException: startup failed:
WorkflowScript: 69: Not a valid stage section definition: "buildStages = prepareBuildStages()". Some extra configuration is required. @ line 69, column 5.
stage('Initializing Parallel Dynamic Stages') {
^
WorkflowScript: 69: Unknown stage section "println". Starting with version 0.5, steps in a stage must be in a steps block. @ line 69, column 5.
stage('Initializing Parallel Dynamic Stages') {
^
WorkflowScript: 75: Expected a stage @ line 75, column 5.
for (builds in buildStages) {
^
WorkflowScript: 86: Unknown stage section "println". Starting with version 0.5, steps in a stage must be in a steps block. @ line 86, column 5.
stage('Done') {
^
WorkflowScript: 69: No "steps" or "parallel" to execute within stage "Initializing Parallel Dynamic Stages" @ line 69, column 5.
stage('Initializing Parallel Dynamic Stages') {
^
WorkflowScript: 86: No "steps" or "parallel" to execute within stage "Done" @ line 86, column 5.
stage('Done') {
^
6 errors
at org.codehaus.groovy.control.ErrorCollector.failIfErrors(ErrorCollector.java:310)
at org.codehaus.groovy.control.CompilationUnit.applyToPrimaryClassNodes(CompilationUnit.java:1085)
at org.codehaus.groovy.control.CompilationUnit.doPhaseOperation(CompilationUnit.java:603)
at org.codehaus.groovy.control.CompilationUnit.processPhaseOperations(CompilationUnit.java:581)
at org.codehaus.groovy.control.CompilationUnit.compile(CompilationUnit.java:558)
at groovy.lang.GroovyClassLoader.doParseClass(GroovyClassLoader.java:298)
at groovy.lang.GroovyClassLoader.parseClass(GroovyClassLoader.java:268)
at groovy.lang.GroovyShell.parseClass(GroovyShell.java:688)
at groovy.lang.GroovyShell.parse(GroovyShell.java:700)
at org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.doParse(CpsGroovyShell.java:133)
at org.jenkinsci.plugins.workflow.cps.CpsGroovyShell.reparse(CpsGroovyShell.java:127)
at org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.parseScript(CpsFlowExecution.java:557)
at org.jenkinsci.plugins.workflow.cps.CpsFlowExecution.start(CpsFlowExecution.java:518)
at org.jenkinsci.plugins.workflow.job.WorkflowRun.run(WorkflowRun.java:290)
at hudson.model.ResourceController.execute(ResourceController.java:97)
at hudson.model.Executor.run(Executor.java:429)
Finished: FAILURE
How can I get this working in Jenkinsfile pipeline section and still able to get individual columns per dynamically created stage for a given project N and Step M?
Tried the following way, still errors the say way.
//------------- Stages
stages {
stage('Initializing Parallel Dynamic Stages') {
// Set up List<Map<String,Closure>> describing the builds
buildStages = prepareBuildStages()
println("Initialised pipeline.")
// tried this way too. within a stage
buildStages.each { bld -->
parallel(bld)
}
}
stage('Done') {
println('The whole SHENZI is complete.')
}
}
//---------------------
So I did some poking into this and got it working.
The new code within Jenkinsfile (for STAGES) is now:
//------------- Stages
stages {
stage('Start Pipeline') {
steps {
script {
sh "echo HELLO moto razr!"
}
}
}
stage('Initializing Parallel Dynamic Stages'){
steps {
script {
// Run all Nth step for all Projects in Parallel.
buildStages.each { bs -> parallel(bs) }
// OR uncomment the following code (if conditional on boolean variable).
/*
for (builds in buildStages) {
if (runParallel) {
parallel(builds)
} else {
// run serially (nb. Map is unordered! )
for (build in builds.values()) {
build.call()
}
}
}
*/
}
}
}
stage('Done') {
println('The whole SHENZI is complete.')
}
}
//---------------------
That's all it took to work.
For clear messages / stage names, I tweaked the function as well and We won't set this variable buildStages within pipeline { ... }
//---
def prepareOneBuildStage(String name) {
def proj_name = name.split(' ')[0]
def proj_parallel_sub_step = name.split(' ')[1]
// return the whole chunkoni (i.e. for a given stage) - will be named dynamically.
return {
stage("BUILD Project-${proj_name} Parallel_Step_${proj_parallel_sub_step}") {
println("Parallel_Step # ${proj_parallel_sub_step} of Project => ${proj_name}")
sh(script:"echo "Parallel_Step # ${proj_parallel_sub_step} of Project => ${proj_name}" && sleep 20", returnStatus:true)
// -- OR -- you can call Gradle task i.e. rpm / any other / any other command here.
}
}
}
// Set up List<Map<String,Closure>> describing the builds. section now.
buildStages = prepareBuildStages()
//---------------------
This implementation is now creating N no. of parallel stages i.e. a separate column per project for a given Nth step (when looking at Jenkinsfile job's dashboard) for P no. of projects.
- It will run All P projects for a given Nth step in parallel.
It will wait for Nth step for all Projects to complete first and then jump to the next Nth step.
What this means is, if Project ALPHA Step #1 is complete, it'll still wait for all Step #1 of other 2 projects and then launch Step #2 of all projects in parallel.
Challenge: How can we make ALPHA Project's Step #2 to start as soon as ALPHA project's Step #1 is complete i.e. it won't wait for Step 1 of other 2 projects to complete and could possibly run Step #2 of ALPHA project 1 in parallel with Step N(=1) or N+1 of other projects.
This assumes all projects are independent of each other and projects don't share contents generated by a given project/their stage/steps in any other project/stage/step.
Depending upon your own requirements, you may want to wait (i.e. don't run Step 2 of all projects until Step 1 of all projects are fully complete) --OR-- you may want to run Step 2 of ALPHA project with let's say - Step 2 of TANGO project while project CHYARLI's step 1 is still in progress.
As the main scope of this post was to get separate dynamically created columns/stages per project (running in parallel within pipeline { ... } section), I think, I got what I was looking for.
NOTE: Go easy with parallel if you want to run concurrent builds of a pipeline. For more info about issues related to running parallel build actions concurrently, see here: Jenkins - java.lang.IllegalArgumentException: Last unit does not have enough valid bits & Gradle error: Task 'null' not found in root project
这篇关于Jenkinsfile Pipeline DSL:如何在作业仪表板 GUI 中显示多列 - 对于所有动态创建的阶段 - 在 PIPELINE 部分中时的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
