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

Parallel branches with no stage should not be displayed in Blue Ocean

    XMLWordPrintable

    Details

    • Similar Issues:

      Description

      With the following pipeline:

      stage("begin") { println "begin" }
      
      parallel (
          "no_stage": { println "no stage" },
          
          "": { println "no name" },
          
          "with_stage": { stage("my_stage") { println "named stage" } }
      )
      
      stage("end") { println "end" }
      

      we are getting the following display in BlueOcean:

      But in the parallel step, only the third branch has a stage defined, and therefore only this one is expected to be displayed. Unfortunately all the branches are displayed even if not containing any stage.
      Additionally, the name displayed for the third branch is the branch name instead of the stage name as one would have thought.

      On the other hand, in the Pipeline view it is displayed as expected:

      Use case: technical steps which need to run in parallel to maintain shared resources, advance timeout monitoring, etc ... doesn't have to pollute the Blue Ocean view.

      May be possible to add a boolean option to the parallel step not to use branch name as default display name in Blue Ocean, and eventually make branch with no stage invisible ?

        Attachments

          Issue Links

            Activity

            jguigui Jean-Paul G created issue -
            jguigui Jean-Paul G made changes -
            Field Original Value New Value
            Description With the following pipeline:
            {code:java}
            stage("begin") { println "begin" }

            parallel (
                "no_stage": { println "no stage" },
                
                "": { println "no name" },
                
                "with_stage": { stage("my_stage") { println "named stage" } }
            )

            stage("end") { println "end" }
            {code}
            we are getting the following display in BlueOcean:

            !blueocean.png!

            But in the parallel step, only the third step as a *stage* defined, and therefore only this one is expected to be displayed. Unfortunately all the branches are displayed even if not containing any stage

            Typically in the Pipeline view it is displayed as expected:

            !stages.png!

            Use case: technical steps which need to run in parallel to maintain shared resources, advance timeout monitoring, etc ... doesn't have to pollute the Blue Ocean view.
            With the following pipeline:
            {code:java}
            stage("begin") { println "begin" }

            parallel (
                "no_stage": { println "no stage" },
                
                "": { println "no name" },
                
                "with_stage": { stage("my_stage") { println "named stage" } }
            )

            stage("end") { println "end" }
            {code}
            we are getting the following display in BlueOcean:

            !blueocean.png!

            But in the parallel step, only the third branch has a *stage* defined, and therefore only this one is expected to be displayed. Unfortunately all the branches are displayed even if not containing any stage.
            Additionally, the name displayed for the third branch is the *branch name* instead of the *stage name* as one would have thought.

            On the other hand, in the Pipeline view it is displayed as expected:

            !stages.png!

            Use case: technical steps which need to run in parallel to maintain shared resources, advance timeout monitoring, etc ... doesn't have to pollute the Blue Ocean view.

            May be possible to add an boolean option to the parallel step not to use branch name as default display name in Blue Ocean ?
            jguigui Jean-Paul G made changes -
            Description With the following pipeline:
            {code:java}
            stage("begin") { println "begin" }

            parallel (
                "no_stage": { println "no stage" },
                
                "": { println "no name" },
                
                "with_stage": { stage("my_stage") { println "named stage" } }
            )

            stage("end") { println "end" }
            {code}
            we are getting the following display in BlueOcean:

            !blueocean.png!

            But in the parallel step, only the third branch has a *stage* defined, and therefore only this one is expected to be displayed. Unfortunately all the branches are displayed even if not containing any stage.
            Additionally, the name displayed for the third branch is the *branch name* instead of the *stage name* as one would have thought.

            On the other hand, in the Pipeline view it is displayed as expected:

            !stages.png!

            Use case: technical steps which need to run in parallel to maintain shared resources, advance timeout monitoring, etc ... doesn't have to pollute the Blue Ocean view.

            May be possible to add an boolean option to the parallel step not to use branch name as default display name in Blue Ocean ?
            With the following pipeline:
            {code:java}
            stage("begin") { println "begin" }

            parallel (
                "no_stage": { println "no stage" },
                
                "": { println "no name" },
                
                "with_stage": { stage("my_stage") { println "named stage" } }
            )

            stage("end") { println "end" }
            {code}
            we are getting the following display in BlueOcean:

            !blueocean.png!

            But in the parallel step, only the third branch has a *stage* defined, and therefore only this one is expected to be displayed. Unfortunately all the branches are displayed even if not containing any stage.
            Additionally, the name displayed for the third branch is the *branch name* instead of the *stage name* as one would have thought.

            On the other hand, in the Pipeline view it is displayed as expected:

            !stages.png!

            Use case: technical steps which need to run in parallel to maintain shared resources, advance timeout monitoring, etc ... doesn't have to pollute the Blue Ocean view.

            May be possible to add a boolean option to the parallel step not to use branch name as default display name in Blue Ocean ?
            jguigui Jean-Paul G made changes -
            Description With the following pipeline:
            {code:java}
            stage("begin") { println "begin" }

            parallel (
                "no_stage": { println "no stage" },
                
                "": { println "no name" },
                
                "with_stage": { stage("my_stage") { println "named stage" } }
            )

            stage("end") { println "end" }
            {code}
            we are getting the following display in BlueOcean:

            !blueocean.png!

            But in the parallel step, only the third branch has a *stage* defined, and therefore only this one is expected to be displayed. Unfortunately all the branches are displayed even if not containing any stage.
            Additionally, the name displayed for the third branch is the *branch name* instead of the *stage name* as one would have thought.

            On the other hand, in the Pipeline view it is displayed as expected:

            !stages.png!

            Use case: technical steps which need to run in parallel to maintain shared resources, advance timeout monitoring, etc ... doesn't have to pollute the Blue Ocean view.

            May be possible to add a boolean option to the parallel step not to use branch name as default display name in Blue Ocean ?
            With the following pipeline:
            {code:java}
            stage("begin") { println "begin" }

            parallel (
                "no_stage": { println "no stage" },
                
                "": { println "no name" },
                
                "with_stage": { stage("my_stage") { println "named stage" } }
            )

            stage("end") { println "end" }
            {code}
            we are getting the following display in BlueOcean:

            !blueocean.png!

            But in the parallel step, only the third branch has a *stage* defined, and therefore only this one is expected to be displayed. Unfortunately all the branches are displayed even if not containing any stage.
            Additionally, the name displayed for the third branch is the *branch name* instead of the *stage name* as one would have thought.

            On the other hand, in the Pipeline view it is displayed as expected:

            !stages.png!

            Use case: technical steps which need to run in parallel to maintain shared resources, advance timeout monitoring, etc ... doesn't have to pollute the Blue Ocean view.

            May be possible to add a boolean option to the parallel step not to use branch name as default display name in Blue Ocean, and eventually make branch with no stage invisible ?
            Hide
            jamesdumay James Dumay added a comment -

            Jean-Paul G this is related to a bunch of problems around sophisticated Pipelines.

            I am in the process of drafting a RFC to rationalise parallel usage.

            For example, in Declarative 1.2 we've introduced the following syntax called "Parallel Stages"

            stage('foo') {
                parallel {
                    stage('Firefox') {
                        steps {
                            echo "First branch"
                        }
                    }
                    stage('Chrome') {
                        steps {
                            echo "Second branch"
                        }
                    }
                }
            }
            

            The advantage here is that we now have different syntaxes for parallel execution and parallel stages.

            For reference the current syntax looks like:

            stage('foo') {
                parallel(
            		'copy-1': {
            			... copy some files ...
            		},
            		'copy-2': {
            			... copy some files ...
            		},
            		'some other process': {
            			 parallel(
            				'branch-1': {
            					... run process 1 ...
            				},
            				'branch-2': {
            					... run process 2 ...
            				}
            			)
            		}
            	)
            }
            

            With the syntax above its possible to next parallels infinitely and this is something Blue Ocean isn't likely to support.

            What I would like to do is:

            • Make the new Parallel Stage syntax the only way to visualise parallel
            • Parallel executions get folded into the nearest "stage" and their steps appear in the step listing according to their execution order.

            This is still some time away but it would cover the case you have outlined here.

            Let me know what you think

            Show
            jamesdumay James Dumay added a comment - Jean-Paul G this is related to a bunch of problems around sophisticated Pipelines. I am in the process of drafting a RFC to rationalise parallel usage. For example, in Declarative 1.2 we've introduced the following syntax called "Parallel Stages" stage( 'foo' ) { parallel { stage( 'Firefox' ) { steps { echo "First branch" } } stage( 'Chrome' ) { steps { echo "Second branch" } } } } The advantage here is that we now have different syntaxes for parallel execution and parallel stages. For reference the current syntax looks like: stage( 'foo' ) { parallel( 'copy-1' : { ... copy some files ... }, 'copy-2' : { ... copy some files ... }, 'some other process' : { parallel( 'branch-1' : { ... run process 1 ... }, 'branch-2' : { ... run process 2 ... } ) } ) } With the syntax above its possible to next parallels infinitely and this is something Blue Ocean isn't likely to support. What I would like to do is: Make the new Parallel Stage syntax the only way to visualise parallel Parallel executions get folded into the nearest "stage" and their steps appear in the step listing according to their execution order. This is still some time away but it would cover the case you have outlined here. Let me know what you think
            jamesdumay James Dumay made changes -
            Epic Link JENKINS-43953 [ 181485 ]
            Hide
            jguigui Jean-Paul G added a comment - - edited

            Hi James,

            I think there are two orthogonal concepts here:

            • the parallel branches used to run in parallel (on different cpu for instance) several tasks
            • the stage used for display purpose

            To be flexible and cover all the use cases, we need to have these two concept independent.
            Typically we may want:

            1. in a same branch have sequential stages
            2. in a same branch have nested stages
            3. having branch without stage (aka no display)

            Looks like your RFC is covering cases 1. and 2. but not 3.

            Today limitation with current implementation are:

            • the parallel branch is creating a stage with this branch name as the stage name
            • branches with no stages are displayed (linked to first point here above)
            • nested stages are not displayed

            Having the branch name (used in the log) different from the stage name (used in Blue Ocean display) is useful too.

            Regarding the representation of nested stages I like your suggestion. There is similar discussion on JENKINS-38442.

            Last point I can think about, is how to represent stage with same name in a parallel step. Typically when lot of branches are generated by a for loop. I'm not sure of the best option:

            • either aggregate them in one display (with eventually a badge indicating the number of stages with same name)
            • either display each of them

            Jean-Paul

            Show
            jguigui Jean-Paul G added a comment - - edited Hi James, I think there are two orthogonal concepts here: the parallel branches used to run in parallel (on different cpu for instance) several tasks the stage used for display purpose To be flexible and cover all the use cases, we need to have these two concept independent. Typically we may want: in a same branch have sequential stages in a same branch have nested stages having branch without stage (aka no display) Looks like your RFC is covering cases 1. and 2. but not 3. Today limitation with current implementation are: the parallel branch is creating a stage with this branch name as the stage name branches with no stages are displayed (linked to first point here above) nested stages are not displayed Having the branch name (used in the log) different from the stage name (used in Blue Ocean display) is useful too. Regarding the representation of nested stages I like your suggestion. There is similar discussion on JENKINS-38442 . Last point I can think about, is how to represent stage with same name in a parallel step. Typically when lot of branches are generated by a for loop. I'm not sure of the best option: either aggregate them in one display (with eventually a badge indicating the number of stages with same name) either display each of them Jean-Paul
            Hide
            jamesdumay James Dumay added a comment - - edited

            Jean-Paul G

            having branch without stage (aka no display)

            These will still need to be in a stage but you would not see the "parallels" in the visualisation. You need the enclosing stage for us to display the steps within the parallel.

            In your example, if we made these changes, your visualisation would look like:

            It is also highly unlikely we will be ever able to visualise infinitely nested parallels. This proposal would not attempt to address that use case.

            Thanks for the response

            Show
            jamesdumay James Dumay added a comment - - edited Jean-Paul G having branch without stage (aka no display) These will still need to be in a stage but you would not see the "parallels" in the visualisation. You need the enclosing stage for us to display the steps within the parallel. In your example, if we made these changes, your visualisation would look like: It is also highly unlikely we will be ever able to visualise infinitely nested parallels. This proposal would not attempt to address that use case. Thanks for the response
            jguigui Jean-Paul G made changes -
            Link This issue is related to JENKINS-38442 [ JENKINS-38442 ]
            jguigui Jean-Paul G made changes -
            Attachment image-2017-06-22-12-33-47-644.png [ 38583 ]
            Hide
            jguigui Jean-Paul G added a comment - - edited

            Hi James,

            If I understood properly, you mean that the following pipeline:

            stage("begin") { println "begin" }
            
            stage('stage_parallel') {
                parallel {
                    stage('stage_p1') {
                        steps {
                            echo "First branch"
                        }
                    }
                    stage(''stage_p2') {
                        steps {
                            echo "Second branch"
                        }
                    }
                }
            }
            
            stage("end") { println "end" }
            
            

            will not display the nested stage_p1 and stage_p2 and generate this:

             

             

            Show
            jguigui Jean-Paul G added a comment - - edited Hi James, If I understood properly, you mean that the following pipeline: stage( "begin" ) { println "begin" } stage( 'stage_parallel' ) { parallel { stage( 'stage_p1' ) { steps { echo "First branch" } } stage( ''stage_p2' ) { steps { echo "Second branch" } } } } stage( "end" ) { println "end" } will not display the nested stage_p1 and stage_p2 and generate this:    
            Hide
            jamesdumay James Dumay added a comment -

            Jean-Paul G that is correct

            Show
            jamesdumay James Dumay added a comment - Jean-Paul G that is correct
            Hide
            jamesdumay James Dumay added a comment - - edited

            Jean-Paul G actually, I spoke too soon. This pipeline:

            stage("begin") { println "begin" }
            
            stage('stage_parallel') {
                parallel {
                    'stage_p1': {
                            echo "First branch"
                    }
                     'stage_p2': {
                            echo "Second branch"
                    }
                }
            }
            
            stage("end") { println "end" }
            

            Would produce:

            Show
            jamesdumay James Dumay added a comment - - edited Jean-Paul G actually, I spoke too soon. This pipeline: stage( "begin" ) { println "begin" } stage( 'stage_parallel' ) { parallel { 'stage_p1' : { echo "First branch" } 'stage_p2' : { echo "Second branch" } } } stage( "end" ) { println "end" } Would produce:
            jguigui Jean-Paul G made changes -
            Attachment image-2017-06-22-12-47-13-324.png [ 38584 ]
            jguigui Jean-Paul G made changes -
            Attachment image-2017-06-22-12-53-45-573.png [ 38585 ]
            Hide
            jguigui Jean-Paul G added a comment -

            And the following pipeline with some branches not inside any stage:

            stage("begin") { println "begin" }
            
            stage('stage_parallel') {
                parallel {
                    stage('stage_p1') {
                        steps {
                            echo "First branch"
                        }
                    }
                    stage('stage_p2') {
                        steps {
                            echo "Second branch"
                        }
                    }
                    'invisible_branch_p3': {
                            echo "Third branch"
                    }
                    'invisible_branch_p4': {
                            echo "Fourth branch"
                    }
                }
            }
            
            stage("end") { println "end" }
            

            would produce with the proposed RFC:

             

            If it's the case, I've my use cases covered.

            Agree with you, multiple nested case will be difficult to display.

            Thanks a lot,

            Jean-Paul

             

            Show
            jguigui Jean-Paul G added a comment - And the following pipeline with some branches not inside any stage: stage( "begin" ) { println "begin" } stage( 'stage_parallel' ) { parallel { stage( 'stage_p1' ) { steps { echo "First branch" } } stage( 'stage_p2' ) { steps { echo "Second branch" } } 'invisible_branch_p3' : { echo "Third branch" } 'invisible_branch_p4' : { echo "Fourth branch" } } } stage( "end" ) { println "end" } would produce with the proposed RFC:   If it's the case, I've my use cases covered. Agree with you, multiple nested case will be difficult to display. Thanks a lot, Jean-Paul  
            Hide
            jamesdumay James Dumay added a comment -

            Jean-Paul G you wouldn't be able to put both parallel syntaxes within the same stage with the proposal as it stands

            Show
            jamesdumay James Dumay added a comment - Jean-Paul G you wouldn't be able to put both parallel syntaxes within the same stage with the proposal as it stands
            Hide
            jguigui Jean-Paul G added a comment -

            I hope you may reconsider the RFC. Definitely by splitting the execution (branch) and the display (stage) concepts, users will be given a much better flexibility. 

            Show
            jguigui Jean-Paul G added a comment - I hope you may reconsider the RFC. Definitely by splitting the execution (branch) and the display (stage) concepts, users will be given a much better flexibility. 
            Hide
            jamesdumay James Dumay added a comment -

            Jean-Paul G its still in the planning stages so I will consider when driving a decision on this one

            Show
            jamesdumay James Dumay added a comment - Jean-Paul G its still in the planning stages so I will consider when driving a decision on this one
            Hide
            jguigui Jean-Paul G added a comment -

            Great ! Thank you very much 

            Jean-Paul

            Show
            jguigui Jean-Paul G added a comment - Great ! Thank you very much  Jean-Paul
            pbro Paolo Brocco made changes -
            Link This issue is related to JENKINS-47473 [ JENKINS-47473 ]
            jamesdumay James Dumay made changes -
            Link This issue is related to JENKINS-47473 [ JENKINS-47473 ]
            jamesdumay James Dumay made changes -
            Remote Link This issue links to "Page (Jenkins Wiki)" [ 18147 ]
            Hide
            jamesdumay James Dumay added a comment -

            Merging this within JENKINS-47799 as it will likely be the solution we are heading towards.

            Show
            jamesdumay James Dumay added a comment - Merging this within JENKINS-47799 as it will likely be the solution we are heading towards.
            jamesdumay James Dumay made changes -
            Link This issue duplicates JENKINS-47799 [ JENKINS-47799 ]
            jamesdumay James Dumay made changes -
            Resolution Duplicate [ 3 ]
            Status Open [ 1 ] Resolved [ 5 ]

              People

              Assignee:
              Unassigned Unassigned
              Reporter:
              jguigui Jean-Paul G
              Votes:
              3 Vote for this issue
              Watchers:
              4 Start watching this issue

                Dates

                Created:
                Updated:
                Resolved: