Groovy methods in pipelines in Jenkins - Commands & Configuration

Introduction

Jenkins pipelines use Groovy code to automate tasks. Groovy methods help organize repeated steps into reusable blocks, making pipelines cleaner and easier to manage.

When you want to run the same set of steps multiple times in a pipeline without repeating code.

When you need to break a complex pipeline into smaller, understandable parts.

When you want to pass parameters to a block of code to customize its behavior.

When you want to improve pipeline readability by naming logical groups of steps.

When you want to reuse code across different stages or jobs in Jenkins.

Config File - Jenkinsfile

Jenkinsfile

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                script {
                    def greet(name) {
                        echo "Hello, ${name}!"
                    }
                    greet('World')
                }
            }
        }
    }
}

This Jenkinsfile defines a pipeline with one stage called 'Example'. Inside the stage, a Groovy method named greet is declared using def. This method takes a parameter name and prints a greeting message. The method is then called with the argument 'World'.

This shows how to define and use Groovy methods inside the script block of a Jenkins pipeline.

Commands

Check that Jenkins Job Builder or Jenkins CLI is installed and accessible before running pipelines.

Terminal

jenkins-jobs --version

Expected Output

2.0.0

Trigger the Jenkins pipeline named 'example-pipeline' and wait for it to finish to see the output.

Terminal

jenkins-cli build example-pipeline -s

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] stage

[Pipeline] { (Example)

[Pipeline] script

[Pipeline] echo

Hello, World!

[Pipeline] }

[Pipeline] // stage

[Pipeline] End of Pipeline

Finished: SUCCESS

→

-s - Waits for the build to complete and shows the console output.

Key Concept

If you remember nothing else from this pattern, remember: Groovy methods let you group and reuse pipeline steps to keep your Jenkinsfile clean and easy to read.

Common Mistakes

Defining Groovy methods outside the script block in a declarative pipeline.

Declarative pipelines require Groovy code like method definitions to be inside the script block; otherwise, Jenkins will fail to parse the pipeline.

Always define Groovy methods inside a script block within your pipeline stages.

Calling a Groovy method before it is defined in the script block.

Groovy methods must be defined before they are called; otherwise, Jenkins throws a missing method error.

Define the method first, then call it later in the script block.

Summary

Define Groovy methods inside the script block of Jenkins pipeline stages.

Use methods to group repeated or complex steps for better readability.

Call methods after defining them to reuse code and pass parameters.

Practice

1. What is the correct way to define a reusable method in a Jenkins pipeline using Groovy?

easy

A. Use def methodName() { } inside a script block

B. Use function methodName() { } outside the pipeline

C. Use method methodName() { } inside steps

D. Use def methodName[] { } inside environment

Solution

1. Step 1: Understand Groovy method syntax in Jenkins

   Groovy methods are defined with def methodName() { } syntax inside script blocks in Jenkins pipelines.

2. Step 2: Identify correct placement

   Methods must be inside script blocks to be recognized and used in declarative pipelines.

3. Final Answer:

   Use def methodName() { } inside a script block -> Option A

4. Quick Check:

   Groovy method = def methodName() { } [OK]

Hint: Remember: def + methodName() inside script block [OK]

Common Mistakes:

• Using 'function' keyword instead of 'def'
• Defining methods outside script blocks
• Using incorrect syntax like square brackets
• Placing methods inside environment block

2. Which of the following is the correct syntax to call a Groovy method named buildApp with a parameter version inside a Jenkins pipeline?

easy

A. buildApp version

B. buildApp->version

C. call buildApp(version)

D. buildApp(version)

Solution

1. Step 1: Recall method call syntax in Groovy

   Groovy methods are called with parentheses enclosing parameters, like methodName(param).

2. Step 2: Match the correct option

   buildApp(version) uses buildApp(version), which is the correct way to call the method with a parameter.

3. Final Answer:

   buildApp(version) -> Option D

4. Quick Check:

   Method call with parentheses = buildApp(version) [OK]

Hint: Call methods with parentheses around parameters [OK]

Common Mistakes:

• Calling method without parentheses
• Using 'call' keyword unnecessarily
• Using arrow syntax which is invalid
• Passing parameters without parentheses

3. Given the following Jenkins pipeline snippet, what will be printed in the console?

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        script {
          def greet(name) {
            return "Hello, ${name}!"
          }
          echo greet('Alice')
        }
      }
    }
  }
}

medium

A. Error: Method not found

B. Hello, Alice!

C. Hello, ${name}!

D. greet(Alice)

Solution

1. Step 1: Understand method definition and call

   The method greet takes a parameter name and returns a string with the name inserted.

2. Step 2: Evaluate the method call inside echo

   Calling greet('Alice') returns "Hello, Alice!" which is printed by echo.

3. Final Answer:

   Hello, Alice! -> Option B

4. Quick Check:

   Method returns greeting string = Hello, Alice! [OK]

Hint: Method returns string with parameter replaced [OK]

Common Mistakes:

• Expecting literal ${name} instead of substituted value
• Thinking method call prints method name
• Assuming method is undefined causing error
• Confusing method call syntax

4. Identify the error in this Jenkins pipeline Groovy method usage:

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        script {
          def compile() {
            echo 'Compiling...'
          }
          compile
        }
      }
    }
  }
}

medium

A. Method compile is called without parentheses causing no execution

B. Method compile is not defined properly with def

C. echo cannot be used inside methods

D. script block cannot contain method definitions

Solution

1. Step 1: Check method call syntax

   The method compile is defined correctly but called without parentheses, so it is treated as a reference, not executed.

2. Step 2: Understand Groovy method invocation

   To execute the method, parentheses are required: compile().

3. Final Answer:

   Method compile is called without parentheses causing no execution -> Option A

4. Quick Check:

   Call methods with () to execute [OK]

Hint: Always add () when calling methods to run them [OK]

Common Mistakes:

• Calling method without parentheses
• Thinking def is missing for method
• Assuming echo can't be inside methods
• Believing script block forbids method definitions

5. You want to create a Groovy method in a Jenkins pipeline that takes a list of strings and returns a single string with all items joined by commas. Which method implementation is correct?

hard

A. def joinList(items) { return items + "," }

B. def joinList(items) { items.join }

C. def joinList(items) { return items.join(",") }

D. def joinList(items) { items.collect { it + "," } }

Solution

1. Step 1: Understand Groovy list joining

   The join method on a list combines elements into a string separated by the given delimiter.

2. Step 2: Check method correctness

   def joinList(items) { return items.join(",") } correctly returns items.join(",") which joins list items with commas.

3. Final Answer:

   def joinList(items) { return items.join(",") } -> Option C

4. Quick Check:

   Use list.join(",") to combine items [OK]

Hint: Use list.join(",") to join list elements into string [OK]

Common Mistakes:

• Forgetting to return the joined string
• Using + operator which concatenates incorrectly
• Using collect which returns a list, not string
• Omitting parentheses in join method