Uploaded image for project: 'Jenkins'
  1. Jenkins
  2. JENKINS-38442

View sequential stages in the pipeline visualization graph

    Details

    • Similar Issues:
    • Released As:
      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

        1. After.png
          After.png
          6 kB
        2. alternate zoom in.png
          alternate zoom in.png
          85 kB
        3. Before.PNG
          Before.PNG
          8 kB
        4. blueocean.sketch 2016-09-28 15-03-57.png
          blueocean.sketch 2016-09-28 15-03-57.png
          29 kB
        5. blueocean-failure.JPG
          blueocean-failure.JPG
          60 kB
        6. Capture.JPG
          Capture.JPG
          17 kB
        7. example.png
          example.png
          44 kB
        8. image-2017-04-12-16-16-17-144.png
          image-2017-04-12-16-16-17-144.png
          148 kB
        9. image-2017-04-12-16-17-38-285.png
          image-2017-04-12-16-17-38-285.png
          131 kB
        10. image-2017-08-14-10-34-10-452.png
          image-2017-08-14-10-34-10-452.png
          10 kB
        11. image-2017-10-19-08-24-00-504.png
          image-2017-10-19-08-24-00-504.png
          3 kB
        12. jenkins-weird-masked2.png
          jenkins-weird-masked2.png
          52 kB
        13. pipeline_mockup.png
          pipeline_mockup.png
          11 kB
        14. PipelineGraphProposal.png
          PipelineGraphProposal.png
          62 kB
        15. Proposed Parallel Stages.JPG
          Proposed Parallel Stages.JPG
          21 kB
        16. screenshot-1.png
          screenshot-1.png
          4 kB
        17. Screen Shot 2016-10-03 at 4.13.46 PM.png
          Screen Shot 2016-10-03 at 4.13.46 PM.png
          25 kB

          Issue Links

            Activity

            mbadran mohamed badran created issue -
            jamesdumay James Dumay made changes -
            Field Original Value New Value
            Issue Type Bug [ 1 ] Story [ 10002 ]
            jamesdumay James Dumay made changes -
            Summary Nested labelled blocks breaks blueocean Support nested stages in the Pipeline Graph
            jamesdumay James Dumay made changes -
            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}

            jamesdumay James Dumay made changes -
            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}

            jamesdumay James Dumay made changes -
            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}

            jamesdumay James Dumay made changes -
            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}

            jamesdumay James Dumay made changes -
            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}

            jamesdumay James Dumay made changes -
            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}

            jamesdumay James Dumay made changes -
            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}

            jamesdumay James Dumay made changes -
            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}

            jamesdumay James Dumay made changes -
            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}

            jamesdumay James Dumay made changes -
            Epic Link JENKINS-35750 [ 171713 ]
            mbadran mohamed badran made changes -
            Attachment Capture.JPG [ 34084 ]
            jamesdumay James Dumay made changes -
            kdawgwilk Kaden Wilkinson made changes -
            jamesdumay James Dumay made changes -
            Rank Ranked higher
            jamesdumay James Dumay made changes -
            Rank Ranked lower
            jamesdumay James Dumay made changes -
            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}
            jamesdumay James Dumay made changes -
            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}
            jamesdumay James Dumay made changes -
            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}
            jamesdumay James Dumay made changes -
            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}
            jamesdumay James Dumay made changes -
            Link This issue relates to JENKINS-35836 [ JENKINS-35836 ]
            jamesdumay James Dumay made changes -
            Link This issue relates to JENKINS-35836 [ JENKINS-35836 ]
            jamesdumay James Dumay made changes -
            Link This issue relates to JENKINS-39464 [ JENKINS-39464 ]
            jamesdumay James Dumay made changes -
            Link This issue relates to JENKINS-40619 [ JENKINS-40619 ]
            jamesdumay James Dumay made changes -
            Link This issue relates to JENKINS-40619 [ JENKINS-40619 ]
            jamesdumay James Dumay made changes -
            Link This issue is duplicated by JENKINS-40619 [ JENKINS-40619 ]
            jamesdumay James Dumay made changes -
            Rank Ranked higher
            jamesdumay James Dumay made changes -
            Rank Ranked lower
            jamesdumay James Dumay made changes -
            Remote Link This issue links to "Jenkins/Jenkins tried to use a matrix style parallel (Web Link)" [ 15226 ]
            jamesdumay James Dumay made changes -
            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}
            michaelneale Michael Neale made changes -
            Link This issue blocks JENKINS-35836 [ JENKINS-35836 ]
            ileitch Ian Leitch made changes -
            Attachment PipelineGraphProposal.png [ 35539 ]
            jamesdumay James Dumay made changes -
            Link This issue is duplicated by JENKINS-41781 [ JENKINS-41781 ]
            rhutchison Ryan Hutchison made changes -
            Link This issue is related to JENKINS-41156 [ JENKINS-41156 ]
            jamesdumay James Dumay made changes -
            Link This issue blocks JENKINS-42062 [ JENKINS-42062 ]
            michaelneale Michael Neale made changes -
            Link This issue relates to JENKINS-41205 [ JENKINS-41205 ]
            b_dean Ben Dean made changes -
            Attachment example.png [ 36599 ]
            b_dean Ben Dean made changes -
            Attachment pipeline_mockup.png [ 36602 ]
            ikari7789 Andrew Miller made changes -
            Attachment image-2017-04-12-16-16-17-144.png [ 37113 ]
            ikari7789 Andrew Miller made changes -
            Attachment image-2017-04-12-16-17-38-285.png [ 37114 ]
            praverma Prateek VERMA made changes -
            Assignee Jesse Glick [ jglick ]
            michaelneale Michael Neale made changes -
            Assignee Jesse Glick [ jglick ]
            praverma Prateek VERMA made changes -
            Attachment Proposed Parallel Stages.JPG [ 37115 ]
            fiztlen ben powers made changes -
            Attachment alternate zoom in.png [ 37120 ]
            tusharmahale Tushar Mahale made changes -
            Assignee Tushar Mahale [ tusharmahale ]
            jamesdumay James Dumay made changes -
            Assignee Tushar Mahale [ tusharmahale ]
            jamesdumay James Dumay made changes -
            Epic Link JENKINS-35750 [ 171713 ] JENKINS-43953 [ 181485 ]
            jamesdumay James Dumay made changes -
            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}
            jamesdumay James Dumay made changes -
            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}
            jamesdumay James Dumay made changes -
            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}
            jguigui Jean-Paul G made changes -
            Link This issue is related to JENKINS-44820 [ JENKINS-44820 ]
            jamesdumay James Dumay made changes -
            Link This issue is duplicated by JENKINS-45664 [ JENKINS-45664 ]
            macdrega Joerg Schwaerzler made changes -
            Attachment image-2017-08-14-10-29-55-373.png [ 39258 ]
            macdrega Joerg Schwaerzler made changes -
            Attachment image-2017-08-14-10-34-10-452.png [ 39259 ]
            macdrega Joerg Schwaerzler made changes -
            Attachment image-2017-08-14-10-29-55-373.png [ 39258 ]
            jamesdumay James Dumay made changes -
            Link This issue is duplicated by JENKINS-46345 [ JENKINS-46345 ]
            michaelneale Michael Neale made changes -
            Remote Link This issue links to "Page (Jenkins Wiki)" [ 17861 ]
            xtrom0rt Henri Anttila made changes -
            Attachment screenshot-1.png [ 40062 ]
            xtrom0rt Henri Anttila made changes -
            Attachment image-2017-10-19-08-24-00-504.png [ 40063 ]
            jamesdumay James Dumay made changes -
            Remote Link This issue links to "CloudBees Internal UX-584 (Web Link)" [ 18213 ]
            gabloe Gabriel Loewen made changes -
            Attachment Before.PNG [ 41786 ]
            gabloe Gabriel Loewen made changes -
            Attachment After.png [ 41787 ]
            jbriden Jenn Briden made changes -
            Assignee CloudBees Inc. [ cloudbees ]
            jbriden Jenn Briden made changes -
            Status Open [ 1 ] In Progress [ 3 ]
            jbriden Jenn Briden made changes -
            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}
            jbriden Jenn Briden made changes -
            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}
            jbriden Jenn Briden made changes -
            Summary Support nested stages in the Pipeline Graph View sequential stages in the pipeline visualization graph
            gertvdijk Gert van Dijk made changes -
            Attachment jenkins-weird-masked2.png [ 43737 ]
            dnusbaum Devin Nusbaum made changes -
            Link This issue duplicates JENKINS-49050 [ JENKINS-49050 ]
            dnusbaum Devin Nusbaum made changes -
            Status In Progress [ 3 ] Closed [ 6 ]
            Resolution Duplicate [ 3 ]
            dnusbaum Devin Nusbaum made changes -
            Released As Blue Ocean 1.8.0
            dnusbaum Devin Nusbaum made changes -
            Link This issue relates to JENKINS-53162 [ JENKINS-53162 ]
            jglick Jesse Glick made changes -
            Link This issue relates to JENKINS-54010 [ JENKINS-54010 ]
            feirenliu zengqiao liu made changes -
            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}

              People

              • Assignee:
                cloudbees CloudBees Inc.
                Reporter:
                mbadran mohamed badran
              • Votes:
                206 Vote for this issue
                Watchers:
                229 Start watching this issue

                Dates

                • Created:
                  Updated:
                  Resolved: