Multiple SCM repositories in Jenkins - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a Jenkins pipeline with two SCM repositories.

Jenkins

pipeline {
  agent any
  stages {
    stage('Checkout') {
      steps {
        [1] [
          $class: 'GitSCM',
          branches: [[name: '**']],
          userRemoteConfigs: [[url: 'https://github.com/example/repo1.git']]
        ]
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

Arun

Bbuild

Ccheckout

Ddeploy

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'build' or 'run' instead of 'checkout' will cause errors.

The checkout step is used to pull source code from SCM repositories in Jenkins pipelines.

2fill in blank

medium

Complete the code to add a second SCM repository checkout in the same stage.

Jenkins

pipeline {
  agent any
  stages {
    stage('Checkout') {
      steps {
        checkout scm
        [1] [
          $class: 'GitSCM',
          branches: [[name: '**']],
          userRemoteConfigs: [[url: 'https://github.com/example/repo2.git']]
        ]
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

Acheckout

Brun

Cbuild

Ddeploy

Attempts:

3 left

💡 Hint

Common Mistakes

Using other step names like 'build' will not work.

To checkout multiple repositories, use the checkout step multiple times with different SCM configurations.

3fill in blank

hard

Fix the error in the code to correctly checkout two repositories in parallel.

Jenkins

pipeline {
  agent any
  stages {
    stage('Checkout') {
      steps {
        parallel {
          repo1: {
            [1] [
              $class: 'GitSCM',
              branches: [[name: '**']],
              userRemoteConfigs: [[url: 'https://github.com/example/repo1.git']]
            ]
          },
          repo2: {
            [1] [
              $class: 'GitSCM',
              branches: [[name: '**']],
              userRemoteConfigs: [[url: 'https://github.com/example/repo2.git']]
            ]
          }
        }
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

Acheckout

Bbuild

Crun

Ddeploy

Attempts:

3 left

💡 Hint

Common Mistakes

Using different step names causes syntax errors.

In Jenkins pipelines, the checkout step is used to pull code. Using it inside parallel allows simultaneous checkouts.

4fill in blank

hard

Fill both blanks to define two SCM repositories with different branches.

Jenkins

pipeline {
  agent any
  stages {
    stage('Checkout') {
      steps {
        checkout scm: [
          $class: 'GitSCM',
          branches: [[name: '[1]']],
          userRemoteConfigs: [[url: 'https://github.com/example/repo1.git']]
        ]
        checkout scm: [
          $class: 'GitSCM',
          branches: [[name: '[2]']],
          userRemoteConfigs: [[url: 'https://github.com/example/repo2.git']]
        ]
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

Arefs/heads/main

Brefs/heads/develop

Crefs/heads/feature

Drefs/heads/release

Attempts:

3 left

💡 Hint

Common Mistakes

Using branch names without 'refs/heads/' prefix causes errors.

The branches field specifies which branch to checkout. Common branches are main and develop.

5fill in blank

hard

Fill all three blanks to create a map of repository names to their URLs and branches.

Jenkins

def repos = [
  '[1]': [url: 'https://github.com/example/repo1.git', branch: '[2]'],
  '[3]': [url: 'https://github.com/example/repo2.git', branch: 'refs/heads/develop']
]

Drag options to blanks, or click blank then click option'

Arepo1

Brefs/heads/main

Crepo2

Drefs/heads/feature

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up repo names or missing the branch prefix.

This map links repository names to their URLs and branches. The first repo is 'repo1' on 'main' branch, the second is 'repo2'.

Practice

1.

What is the main benefit of using multiple SCM repositories in a Jenkins job?

easy

A. It allows Jenkins to fetch code from several repositories in one build.

B. It speeds up the Jenkins server performance automatically.

C. It merges all repositories into a single repository permanently.

D. It restricts Jenkins to use only one branch per build.

Solution

1. Step 1: Understand Jenkins SCM usage

   Jenkins uses SCM to get source code for building projects.

2. Step 2: Identify multiple SCM benefit

   Multiple SCM lets Jenkins pull from many repositories in one job, useful for projects with dependencies.

3. Final Answer:

   It allows Jenkins to fetch code from several repositories in one build. -> Option A

4. Quick Check:

   Multiple SCM = fetch multiple repos [OK]

Hint: Multiple SCM means multiple code sources in one job [OK]

Common Mistakes:

• Thinking it merges repos permanently
• Assuming it improves server speed
• Believing it limits branches

2.

Which Jenkins pipeline syntax correctly defines two SCM repositories using checkout steps?

<pre>1) checkout([$class: 'GitSCM', userRemoteConfigs: [[url: 'https://repo1.git']]]) checkout([$class: 'GitSCM', userRemoteConfigs: [[url: 'https://repo2.git']]]) 2) checkout([$class: 'GitSCM', userRemoteConfigs: [[url: 'https://repo1.git', url: 'https://repo2.git']]]) 3) checkout([$class: 'GitSCM', url: 'https://repo1.git']) checkout([$class: 'GitSCM', url: 'https://repo2.git']) 4) checkout([$class: 'GitSCM', userRemoteConfigs: ['https://repo1.git', 'https://repo2.git']])

easy

A. Option 1

B. Option 2

C. Option 3

D. Option 4

Solution

1. Step 1: Check syntax for multiple SCM in Jenkins pipeline

   Each checkout step handles one SCM repo; multiple repos require multiple checkout calls.

2. Step 2: Analyze options

   Option 1 uses two separate checkout calls with correct userRemoteConfigs. Option 2 tries to combine repos in one config incorrectly. Option 3 uses wrong key url directly. Option 4 uses wrong list format.

3. Final Answer:

   Option 1 -> Option A

4. Quick Check:

   Separate checkout per repo = Option 1 [OK]

Hint: Use separate checkout steps for each repo [OK]

Common Mistakes:

• Combining multiple URLs in one userRemoteConfigs entry
• Using 'url' key instead of userRemoteConfigs
• Passing URLs as plain list without map

3.

Given this Jenkins pipeline snippet, what will be the result?

stage('Checkout') {
  steps {
    checkout([$class: 'GitSCM', userRemoteConfigs: [[url: 'https://repo1.git']]])
    checkout([$class: 'GitSCM', userRemoteConfigs: [[url: 'https://repo2.git']]])
  }
}

Choose the correct statement about the workspace after this stage runs.

medium

A. The workspace contains code from both repo1 and repo2 in separate folders.

B. The workspace contains only repo2 code, repo1 is overwritten.

C. The workspace contains merged files from repo1 and repo2 in the root folder.

D. The build will fail due to multiple checkout commands.

Solution

1. Step 1: Understand default checkout behavior

   By default, Jenkins checks out each repo into the same workspace folder, overwriting previous content.

2. Step 2: Analyze the effect of two checkout calls

   The second checkout replaces the first repo's files because both use the root workspace folder without specifying subdirectories.

3. Final Answer:

   The workspace contains only repo2 code, repo1 is overwritten. -> Option B

4. Quick Check:

   Multiple checkout without directories overwrites workspace [OK]

Hint: Without directories, last checkout overwrites workspace [OK]

Common Mistakes:

• Assuming repos merge automatically
• Thinking Jenkins creates subfolders by default
• Believing multiple checkouts cause build failure

4.

In a Jenkins job configured with multiple SCM repositories, the build fails with this error: hudson.plugins.git.GitException: Command "git clone" failed. What is the most likely cause?

medium

A. The workspace directory is not cleaned before checkout.

B. The Jenkins server has no internet connection.

C. The Jenkinsfile syntax is invalid.

D. The userRemoteConfigs list is empty or missing URLs.

Solution

1. Step 1: Understand the error context

   Git clone failure usually means the repository URL is invalid or missing.

2. Step 2: Check multiple SCM config

   If userRemoteConfigs is empty or missing URLs, Jenkins cannot clone repos, causing this error.

3. Final Answer:

   The userRemoteConfigs list is empty or missing URLs. -> Option D

4. Quick Check:

   Missing repo URLs cause git clone failure [OK]

Hint: Check repo URLs in userRemoteConfigs first [OK]

Common Mistakes:

• Blaming workspace cleanup for git clone errors
• Assuming Jenkinsfile syntax causes git clone failure
• Ignoring network issues as cause

5.

You want to configure a Jenkins pipeline to checkout two Git repositories into separate folders repo1 and repo2 inside the workspace. Which pipeline snippet correctly achieves this?

checkout([$class: 'GitSCM', userRemoteConfigs: [[url: 'https://repo1.git']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'repo1']]])
checkout([$class: 'GitSCM', userRemoteConfigs: [[url: 'https://repo2.git']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'repo2']]])

hard

A. This snippet merges both repos into the root workspace folder.

B. This snippet will fail because RelativeTargetDirectory is not supported.

C. This snippet correctly checks out both repos into separate folders.

D. This snippet only checks out the first repo; second is ignored.

Solution

1. Step 1: Understand RelativeTargetDirectory extension

   This extension tells Jenkins to checkout the repo into a specified subfolder inside the workspace.

2. Step 2: Analyze the snippet

   Each checkout uses RelativeTargetDirectory with different folder names, so repos go into separate folders without overwriting.

3. Final Answer:

   This snippet correctly checks out both repos into separate folders. -> Option C

4. Quick Check:

   RelativeTargetDirectory separates repos in workspace [OK]

Hint: Use RelativeTargetDirectory to separate repos in workspace [OK]

Common Mistakes:

• Not using RelativeTargetDirectory causes overwriting
• Assuming Jenkins merges repos automatically
• Believing second checkout is ignored