Groovy syntax in pipelines in Jenkins - Commands & Configuration

Introduction

Groovy is the language used to write Jenkins pipelines. It helps automate tasks like building, testing, and deploying software by defining steps in a simple script.

When you want to automate your software build and deployment process in Jenkins.

When you need to define multiple steps that run in order, like compiling code, running tests, and deploying.

When you want to reuse code blocks or variables inside your Jenkins pipeline.

When you want to add conditions to run certain steps only if specific criteria are met.

When you want to organize your pipeline with stages and parallel tasks.

Config File - Jenkinsfile

Jenkinsfile

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building the project'
            }
        }
        stage('Test') {
            steps {
                echo 'Running tests'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying application'
            }
        }
    }
}

This Jenkinsfile defines a simple pipeline with three stages: Build, Test, and Deploy.

pipeline: The main block that defines the pipeline.

agent any: Runs the pipeline on any available Jenkins agent.

stages: Contains all the stages of the pipeline.

stage('Name'): Defines a step group with a name.

steps: Contains the commands or actions to run in that stage.

echo: Prints a message to the Jenkins console output.

Commands

Check if Jenkins CLI or Jenkins Job Builder is installed to interact with Jenkins pipelines.

Terminal

jenkins-jobs --version

Expected Output

jenkins-job-builder 3.9.0

View the Jenkinsfile content to understand the pipeline script written in Groovy syntax.

Terminal

cat Jenkinsfile

Expected Output

pipeline {

    agent any

    stages {

        stage('Build') {

            steps {

                echo 'Building the project'

            }

        }

        stage('Test') {

            steps {

                echo 'Running tests'

            }

        }

        stage('Deploy') {

            steps {

                echo 'Deploying application'

            }

        }

    }

}

Trigger the Jenkins pipeline named 'my-pipeline' to run the Groovy script and execute the defined stages.

Terminal

jenkins-cli build my-pipeline

Expected Output

Started build #1

Waiting for build to complete...

Finished: SUCCESS

→

--wait - Waits for the build to finish before returning control

View the console output of build number 1 to see the Groovy script execution results and messages.

Terminal

jenkins-cli console my-pipeline 1

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] echo

Building the project

[Pipeline] echo

Running tests

[Pipeline] echo

Deploying application

[Pipeline] End of Pipeline

Finished: SUCCESS

Key Concept

If you remember nothing else from this pattern, remember: Jenkins pipelines use Groovy scripts to define clear, step-by-step automation for building, testing, and deploying software.

Common Mistakes

Writing pipeline steps without proper indentation or braces.

Groovy syntax requires correct structure; otherwise, Jenkins will fail to parse the Jenkinsfile.

Always use consistent indentation and enclose blocks with braces {} as shown in the example.

Using shell commands directly without the 'sh' step in scripted pipelines.

Jenkins expects shell commands inside 'sh' steps to execute them properly.

Wrap shell commands inside 'sh' blocks, for example: sh 'echo Hello'.

Forgetting to define an agent in the pipeline.

Without an agent, Jenkins does not know where to run the pipeline steps.

Always specify 'agent any' or a specific agent to run the pipeline.

Summary

Jenkins pipelines use Groovy syntax to automate software build, test, and deployment steps.

A Jenkinsfile defines stages and steps with clear structure using pipeline, agent, stages, stage, and steps blocks.

Commands include viewing the Jenkinsfile, triggering the pipeline, and checking the console output to verify execution.

Practice

1. In a Jenkins pipeline script using Groovy, what does the stage block represent?

easy

A. A loop for repeating tasks

B. A logical phase or step in the pipeline process

C. A function definition

D. A variable declaration

Solution

1. Step 1: Understand the purpose of stage in Jenkins pipelines

   The stage block is used to define a distinct phase or step in the pipeline, such as build, test, or deploy.

2. Step 2: Differentiate from other Groovy constructs

   It is not a variable, function, or loop but a way to organize pipeline tasks clearly.

3. Final Answer:

   A logical phase or step in the pipeline process -> Option B

4. Quick Check:

   stage = logical step [OK]

Hint: Remember: stage means a step or phase in pipeline [OK]

Common Mistakes:

• Confusing stage with variable or function
• Thinking stage is a loop
• Assuming stage is a Groovy keyword unrelated to Jenkins

2. Which of the following is the correct syntax to define a variable name with value Jenkins in a Groovy pipeline script?

easy

A. name := "Jenkins"

B. var name = 'Jenkins'

C. def name = "Jenkins"

D. let name = 'Jenkins'

Solution

1. Step 1: Recall Groovy variable declaration syntax

   Groovy uses def to declare variables, so def name = "Jenkins" is correct.

2. Step 2: Identify incorrect syntax

   var and let are JavaScript keywords, and := is not Groovy syntax.

3. Final Answer:

   def name = "Jenkins" -> Option C

4. Quick Check:

   def declares variables in Groovy [OK]

Hint: Use def to declare variables in Groovy [OK]

Common Mistakes:

• Using JavaScript keywords like var or let
• Using := which is not Groovy syntax
• Forgetting quotes around string values

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

def result = []
for (i in 1..3) {
  result << i * 2
}
return result

medium

A. [2, 4, 6]

B. [1, 2, 3]

C. [3, 6, 9]

D. SyntaxError

Solution

1. Step 1: Understand the loop and range

   The loop runs from 1 to 3 inclusive, so i takes values 1, 2, 3.

2. Step 2: Calculate each iteration's result

   Each i is multiplied by 2 and added to the list: 2, 4, 6.

3. Final Answer:

   [2, 4, 6] -> Option A

4. Quick Check:

   Loop 1..3 * 2 = [2,4,6] [OK]

Hint: Multiply each loop value by 2 and collect in list [OK]

Common Mistakes:

• Confusing range syntax with exclusive end
• Forgetting to append to list
• Expecting syntax error due to unfamiliar Groovy syntax

4. Identify the error in this Jenkins pipeline Groovy snippet:

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        echo 'Building...'
      }
    }
  }
  post {
    always {
      echo 'Cleaning up'
    }
  }
}

medium

A. No error, syntax is correct

B. Missing script block inside steps

C. Missing environment block

D. Incorrect use of post block outside stages

Solution

1. Step 1: Review pipeline structure

   The pipeline has agent, stages with one stage and post block correctly placed.

2. Step 2: Check syntax correctness

   Using echo inside steps is valid without needing script. The post block is correctly outside stages.

3. Final Answer:

   No error, syntax is correct -> Option A

4. Quick Check:

   Pipeline syntax valid as given [OK]

Hint: Remember post block is outside stages, steps can have echo directly [OK]

Common Mistakes:

• Thinking echo needs script block
• Assuming post must be inside stages
• Expecting environment block is mandatory

5. How can you write a Groovy pipeline snippet to run a shell command ls -l only if a variable runList is true?

hard

A. stage('List') { if runList sh 'ls -l' }

B. when (runList) { sh 'ls -l' }

C. sh 'ls -l' if runList

D. if (runList) { sh 'ls -l' }

Solution

1. Step 1: Use Groovy if statement syntax

   Groovy uses if (condition) { ... } to run code conditionally.

2. Step 2: Apply condition to run shell command

   Inside the steps block, if (runList) { sh 'ls -l' } runs the shell command only if runList is true.

3. Final Answer:

   if (runList) { sh 'ls -l' } -> Option D

4. Quick Check:

   Groovy if syntax with braces [OK]

Hint: Use if(condition) { ... } to run commands conditionally [OK]

Common Mistakes:

• Using when instead of if for condition
• Omitting parentheses in if statement
• Trying inline if without proper Groovy syntax