Script blocks for Groovy in Jenkins - Commands & Configuration

Introduction

Script blocks in Groovy let you run multiple commands or complex logic inside Jenkins pipelines. They help you group steps that need to run together or use Groovy features not directly supported by pipeline syntax.

When you want to run several Groovy commands as one unit inside a Jenkins pipeline stage

When you need to use Groovy control structures like loops or conditionals inside your pipeline

When you want to define variables or functions inside your pipeline script

When you want to execute Groovy code that is not part of the declarative pipeline syntax

When you want to manipulate strings, lists, or maps using Groovy methods inside your pipeline

Config File - Jenkinsfile

Jenkinsfile

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                script {
                    def message = 'Hello from Groovy script block'
                    echo message
                    for (int i = 1; i <= 3; i++) {
                        echo "Counting: ${i}"
                    }
                }
            }
        }
    }
}

This Jenkinsfile defines a pipeline with one stage called 'Example'. Inside the steps, the script block allows running Groovy code.

The def message line creates a variable. The echo commands print messages to the Jenkins console. The for loop runs three times, showing how you can use Groovy control flow inside the script block.

Commands

Check that Jenkins Job Builder or Jenkins CLI is installed to run Jenkins pipelines.

Terminal

jenkins-jobs --version

Expected Output

jenkins-jobs 3.10.0

Trigger the Jenkins pipeline job named 'example-pipeline' that uses the Jenkinsfile with script blocks.

Terminal

jenkins-cli build example-pipeline

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] stage

[Pipeline] { (Example)

[Pipeline] script

[Pipeline] {

[Pipeline] echo

Hello from Groovy script block

[Pipeline] echo

Counting: 1

[Pipeline] echo

Counting: 2

[Pipeline] echo

Counting: 3

[Pipeline] }

[Pipeline] }

[Pipeline] End of Pipeline

Finished: SUCCESS

View the console output of the last run of the 'example-pipeline' to verify the script block executed correctly.

Terminal

jenkins-cli console example-pipeline

Expected Output

Started by user admin

Running in Durability level: MAX_SURVIVABILITY

[Pipeline] Start of Pipeline

[Pipeline] stage

[Pipeline] { (Example)

[Pipeline] script

[Pipeline] {

[Pipeline] echo

Hello from Groovy script block

[Pipeline] echo

Counting: 1

[Pipeline] echo

Counting: 2

[Pipeline] echo

Counting: 3

[Pipeline] }

[Pipeline] }

[Pipeline] End of Pipeline

Finished: SUCCESS

Key Concept

If you remember nothing else from script blocks, remember: they let you run full Groovy code inside Jenkins pipelines to add flexibility beyond declarative syntax.

Common Mistakes

Trying to use Groovy code outside a script block in a declarative pipeline

Declarative pipelines only allow limited Groovy expressions outside script blocks, so the code will fail to parse or run.

Always wrap complex Groovy code inside a script { } block in declarative pipelines.

Using pipeline steps like 'echo' inside Groovy code without proper syntax

Pipeline steps must be called as methods inside script blocks, not as plain Groovy commands, or they will cause errors.

Call pipeline steps like echo as methods inside script blocks, e.g., echo 'message'.

Defining variables inside script blocks but trying to use them outside

Variables defined inside script blocks have local scope and are not accessible outside the block.

Define variables at the pipeline or stage level if you need to use them outside script blocks.

Summary

Use script blocks in Jenkins pipelines to run multiple Groovy commands together.

Script blocks allow loops, conditionals, and variable definitions inside pipelines.

Always wrap complex Groovy code inside script { } in declarative pipelines to avoid errors.

Practice

1. What is the main purpose of using script blocks in Jenkins pipelines?

easy

A. To define environment variables

B. To specify the agent where the pipeline runs

C. To run Groovy code for custom logic inside the pipeline

D. To declare pipeline stages

Solution

1. Step 1: Understand Jenkins pipeline structure

   Jenkins pipelines use declarative syntax but allow Groovy code inside script blocks for flexibility.

2. Step 2: Identify the role of script blocks

   script blocks let you write Groovy code for loops, conditions, and other logic not directly supported in declarative syntax.

3. Final Answer:

   To run Groovy code for custom logic inside the pipeline -> Option C

4. Quick Check:

   Script blocks = Groovy code inside pipeline [OK]

Hint: Script blocks run Groovy code inside steps [OK]

Common Mistakes:

• Confusing script blocks with environment or agent declarations
• Thinking script blocks define stages
• Assuming script blocks are optional for all logic

2. Which of the following is the correct way to start a script block inside a declarative Jenkins pipeline?

easy

A. script { echo 'Hello' }

B. script: { echo 'Hello' }

C. script() { echo 'Hello' }

D. script => { echo 'Hello' }

Solution

1. Step 1: Recall correct syntax for script blocks

   In declarative pipelines, script is a block keyword followed by curly braces containing Groovy code.

2. Step 2: Compare options

   Only script { ... } is valid Groovy block syntax. Others use invalid punctuation or keywords.

3. Final Answer:

   script { echo 'Hello' } -> Option A

4. Quick Check:

   script block syntax = script { ... } [OK]

Hint: Use script { } with braces, no colons or arrows [OK]

Common Mistakes:

• Using colons or arrows instead of braces
• Adding parentheses after script keyword
• Misplacing quotes or braces

3. What will be the output of this Jenkins pipeline snippet?

pipeline {
  agent any
  stages {
    stage('Example') {
      steps {
        script {
          def sum = 0
          for (i in 1..3) {
            sum += i
          }
          echo "Sum is ${sum}"
        }
      }
    }
  }
}

medium

A. Sum is 6

B. Sum is 3

C. Sum is 0

D. Syntax error

Solution

1. Step 1: Analyze the for loop inside script block

   The loop runs from 1 to 3 inclusive, adding each number to sum: 1 + 2 + 3 = 6.

2. Step 2: Understand echo output

   The echo prints the string with sum value interpolated, so output is "Sum is 6".

3. Final Answer:

   Sum is 6 -> Option A

4. Quick Check:

   1+2+3=6 output = Sum is 6 [OK]

Hint: Sum 1 to 3 = 6; echo prints it [OK]

Common Mistakes:

• Thinking loop ends at 2
• Confusing sum initialization
• Assuming syntax error due to script block

4. Identify the error in this Jenkins pipeline snippet using a script block:

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        script {
          for i in 1..3 {
            echo "Number: ${i}"
          }
        }
      }
    }
  }
}

medium

A. Script block must be outside steps

B. Incorrect use of echo inside script block

C. Agent declaration is invalid

D. Missing parentheses around for loop variable and range

Solution

1. Step 1: Check for loop syntax in Groovy

   Groovy requires parentheses around the for loop variable and range: for (i in 1..3).

2. Step 2: Identify the error in given code

   The code uses for i in 1..3 without parentheses, causing syntax error.

3. Final Answer:

   Missing parentheses around for loop variable and range -> Option D

4. Quick Check:

   Groovy for loop needs ( ) [OK]

Hint: Always use parentheses in Groovy for loops [OK]

Common Mistakes:

• Omitting parentheses in for loops
• Misplacing script block outside steps
• Confusing echo usage inside script

5. You want to use a script block in Jenkins to create a map of numbers to their squares for numbers 1 to 4, then print each pair. Which code snippet correctly does this inside a script block?

hard

A. def squares = []
for (i in 1..4) {
squares.add(i * i)
}
squares.each { echo "${it} squared" }

B. def squares = [:]
for (i in 1..4) {
squares[i] = i * i
}
squares.each { k, v -> echo "${k} squared is ${v}" }

C. def squares = [:]
for i in 1..4 {
squares[i] = i * i
}
squares.each { k, v -> echo "${k} squared is ${v}" }

D. def squares = [:]
for (i in 1..4) {
squares[i] = i ^ 2
}
squares.each { k, v -> echo "${k} squared is ${v}" }

Solution

1. Step 1: Check map creation and loop syntax

   def squares = [:] for (i in 1..4) { squares[i] = i * i } squares.each { k, v -> echo "${k} squared is ${v}" } correctly creates an empty map with [:] and uses parentheses in the for loop.

2. Step 2: Verify square calculation and iteration

   def squares = [:] for (i in 1..4) { squares[i] = i * i } squares.each { k, v -> echo "${k} squared is ${v}" } uses i * i for squares and iterates map with each { k, v -> ... } to echo key-value pairs.

3. Final Answer:

   def squares = [:] for (i in 1..4) { squares[i] = i * i } squares.each { k, v -> echo "${k} squared is ${v}" } -> Option B

4. Quick Check:

   Map with for (i in 1..4) and i*i is correct [OK]

Hint: Use [:] for map, for (i in range), i*i for squares [OK]

Common Mistakes:

• Using list [] instead of map [:]
• Omitting parentheses in for loop
• Using ^ for power instead of *
• Incorrect map iteration syntax