Groovy methods in pipelines in Jenkins - Mini Project: Build & Apply

Using Groovy Methods in Jenkins Pipelines

📖 Scenario: You are setting up a Jenkins pipeline to automate a simple build process. To keep your pipeline clean and reusable, you want to define a Groovy method inside the pipeline script that prints a welcome message with the project name.

🎯 Goal: Build a Jenkins pipeline script that defines a Groovy method called printWelcome which takes a project name as input and prints a welcome message. Then call this method in the pipeline to display the message.

📋 What You'll Learn

Create a Groovy method named printWelcome that accepts one parameter projectName

Inside the method, print the message: "Welcome to the project: <projectName>"

Call the printWelcome method inside the pipeline script with the project name "MyApp"

Use a pipeline block with agent any and a stage named "Greeting"

Print the output to the Jenkins console log

💡 Why This Matters

🌍 Real World

In real Jenkins pipelines, defining Groovy methods helps organize repeated tasks like notifications, validations, or formatting logs.

💼 Career

Knowing how to write and call Groovy methods in Jenkins pipelines is essential for DevOps engineers to create maintainable and scalable CI/CD workflows.

1

Create the Groovy method printWelcome

Define a Groovy method called printWelcome that takes one parameter named projectName. Inside the method, use echo to print the message "Welcome to the project: <projectName>".

Jenkins

# Define the Groovy method printWelcome with parameter projectName
# Your code here

Hint

Use def to define the method and echo to print inside Jenkins pipeline.

2

Set up the Jenkins pipeline skeleton

Create a pipeline block with agent any and a stage named "Greeting". Inside the stage, add a steps block.

Jenkins

def printWelcome(String projectName) {
    echo "Welcome to the project: ${projectName}"
}

pipeline {
    agent any
    stages {
        stage('Greeting') {
            steps {
                # Your code here
            }
        }
    }
}

Hint

Use the pipeline syntax with agent any and define a stage called Greeting.

3

Call the printWelcome method inside the pipeline

Inside the steps block of the Greeting stage, call the printWelcome method with the argument "MyApp".

Jenkins

def printWelcome(String projectName) {
    echo "Welcome to the project: ${projectName}"
}

pipeline {
    agent any
    stages {
        stage('Greeting') {
            steps {
                // Call printWelcome with "MyApp" here
                # Your code here
            }
        }
    }
}

Hint

Use a script block inside steps to call the Groovy method.

4

Run the pipeline and display the output

Run the pipeline script. The Jenkins console log should display the message Welcome to the project: MyApp. Add a print statement if needed to show the output.

Jenkins

def printWelcome(String projectName) {
    echo "Welcome to the project: ${projectName}"
}

pipeline {
    agent any
    stages {
        stage('Greeting') {
            steps {
                script {
                    printWelcome("MyApp")
                }
            }
        }
    }
}

// Run the pipeline and check output in Jenkins console
# Your code here

Hint

Check the Jenkins console output after running the pipeline to see the welcome message.

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