Source code management setup in Jenkins - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Source Code Management (SCM) in Jenkins?

SCM in Jenkins is a system that helps Jenkins get the latest version of your code from a repository like Git or Subversion before building or testing it.

beginner

Name two popular SCM tools Jenkins can integrate with.

Git and Subversion (SVN) are two popular SCM tools Jenkins can connect to for fetching source code.

beginner

What is the purpose of the 'Repository URL' field in Jenkins SCM setup?

It tells Jenkins where to find your source code repository so it can download the code to build or test.

intermediate

How does Jenkins use credentials in SCM setup?

Jenkins uses credentials like usernames, passwords, or SSH keys to securely access private repositories during the build process.

beginner

What is a 'branch' in SCM and why might you specify it in Jenkins?

A branch is a separate line of development in your code. Specifying it in Jenkins tells it which version of the code to build.

Which SCM tool is most commonly used with Jenkins for modern projects?

A Git

B CVS

C Mercurial

D Perforce

Git is the most popular SCM tool integrated with Jenkins today.

What does Jenkins need to access a private Git repository?

A Repository URL only

B Docker image

C Build triggers

D Credentials like SSH keys or username/password

Jenkins requires credentials to securely access private repositories.

In Jenkins SCM setup, what does specifying a branch do?

A Defines the build environment

B Selects which code version to build

C Sets the build schedule

D Configures notifications

Specifying a branch tells Jenkins which line of code to use.

Which plugin is commonly used in Jenkins to connect with Git repositories?

A Docker plugin

B Subversion plugin

C Git plugin

D Maven plugin

The Git plugin enables Jenkins to work with Git repositories.

What is the first step to set up SCM in a Jenkins job?

A Add repository URL in Source Code Management section

B Configure build triggers

C Install Jenkins

D Write build scripts

You start by adding the repository URL in the SCM section of the job.

Explain how to set up source code management in a Jenkins job for a Git repository.

Think about the steps you take to connect Jenkins to your code.

Why is it important to use credentials when setting up SCM in Jenkins?

Consider security and access control.

Practice

1. What is the main purpose of setting up source code management (SCM) in Jenkins?

easy

A. To automatically fetch the latest code from a repository

B. To manually upload code files to Jenkins

C. To create user accounts for Jenkins

D. To monitor server hardware status

Solution

1. Step 1: Understand SCM role in Jenkins

   SCM connects Jenkins to your code repository to get the latest code automatically.

2. Step 2: Compare options

   Only To automatically fetch the latest code from a repository describes automatic fetching of code, which is the main purpose of SCM setup.

3. Final Answer:

   To automatically fetch the latest code from a repository -> Option A

4. Quick Check:

   SCM = automatic code fetch [OK]

Hint: SCM means Jenkins pulls code automatically [OK]

Common Mistakes:

• Thinking SCM uploads code manually
• Confusing SCM with user management
• Assuming SCM monitors hardware

2. Which Jenkins pipeline syntax correctly checks out code from a Git repository URL https://github.com/example/repo.git on branch main?

easy

A. git url: 'https://github.com/example/repo.git' branch: 'main'

B. checkout([$class: 'GitSCM', branches: [[name: 'main']], userRemoteConfigs: [[url: 'https://github.com/example/repo.git']]])

C. checkout scm: 'https://github.com/example/repo.git', branch: 'main'

D. gitCheckout('https://github.com/example/repo.git', 'main')

Solution

1. Step 1: Recall Jenkins pipeline checkout syntax

   The correct syntax uses checkout with a map specifying $class: 'GitSCM', branches, and userRemoteConfigs.

2. Step 2: Validate options

   checkout([$class: 'GitSCM', branches: [[name: 'main']], userRemoteConfigs: [[url: 'https://github.com/example/repo.git']]]) matches the correct syntax. Options B, C, and D are incorrect Jenkins pipeline syntax.

3. Final Answer:

   checkout([$class: 'GitSCM', branches: [[name: 'main']], userRemoteConfigs: [[url: 'https://github.com/example/repo.git']]]) -> Option B

4. Quick Check:

   Use checkout with GitSCM map [OK]

Hint: Use checkout with $class: 'GitSCM' for Git repos [OK]

Common Mistakes:

• Using incorrect method names like gitCheckout
• Missing $class: 'GitSCM' in checkout
• Wrong parameter names or structure

3. Given this Jenkins pipeline snippet, what will be the output if the repository URL is invalid?

pipeline {
  agent any
  stages {
    stage('Checkout') {
      steps {
        checkout([$class: 'GitSCM', branches: [[name: 'main']], userRemoteConfigs: [[url: 'https://invalid-url/repo.git']]])
      }
    }
  }
}

medium

A. The pipeline will retry checkout indefinitely

B. The pipeline will succeed but skip checkout

C. The pipeline will fail with a checkout error

D. The pipeline will ignore the invalid URL and continue

Solution

1. Step 1: Understand checkout behavior with invalid URL

   If the Git URL is invalid, Jenkins cannot fetch code and throws an error causing the pipeline to fail.

2. Step 2: Analyze options

   Only The pipeline will fail with a checkout error correctly states the pipeline fails with a checkout error. Others describe incorrect behaviors.

3. Final Answer:

   The pipeline will fail with a checkout error -> Option C

4. Quick Check:

   Invalid URL causes checkout failure [OK]

Hint: Invalid repo URL causes pipeline failure [OK]

Common Mistakes:

• Assuming pipeline skips checkout silently
• Thinking Jenkins retries forever
• Believing pipeline ignores errors

4. You wrote this Jenkins pipeline snippet to checkout code but it fails with a syntax error:

checkout([$class: 'GitSCM', branches: [name: 'main'], userRemoteConfigs: [[url: 'https://github.com/example/repo.git']]])

What is the error and how to fix it?

medium

A. Missing quotes around $class; fix to "$class: 'GitSCM'"

B. Wrong URL format; fix to '[e-mail]:example/repo.git'

C. Incorrect method name; fix to gitCheckout(...)

D. Missing double brackets around branches list; fix to branches: [[name: 'main']]

Solution

1. Step 1: Identify syntax error in branches parameter

   The branches parameter expects a list of maps, so it must be double bracketed: [[name: 'main']].

2. Step 2: Correct the branches syntax

   Change branches: [name: 'main'] to branches: [[name: 'main']] to fix the syntax error.

3. Final Answer:

   Missing double brackets around branches list; fix to branches: [[name: 'main']] -> Option D

4. Quick Check:

   Branches list needs double brackets [OK]

Hint: Branches must be a list of maps with double brackets [OK]

Common Mistakes:

• Using single brackets for branches list
• Changing URL format unnecessarily
• Misquoting $class key

5. You want Jenkins to checkout code from a Git repository and only build when the develop branch changes. Which setup correctly achieves this in a declarative pipeline?

hard

A. pipeline {
agent any
triggers {
pollSCM('H/5 * * * *')
}
stages {
stage('Checkout') {
steps {
git branch: 'develop', url: 'https://github.com/example/repo.git'
}
}
}
}

B. pipeline {
agent any
triggers {
pollSCM('H/5 * * * *')
}
stages {
stage('Checkout') {
steps {
checkout([$class: 'GitSCM', branches: [[name: 'main']], userRemoteConfigs: [[url: 'https://github.com/example/repo.git']]])
}
}
}
}

C. pipeline {
agent any
triggers {
cron('H/5 * * * *')
}
stages {
stage('Checkout') {
steps {
checkout([$class: 'GitSCM', branches: [[name: 'develop']], userRemoteConfigs: [[url: 'https://github.com/example/repo.git']]])
}
}
}
}

D. >erp/<}
}
}
}
)]]]'tig.oper/elpmaxe/moc.buhtig//:sptth' :lru[[ :sgifnoCetomeRresu ,]]'niam' :eman[[ :sehcnarb ,'MCStiG' :ssalc$[(tuokcehc
{ spets
{ )'tuokcehC'(egats
{ segats
}
)'* * * * 5/H'(MCSllop
{ sreggirt
yna tnega
{ enilepip>erp<

Solution

1. Step 1: Understand trigger and checkout requirements

   To build only when the develop branch changes, use pollSCM trigger and checkout the develop branch.

2. Step 2: Compare checkout methods

   pipeline {
     agent any
     triggers {
       pollSCM('H/5 * * * *')
     }
     stages {
       stage('Checkout') {
         steps {
           git branch: 'develop', url: 'https://github.com/example/repo.git'
         }
       }
     }
   }

   uses the simpler git step with branch and URL, which works well with pollSCM trigger to watch develop branch changes.

3. Step 3: Identify why others are incorrect

   Options A and C use checkout with GitSCM but C uses cron trigger (not SCM polling).

   pipeline {
     agent any
     triggers {
       pollSCM('H/5 * * * *')
     }
     stages {
       stage('Checkout') {
         steps {
           checkout([$class: 'GitSCM', branches: [[name: 'main']], userRemoteConfigs: [[url: 'https://github.com/example/repo.git']]])
         }
       }
     }
   }

   checks out main branch, not develop.

4. Final Answer:

   Use pollSCM trigger with git step for develop branch checkout -> Option A

5. Quick Check:

   pollSCM + git step + develop branch = correct setup [OK]

Hint: Use pollSCM trigger and git step with branch name [OK]

Common Mistakes:

• Using cron instead of pollSCM for SCM changes
• Checking out wrong branch
• Using complex checkout syntax unnecessarily