Failing fast principle in Jenkins - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Jenkins Pipeline: What happens when a stage fails?

Consider this Jenkins pipeline snippet:

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'exit 1'
      }
    }
    stage('Test') {
      steps {
        echo 'Running tests'
      }
    }
  }
}

What will Jenkins do after the 'Build' stage fails?

Jenkins

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'exit 1'
      }
    }
    stage('Test') {
      steps {
        echo 'Running tests'
      }
    }
  }
}

A Continue to the 'Test' stage despite the failure in 'Build'.

B Skip the 'Build' stage and run the 'Test' stage.

C Retry the 'Build' stage automatically before moving on.

D Stop the pipeline immediately and mark it as failed; the 'Test' stage will not run.

💡 Hint

Think about the default behavior of Jenkins pipelines when a shell command returns a non-zero exit code.

By default, Jenkins stops the pipeline immediately when a stage fails (non-zero exit code). This is the 'fail fast' principle to avoid wasting time on subsequent steps.

🧠 Conceptual

intermediate

Understanding the 'Failing Fast' Principle in Jenkins

Which statement best describes the 'Failing Fast' principle in Jenkins pipelines?

A The pipeline retries failed stages multiple times before stopping.

B The pipeline continues running all stages regardless of errors to collect maximum data.

C The pipeline stops execution immediately when an error occurs to save time and resources.

D The pipeline ignores errors and marks the build as successful.

💡 Hint

Consider why stopping early might be beneficial in automated builds.

'Failing Fast' means stopping the process as soon as a failure is detected to avoid wasting time and resources on subsequent steps that depend on the success of earlier ones.

🔀 Workflow

advanced

Configuring Jenkins to Fail Fast with Parallel Stages

You have a Jenkins pipeline with parallel stages. How can you configure it so that if any parallel stage fails, the entire pipeline stops immediately?

A Set <code>continueOnError true</code> in each parallel stage.

B Use the <code>failFast true</code> option inside the <code>parallel</code> block.

C Wrap each parallel stage in a <code>try-catch</code> block and ignore errors.

D Use <code>timeout</code> on each stage to stop after a fixed time.

💡 Hint

Look for a built-in option that controls failure behavior in parallel execution.

Jenkins supports a failFast true option inside the parallel block to stop all parallel branches as soon as one fails.

❓ Troubleshoot

advanced

Why does Jenkins continue after a failing shell command?

In a Jenkins pipeline, the shell command sh 'exit 1' is used, but the pipeline continues to the next stage instead of failing immediately. What is the most likely cause?

A The shell step is wrapped with <code>returnStatus: true</code>, so it returns the exit code instead of failing.

B The Jenkins agent is offline, so the command is skipped.

C The pipeline is configured with <code>failFast true</code>.

D The shell command syntax is incorrect, so it never runs.

💡 Hint

Check how Jenkins handles shell command exit codes when returnStatus is used.

Using returnStatus: true makes the shell step return the exit code as a number instead of failing the build, so the pipeline continues.

✅ Best Practice

expert

Implementing Fail Fast in a Complex Jenkins Pipeline

You have a Jenkins pipeline with multiple sequential and parallel stages. You want to ensure the pipeline fails fast on any error but also perform cleanup steps regardless of failure. Which Jenkins pipeline structure best achieves this?

A Use <code>try { ... } catch { ... } finally { cleanup }</code> blocks around stages, with <code>failFast true</code> in parallel blocks.

B Run all stages without error handling and add cleanup only at the end.

C Use <code>catchError</code> to ignore errors and run cleanup only if all stages succeed.

D Disable fail fast and rely on manual intervention to stop the pipeline.

💡 Hint

Think about combining fail fast behavior with guaranteed cleanup.

Using try-catch-finally allows the pipeline to fail fast on errors but still run cleanup steps in the finally block. The failFast true option stops parallel stages immediately on failure.

Practice

1. What does the failing fast principle mean in Jenkins pipelines?

easy

A. Run all steps twice to check for errors

B. Stop the pipeline immediately when an error occurs

C. Ignore errors and continue running all steps

D. Delay error handling until the end of the pipeline

Solution

1. Step 1: Understand the failing fast principle

   The principle means to stop work quickly when an error happens to save time and resources.

2. Step 2: Apply to Jenkins pipelines

   In Jenkins, this means the pipeline should stop immediately on error instead of continuing.

3. Final Answer:

   Stop the pipeline immediately when an error occurs -> Option B

4. Quick Check:

   Fail fast = stop immediately on error [OK]

Hint: Fail fast means stop immediately on error [OK]

Common Mistakes:

• Thinking pipeline should continue despite errors
• Confusing fail fast with retrying steps
• Assuming errors are handled at the end

2. Which Jenkins pipeline syntax correctly fails fast when a condition is not met?

easy

A. if (!condition) { echo('Fail fast') }

B. if (!condition) { sleep(10) }

C. if (!condition) { retry(3) }

D. if (!condition) { error('Fail fast') }

Solution

1. Step 1: Identify the Jenkins command to fail fast

   The error() step immediately stops the pipeline with a failure.

2. Step 2: Check the condition usage

   If the condition is false, calling error() triggers fail fast behavior.

3. Final Answer:

   if (!condition) { error('Fail fast') } -> Option D

4. Quick Check:

   Use error() to fail fast [OK]

Hint: Use error() to stop pipeline immediately [OK]

Common Mistakes:

• Using echo() which only prints message
• Using retry() which retries steps instead of failing
• Using sleep() which delays but does not fail

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

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        script {
          if (false) {
            error('Fail fast triggered')
          }
          echo('Step completed')
        }
      }
    }
  }
}

medium

A. Pipeline prints 'Step completed' and succeeds

B. Pipeline fails with message 'Fail fast triggered'

C. Pipeline hangs indefinitely

D. Pipeline skips 'Step completed' but succeeds

Solution

1. Step 1: Analyze the condition in the script block

   The condition is false, so error() is not called.

2. Step 2: Check what happens next

   The pipeline executes echo('Step completed') and continues successfully.

3. Final Answer:

   Pipeline prints 'Step completed' and succeeds -> Option A

4. Quick Check:

   False condition skips error(), so pipeline succeeds [OK]

Hint: False condition means error() not called, pipeline continues [OK]

Common Mistakes:

• Assuming error() runs even if condition is false
• Thinking pipeline fails without error() call
• Confusing echo() with error()

4. Identify the error in this Jenkins pipeline snippet that tries to fail fast:

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        script {
          if (buildStatus == 'FAILURE')
            error('Build failed')
        }
      }
    }
  }
}

medium

A. buildStatus variable is undefined

B. Incorrect use of error() function

C. Missing braces {} around if block

D. Pipeline syntax requires 'steps' outside 'script'

Solution

1. Step 1: Check variable definitions

   The buildStatus variable is not defined in the pipeline context.

2. Step 2: Verify standard Jenkins variables

   In Jenkins, use currentBuild.result or define buildStatus from previous steps to check status.

3. Final Answer:

   buildStatus variable is undefined -> Option A

4. Quick Check:

   Undefined variables cause runtime errors [OK]

Hint: Check for undefined variables in scripts [OK]

Common Mistakes:

• Assuming error() usage is wrong
• Ignoring undefined variables without context
• Misplacing steps and script blocks

5. You want your Jenkins pipeline to fail fast if any test stage fails, but continue running other stages if tests pass. Which approach best implements this?

hard

A. Use sleep() to delay failure until all tests complete

B. Use try-catch around test stages and call error() in catch

C. Use error() inside each test stage to stop pipeline on failure

D. Use catchError to mark test failures but continue pipeline

Solution

1. Step 1: Understand fail fast requirement

   Fail fast means stop pipeline immediately on test failure, so no further stages run.

2. Step 2: Evaluate options

   Using error() inside each test stage stops pipeline immediately on failure, matching fail fast.

3. Final Answer:

   Use error() inside each test stage to stop pipeline on failure -> Option C

4. Quick Check:

   Fail fast = error() stops pipeline immediately [OK]

Hint: Use error() in failing stages to stop pipeline fast [OK]

Common Mistakes:

• Using catchError which allows pipeline to continue
• Using try-catch which delays failure
• Using sleep() which only delays, not fails