Stage block structure in Jenkins - Step-by-Step Execution

Process Flow - Stage block structure

Start Pipeline

↓

Enter stages block

↓

Execute stage 1

↓

Execute stage 2

↓

... more stages ...

↓

Exit stages block

↓

End Pipeline

The pipeline starts, enters the stages block, executes each stage in order, then exits the stages block and ends.

Execution Sample

Jenkins

pipeline {
  agent any
  stages {
    stage('Build') {
      steps { echo 'Building...' }
    }
  }
}

This pipeline runs one stage named 'Build' that prints 'Building...'.

Process Table

Step	Block Entered	Action	Output	Next Step
1	pipeline	Start pipeline execution	Pipeline started	Enter stages block
2	stages	Enter stages block	Ready to run stages	Enter stage 'Build'
3	stage('Build')	Run steps block	Prints: Building...	Exit stage 'Build'
4	stage('Build')	Exit stage block	Stage 'Build' complete	Exit stages block
5	stages	Exit stages block	All stages complete	End pipeline
6	pipeline	End pipeline execution	Pipeline finished	Stop

💡 All stages executed, pipeline ends normally

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
pipeline_state	Not started	Running	Running	Running	Finished
current_block	None	stages	stage('Build')	stages	None
stage_status	None	Pending	Running	Complete	Complete

Key Moments - 2 Insights

Why does the pipeline enter the 'stages' block before running any stage?

The 'stages' block groups all stages together. Execution must enter it first to know which stages to run, as shown in step 2 of the execution table.

What happens if there are multiple stages inside the 'stages' block?

Each stage runs one after another inside the 'stages' block. The pipeline enters each stage block in order, runs its steps, then moves to the next stage, similar to step 3 and 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the 'current_block' after step 3?

A stages

B pipeline

C stage('Build')

D None

💡 Hint

Check the 'current_block' column in variable_tracker after step 3

At which step does the pipeline finish execution?

A Step 5

B Step 6

C Step 4

D Step 3

💡 Hint

Look at the 'pipeline_state' variable in variable_tracker and the 'Action' column in execution_table

If a second stage is added after 'Build', what will happen after step 4?

A Next stage block starts executing

B Stages block exits

C Pipeline ends immediately

D Pipeline restarts

💡 Hint

Refer to the concept_flow and execution_table steps for multiple stages

Concept Snapshot

pipeline {
  agent any
  stages {
    stage('Name') {
      steps { ... }
    }
  }
}

- 'stages' groups multiple 'stage' blocks
- Each 'stage' runs sequentially
- Steps inside 'stage' execute commands
- Pipeline ends after all stages complete

Full Transcript

The Jenkins pipeline starts by entering the pipeline block. Inside it, the stages block groups all stages. The pipeline enters the stages block, then executes each stage one by one. For each stage, it runs the steps defined inside. After finishing all stages, the pipeline exits the stages block and ends. Variables like current_block and stage_status track which part is running. This structure helps organize tasks clearly and run them in order.

Practice

1. What is the main purpose of a stage block in a Jenkins pipeline?

easy

A. To define environment variables for the pipeline

B. To divide the pipeline into named steps for better organization and tracking

C. To specify the agent where the pipeline runs

D. To declare global variables accessible in all stages

Solution

1. Step 1: Understand the role of stage in Jenkins

   The stage block is used to split the pipeline into named sections, making it easier to follow and debug.

2. Step 2: Compare with other pipeline blocks

   Other blocks like environment or agent serve different purposes, not organizing steps.

3. Final Answer:

   To divide the pipeline into named steps for better organization and tracking -> Option B

4. Quick Check:

   Stage block purpose = organization [OK]

Hint: Stages name steps to track progress clearly [OK]

Common Mistakes:

• Confusing stage with environment block
• Thinking stage sets agents
• Assuming stage declares variables

2. Which of the following is the correct syntax for defining a stage named Build with a simple shell command in Jenkins declarative pipeline?

easy

A. stage('Build') { step { sh 'make' } }

B. stage: 'Build' { steps { sh 'make' } }

C. stage('Build') { steps { sh 'make' } }

D. stage('Build') steps { sh 'make' }

Solution

1. Step 1: Recall correct stage block syntax

   The correct syntax uses stage('Name') { steps { ... } } with curly braces and plural steps.

2. Step 2: Identify syntax errors in other options

   The other options contain these errors: singular step instead of plural steps, colon : instead of parentheses for the stage name, and missing opening brace before steps.

3. Final Answer:

   stage('Build') { steps { sh 'make' } } -> Option C

4. Quick Check:

   Correct stage syntax = stage('Build') { steps { sh 'make' } } [OK]

Hint: Remember: stage('name') { steps { ... } } [OK]

Common Mistakes:

• Using colon instead of braces
• Writing singular 'step' instead of 'steps'
• Omitting braces around steps block

3. Given this Jenkins pipeline snippet, what will be the output in the console for the Test stage?

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        echo 'Running tests'
      }
    }
  }
}

medium

A. No output

B. Test stage skipped

C. Syntax error in pipeline

D. Running tests

Solution

1. Step 1: Analyze the pipeline snippet

   The pipeline defines a single stage named 'Test' with a step that echoes 'Running tests'.

2. Step 2: Understand echo behavior in Jenkins

   The echo command prints the given string to the console output during the stage execution.

3. Final Answer:

   Running tests -> Option D

4. Quick Check:

   Echo prints message = Running tests [OK]

Hint: Echo prints text inside steps block [OK]

Common Mistakes:

• Assuming echo does not print
• Thinking stage is skipped
• Confusing syntax errors

4. Identify the error in this Jenkins pipeline stage block:

stage('Deploy') {
  step {
    sh 'deploy.sh'
  }
}

medium

A. The block should use steps instead of step

B. The stage name must be lowercase

C. The sh command is invalid inside a stage

D. Missing agent declaration inside the stage

Solution

1. Step 1: Check the block keyword inside stage

   The correct keyword to wrap commands inside a stage is steps (plural), not step.

2. Step 2: Verify other options

   Stage names can be any case, sh is valid inside steps, and agent is optional if defined globally.

3. Final Answer:

   The block should use steps instead of step -> Option A

4. Quick Check:

   Use 'steps' block inside stage [OK]

Hint: Inside stage, use 'steps' plural for commands [OK]

Common Mistakes:

• Using singular 'step' instead of 'steps'
• Thinking stage name case matters
• Assuming sh is invalid inside stage

5. You want to create a Jenkins pipeline with two stages: Build and Test. The Test stage should only run if the Build stage succeeds. Which structure correctly enforces this using stage blocks?

hard

A. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { expression { currentBuild.result == null || currentBuild.result == 'SUCCESS' } } steps { sh 'make test' } } } }

B. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { steps { sh 'make test' } } } }

C. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { branch 'main' } steps { sh 'make test' } } } }

D. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { steps { sh 'make test' } post { always { echo 'Test done' } } } } }

Solution

1. Step 1: Understand stage execution conditions

   By default, stages run sequentially but may run even if previous stages fail. To run Test only if Build succeeds, use a when condition checking build result.

2. Step 2: Analyze options for conditional execution

   pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { expression { currentBuild.result == null || currentBuild.result == 'SUCCESS' } } steps { sh 'make test' } } } } uses when with an expression checking if the current build result is success or null (meaning no failure yet), ensuring Test runs only after successful Build.

3. Step 3: Verify other options

   pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { steps { sh 'make test' } } } } runs both stages unconditionally. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { branch 'main' } steps { sh 'make test' } } } } runs Test only on branch 'main' but not based on build success. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { steps { sh 'make test' } post { always { echo 'Test done' } } } } } runs Test always and adds a post action.

4. Final Answer:

   pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { expression { currentBuild.result == null || currentBuild.result == 'SUCCESS' } } steps { sh 'make test' } } } } -> Option A

5. Quick Check:

   Use 'when' with build result for conditional stages [OK]

Hint: Use 'when' block to run stage only on success [OK]

Common Mistakes:

• Assuming stages run conditionally by default
• Using branch condition instead of build result
• Missing 'when' block for conditional execution