Try-catch-finally in pipelines in Jenkins - Step-by-Step Execution

Process Flow - Try-catch-finally in pipelines

Start Pipeline

↓

Try Block: Run Steps

↓

Error Occurs?

No→Skip Catch

Yes↓

Catch Block: Handle Error

↓

Finally Block: Always Runs

↓

End Pipeline

The pipeline runs the try block steps first. If an error happens, it jumps to catch. Finally always runs at the end.

Execution Sample

Jenkins

pipeline {
  agent any
  stages {
    stage('Example') {
      steps {
        script {
          try {
            sh 'exit 1'
          } catch (err) {
            echo "Caught error: ${err}"
          } finally {
            echo 'Always runs'
          }
        }
      }
    }
  }
}

This pipeline tries to run a failing shell command, catches the error, then runs the finally block.

Process Table

Step	Action	Result	Next Step
1	Start pipeline and enter try block	No error yet	Run shell command
2	Run shell command 'exit 1'	Command fails with error code 1	Jump to catch block
3	Catch block runs	Error caught and message printed	Run finally block
4	Finally block runs	Message 'Always runs' printed	Pipeline ends

💡 Pipeline ends after finally block runs

Status Tracker

Variable	Start	After Step 2	After Step 3	Final
err	null	error object from shell failure	error object retained	error object retained

Key Moments - 2 Insights

Why does the pipeline run the finally block even after an error?

The finally block always runs regardless of errors, as shown in execution_table step 4, ensuring cleanup or final steps happen.

What happens if no error occurs in the try block?

If no error occurs, the catch block is skipped and the pipeline goes directly to finally, as shown by the 'No error yet' in step 1 and skipping step 3.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 2?

A The shell command fails with error code 1

B The shell command runs successfully

C The catch block runs

D The finally block runs

💡 Hint

Check the 'Result' column for step 2 in the execution_table

At which step does the pipeline print the error message?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for the 'Catch block runs' action in the execution_table

If the shell command succeeded, which step would be skipped?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Refer to key_moments about what happens if no error occurs

Concept Snapshot

Try-catch-finally in Jenkins pipelines:
- try: run steps that may fail
- catch: handle errors if try fails
- finally: always runs after try/catch
- ensures cleanup or messages run no matter what
- catch skipped if no error
- finally always runs

Full Transcript

In Jenkins pipelines, the try-catch-finally structure helps manage errors. The pipeline starts by running the try block steps. If an error occurs, it jumps to the catch block to handle it. Regardless of error or not, the finally block always runs at the end. This ensures important cleanup or messages always happen. For example, running a shell command that fails triggers the catch block to print the error, then the finally block runs. If the command succeeds, the catch block is skipped but finally still runs. This flow helps keep pipelines reliable and clear.

Practice

1. What is the main purpose of using try-catch-finally blocks in Jenkins pipelines?

easy

A. To create parallel stages automatically

B. To speed up the pipeline execution

C. To handle errors and ensure cleanup actions run

D. To deploy applications to production

Solution

1. Step 1: Understand the role of try-catch-finally

   The try block runs code that might fail, catch handles errors, and finally runs cleanup code regardless of success or failure.

2. Step 2: Identify the main purpose in Jenkins pipelines

   This structure helps manage errors gracefully and ensures cleanup steps always run, making pipelines reliable.

3. Final Answer:

   To handle errors and ensure cleanup actions run -> Option C

4. Quick Check:

   Error handling and cleanup = A [OK]

Hint: Remember: try for risky code, catch errors, finally cleans up [OK]

Common Mistakes:

• Thinking try-catch-finally speeds up pipelines
• Confusing try-catch-finally with deployment steps
• Assuming finally runs only on success

2. Which of the following is the correct syntax to catch an exception in a Jenkins scripted pipeline?

easy

A. try { ... } catch Exception e { ... } finally { ... }

B. try { ... } catch(Exception e) { ... } finally { ... }

C. try { ... } catch { Exception e } finally { ... }

D. try: { ... } except(Exception e) { ... } finally { ... }

Solution

1. Step 1: Recall Jenkins scripted pipeline syntax

   Jenkins scripted pipelines use Groovy syntax, where try { ... } catch(Exception e) { ... } finally { ... } is correct.

2. Step 2: Identify syntax errors in other options

   Options A, B, and C have incorrect keywords or misplaced braces not valid in Groovy.

3. Final Answer:

   try { ... } catch(Exception e) { ... } finally { ... } -> Option B

4. Quick Check:

   Groovy try-catch syntax = D [OK]

Hint: Groovy uses catch(Exception e) with braces, not colons or misplaced braces [OK]

Common Mistakes:

• Using Python-style except instead of catch
• Misplacing braces around catch block
• Omitting parentheses around exception

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

try {
  echo 'Start'
  error('Fail here')
  echo 'End'
} catch (Exception e) {
  echo 'Caught error'
} finally {
  echo 'Cleanup'
}

medium

A. Start\nCaught error\nCleanup

B. Caught error\nCleanup

C. Start\nEnd\nCleanup

D. Start\nCleanup

Solution

1. Step 1: Trace the try block execution

   The pipeline prints 'Start', then calls error('Fail here') which throws an exception, so 'End' is skipped.

2. Step 2: Understand catch and finally blocks

   The catch block runs and prints 'Caught error'. The finally block always runs and prints 'Cleanup'.

3. Final Answer:

   Start Caught error Cleanup -> Option A

4. Quick Check:

   Exception skips 'End', catch and finally run = C [OK]

Hint: Remember: error stops try, catch runs, finally always runs [OK]

Common Mistakes:

• Assuming code after error() runs
• Thinking finally runs before catch
• Ignoring that catch handles the error

4. Identify the error in this Jenkins pipeline snippet:

try {
  echo 'Running'
} catch {
  echo 'Error caught'
} finally {
  echo 'Done'
}

medium

A. try block must have a return statement

B. finally block cannot be used without catch

C. echo statements must be inside script block

D. Missing exception variable in catch block

Solution

1. Step 1: Check catch block syntax

   In Groovy/Jenkins, catch must declare an exception variable like catch (Exception e). Here it is missing.

2. Step 2: Verify other parts

   finally block is valid with catch, echo works outside script block in scripted pipeline, and try block does not require return.

3. Final Answer:

   Missing exception variable in catch block -> Option D

4. Quick Check:

   catch needs (Exception e) = A [OK]

Hint: Always declare exception variable in catch (e.g., catch(Exception e)) [OK]

Common Mistakes:

• Omitting exception variable in catch
• Thinking finally requires catch to be absent
• Assuming echo needs script block

5. You want to run a cleanup step in your Jenkins pipeline regardless of success or failure, but only if the try block ran without syntax errors. Which is the best way to structure your pipeline?

hard

A. Put cleanup code inside the finally block

B. Put cleanup code inside the catch block

C. Put cleanup code after the try-catch-finally block

D. Put cleanup code inside the try block after risky steps

Solution

1. Step 1: Understand when finally runs

   The finally block runs after try and catch, regardless of success or failure, but only if the pipeline syntax is valid and the try block started.

2. Step 2: Compare options for cleanup placement

   Cleanup in catch runs only on errors, after block runs only if no errors, and inside try risks skipping on errors. finally is best for guaranteed cleanup.

3. Final Answer:

   Put cleanup code inside the finally block -> Option A

4. Quick Check:

   Cleanup always runs in finally = B [OK]

Hint: Use finally for guaranteed cleanup after try-catch [OK]

Common Mistakes:

• Putting cleanup only in catch (misses success case)
• Placing cleanup after try-catch (may skip on errors)
• Putting cleanup inside try (skipped if error thrown early)