Try-catch-finally in pipelines in Jenkins - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the output of this Jenkins pipeline snippet?

Consider this Jenkins scripted pipeline snippet using try-catch-finally:

node {
  try {
    echo 'Start build'
    error 'Build failed'
  } catch (Exception e) {
    echo "Caught error: ${e.message}"
  } finally {
    echo 'Cleanup actions'
  }
}

What will Jenkins print in the console?

Jenkins

node {
  try {
    echo 'Start build'
    error 'Build failed'
  } catch (Exception e) {
    echo "Caught error: ${e.message}"
  } finally {
    echo 'Cleanup actions'
  }
}

A

Start build
Caught error: Build failed
Cleanup actions

B

Start build
Build failed
Cleanup actions

C

Start build
Cleanup actions

D

Caught error: Build failed
Cleanup actions

💡 Hint

Remember that error throws an exception caught by catch, and finally always runs.

The error step throws an exception with message 'Build failed'. The catch block catches it and prints the message. The finally block always runs after try or catch, so 'Cleanup actions' is printed last.

🧠 Conceptual

intermediate

Which statement about try-catch-finally in Jenkins pipelines is true?

Choose the correct statement about the behavior of try-catch-finally blocks in Jenkins scripted pipelines.

A If an error occurs in the finally block, it is ignored by Jenkins.

B The finally block runs only if the try block succeeds without errors.

C The finally block runs only if the catch block is executed.

D The catch block can catch any exception thrown inside the try block.

💡 Hint

Think about how exceptions propagate and how finally always runs.

The catch block catches any exception thrown in the try block. The finally block always runs regardless of success or failure. Errors in finally are not ignored and will fail the build.

🔀 Workflow

advanced

Order the steps Jenkins executes in this try-catch-finally pipeline

Given this Jenkins scripted pipeline snippet, order the steps as Jenkins executes them:

node {
  try {
    echo 'Step 1'
    error 'Fail here'
    echo 'Step 2'
  } catch (Exception e) {
    echo 'Step 3'
  } finally {
    echo 'Step 4'
  }
  echo 'Step 5'
}

A 1,2,4,5,6,3

B 1,2,3,4,5,6

C 1,2,4,5,6

D 1,4,2,5,6,3

💡 Hint

Remember that after error is called, the rest of try block is skipped.

Jenkins runs 'Step 1', then hits error which throws an exception. 'Step 2' is skipped. The catch block runs printing 'Step 3'. Then finally runs printing 'Step 4'. After finally, the pipeline continues with 'Step 5'. But 'Step 5' is outside try-catch-finally and runs normally. However, since the error was caught, the pipeline continues. So the order is 1,2 (error), 4 (catch), 5 (finally), 6 (after finally). Option C (1,2,4,5,6) matches this correct order.

❓ Troubleshoot

advanced

Why does this Jenkins pipeline fail without printing 'Cleanup'?

Look at this Jenkins scripted pipeline snippet:

node {
  try {
    echo 'Build started'
    sh 'exit 1'
  } catch (Exception e) {
    echo 'Caught error'
  } finally {
    sh 'exit 1'
    echo 'Cleanup'
  }
}

Why does Jenkins fail without printing 'Cleanup'?

A The catch block does not catch shell command errors.

B The shell command in finally fails and stops execution before echo 'Cleanup'.

C The finally block runs before the catch block, so 'Cleanup' is skipped.

D Jenkins ignores errors in finally and continues, so this should print 'Cleanup'.

💡 Hint

Consider the order of commands in finally and what happens if a shell command fails.

The shell command sh 'exit 1' in finally causes the pipeline to fail immediately, so the next line echo 'Cleanup' is never reached. The catch block runs before finally, so it does catch the first error. But errors in finally are not caught and stop the pipeline.

✅ Best Practice

expert

Which Jenkins pipeline pattern ensures cleanup always runs even if cleanup commands fail?

In Jenkins scripted pipelines, you want to ensure cleanup commands always run, and even if a cleanup command fails, the pipeline continues to run all cleanup steps. Which pattern achieves this?

A Wrap each cleanup command inside its own try-catch inside the finally block.

B Put all cleanup commands inside finally block without try-catch inside finally.

C Put cleanup commands only in the catch block to run on errors.

D Use a separate post { always { ... } } block instead of try-catch-finally.

💡 Hint

Think about how to handle errors inside finally to avoid stopping cleanup early.

Errors inside finally stop the pipeline immediately, so to ensure all cleanup commands run, each should be wrapped in its own try-catch inside finally. This way, if one cleanup command fails, others still run.