Details
-
Story
-
Status: Closed (View Workflow)
-
Major
-
Resolution: Duplicate
-
-
Blue Ocean 1.8.0
Description
In progress - one level of visualization below parent stage. Additional research and feedback will help us determine future visualizations.
I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps.
Example 1
def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } }
Example 2
node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } }
Attachments
Issue Links
- blocks
-
JENKINS-42062 Inputs not showing in inner most nested parallels
-
- Closed
-
-
JENKINS-35836 Steps outside a stage or within a stage but outside a parallel do not get visualized
-
- Closed
-
- duplicates
-
JENKINS-49050 I can view my sequential declarative pipeline stages in the pipeline visualization plugin
-
- Closed
-
- is duplicated by
-
JENKINS-45664 blue-ocean parallel streams are not showing up red on a stream failure
-
- Closed
-
-
JENKINS-41781 Support multiple parallels within a stage in the Pipeline Visualization
-
- Closed
-
-
JENKINS-46345 Graphical view not showing correct process
-
- Closed
-
-
JENKINS-40619 Visualizing (list of sequential steps) as groups, as part of one stage
-
- Resolved
-
- is related to
-
JENKINS-41156 [Pipeline] Have shell and batch steps be renameable
-
- Resolved
-
-
JENKINS-44820 Parallel branches with no stage should not be displayed in Blue Ocean
-
- Resolved
-
- relates to
-
JENKINS-54010 Support the visualization of two levels of parallelity in stages
-
- In Progress
-
-
JENKINS-39464 Pipeline with parallel and no stages does not get visualised correctly
-
- In Progress
-
-
JENKINS-53162 Blueocean support for visualizing stages in parallel block in scripted pipeline
-
- Closed
-
-
JENKINS-41205 Stage graph unsuitable for large and/or complex pipelines
-
- Resolved
-
- links to
- mentioned in
-
Page Loading...
Activity
Field | Original Value | New Value |
---|---|---|
Issue Type | Bug [ 1 ] | Story [ 10002 ] |
Summary | Nested labelled blocks breaks blueocean | Support nested stages in the Pipeline Graph |
Description |
I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel title="Support for nested stages is currently unplanned"} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
Description |
{panel title="Support for nested stages is currently unplanned"} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel:title="Support for nested stages is currently unplanned"} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
Description |
{panel:title="Support for nested stages is currently unplanned"} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=blue} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
Description |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=blue} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=grey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
Description |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=grey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
Description |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
Description |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
Description |
{panel:title="Support for nested stages is currently unplanned"|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
Description |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
Epic Link | JENKINS-35750 [ 171713 ] |
Attachment | Capture.JPG [ 34084 ] |
Attachment | blueocean.sketch 2016-09-28 15-03-57.png [ 34100 ] |
Attachment | Screen Shot 2016-10-03 at 4.13.46 PM.png [ 34227 ] |
Rank | Ranked higher |
Rank | Ranked lower |
Description |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. Code used: {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Description |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {stage} needs to be revisited. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Description |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {stage} needs to be revisited. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Description |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Link |
This issue relates to |
Link |
This issue relates to |
Link |
This issue relates to |
Link |
This issue relates to |
Link |
This issue relates to |
Link |
This issue is duplicated by |
Rank | Ranked higher |
Rank | Ranked lower |
Remote Link | This issue links to "Jenkins/Jenkins tried to use a matrix style parallel (Web Link)" [ 15226 ] |
Description |
{panel:title=Support for nested stages is currently unplanned|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel:title=Support for nested stages is currently unplanned and is not actively being worked on|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Link |
This issue blocks |
Attachment | PipelineGraphProposal.png [ 35539 ] |
Link |
This issue is duplicated by |
Link |
This issue is related to |
Link |
This issue blocks |
Link |
This issue relates to |
Attachment | example.png [ 36599 ] |
Attachment | pipeline_mockup.png [ 36602 ] |
Attachment | image-2017-04-12-16-16-17-144.png [ 37113 ] |
Attachment | image-2017-04-12-16-17-38-285.png [ 37114 ] |
Assignee | Jesse Glick [ jglick ] |
Assignee | Jesse Glick [ jglick ] |
Attachment | Proposed Parallel Stages.JPG [ 37115 ] |
Attachment | alternate zoom in.png [ 37120 ] |
Assignee | Tushar Mahale [ tusharmahale ] |
Assignee | Tushar Mahale [ tusharmahale ] |
Epic Link | JENKINS-35750 [ 171713 ] | JENKINS-43953 [ 181485 ] |
Description |
{panel:title=Support for nested stages is currently unplanned and is not actively being worked on|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel:title=Support for nested stages is currently unplanned and is not actively being worked on|titleBGColor=lightgrey|titleColor=white} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Description |
{panel:title=Support for nested stages is currently unplanned and is not actively being worked on|titleBGColor=lightgrey|titleColor=white} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel:title=Support for nested stages is currently unplanned and is not actively being worked on|titleBGColor=#3878de|titleColor=white} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Description |
{panel:title=Support for nested stages is currently unplanned and is not actively being worked on|titleBGColor=#3878de|titleColor=white} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel:title=Support for nested stages is currently unplanned and is not actively being worked on|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Link |
This issue is related to |
Link |
This issue is duplicated by |
Attachment | image-2017-08-14-10-29-55-373.png [ 39258 ] |
Attachment | image-2017-08-14-10-34-10-452.png [ 39259 ] |
Attachment | image-2017-08-14-10-29-55-373.png [ 39258 ] |
Link |
This issue is duplicated by |
Remote Link | This issue links to "Page (Jenkins Wiki)" [ 17861 ] |
Attachment | screenshot-1.png [ 40062 ] |
Attachment | image-2017-10-19-08-24-00-504.png [ 40063 ] |
Remote Link | This issue links to "CloudBees Internal UX-584 (Web Link)" [ 18213 ] |
Attachment | Before.PNG [ 41786 ] |
Attachment | After.png [ 41787 ] |
Assignee | CloudBees Inc. [ cloudbees ] |
Status | Open [ 1 ] | In Progress [ 3 ] |
Description |
{panel:title=Support for nested stages is currently unplanned and is not actively being worked on|titleBGColor=lightgrey} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code:java} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Description |
{panel} There is some debate on how this concept can be visualised in Blue Ocean. Its possible to have infinitely nested stages that would be impossible for the visualization to display correctly. It's also impossible for us to correctly decide if a inner stage should be used as a "label" for a set of steps or if it is an actual stage. Labelling using {{stage}} needs to be revisited in Pipeline Script. The Blue Ocean team needs to refine the design for the pipeline graph for this to be supported. {panel} *Original ticket* I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code:java} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel} In progress - one level of visualization below parent stage. Additional research and feedback will help us determine future visualizations.{panel} I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code:java} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Summary | Support nested stages in the Pipeline Graph | View sequential stages in the pipeline visualization graph |
Attachment | jenkins-weird-masked2.png [ 43737 ] |
Link |
This issue duplicates |
Resolution | Duplicate [ 3 ] | |
Status | In Progress [ 3 ] | Closed [ 6 ] |
Released As | Blue Ocean 1.8.0 |
Link |
This issue relates to |
Link | This issue relates to JENKINS-54010 [ JENKINS-54010 ] |
Description |
{panel} In progress - one level of visualization below parent stage. Additional research and feedback will help us determine future visualizations.{panel} I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code:java} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
{panel} In progress - one level of visualization below parent stage. Additional research and feedback will help us determine future visualizations. {panel} I've tried using nested stages in order to group each shell script alone to have a meaningful data, however this broken the UI of blueocean and it stopped it from showing showing the variant steps. *Example 1* {code:java} def test = [:] test["a"] = { stage ("a") { stage ("ab") { sh "echo stage abc" } stage ("xyz") { sh "echo stage xyz" } } } test["b"] = { stage ("b") { stage ("bb") { sh "echo stage bb" } stage ("bxz") { sh "echo stagebxyz" } } } node { //stage 'start' parallel test stage ('middle') { sh "echo middle" } } {code} *Example 2* {code:java} node() { stage('Build') { println 'I prepare the build for the parallel steps' } stage('Test') { parallel ( "win7-vs2012" : { stage("checkout") { }; stage("build") { }; stage("test") { } }, "win10-vs2015" : { stage("checkout") { }; stage("build") { }; stage("test") { }}, "linux-gcc5" : { stage("checkout") { }; stage("build") { }; stage("test") { } } ) } } {code} |
Attachment | current.png [ 53474 ] |
Attachment | Jenkins-substages.png [ 53475 ] |
Ah, is this is nested stages, they won't be supported visually for some time (there is some question on how to show them, labelled steps below the parent stage, or a nested block of stages in the graph).
For now, don't use nested stages, it won't do much good. I am curious what your aim is - you want to label steps or blocks of steps as doing something significant?