Source code management setup in Jenkins - Step-by-Step Execution

Process Flow - Source code management setup

Start Jenkins Job Configuration

↓

Select Source Code Management (SCM)

↓

Choose SCM Type (e.g., Git)

↓

Enter Repository URL

↓

Add Credentials if needed

↓

Specify Branch to Build

↓

Save Configuration

↓

Trigger Build -> Jenkins clones repo

↓

Build uses latest code from SCM

↓

End

This flow shows the step-by-step setup of source code management in Jenkins, from job configuration to using the code in a build.

Execution Sample

Jenkins

pipeline {
  agent any
  stages {
    stage('Checkout') {
      steps {
        git url: 'https://github.com/example/repo.git', branch: 'main'
      }
    }
  }
}

This Jenkins pipeline code checks out the 'main' branch from a GitHub repository.

Process Table

Step	Action	Input/Config	Result/Output
1	Start Jenkins job configuration	N/A	Job configuration page opens
2	Select Source Code Management	Git	Git SCM selected
3	Enter repository URL	https://github.com/example/repo.git	Repository URL saved
4	Add credentials	None (public repo)	No credentials needed
5	Specify branch	main	Branch set to 'main'
6	Save configuration	N/A	Configuration saved
7	Trigger build	N/A	Build starts, Jenkins clones repo
8	Checkout code	git clone https://github.com/example/repo.git -b main	Code checked out to workspace
9	Build uses latest code	N/A	Build runs with latest source code
10	End	N/A	Build completes successfully

💡 Build completes after checking out the specified branch from the repository.

Status Tracker

Variable	Start	After Step 3	After Step 5	After Step 8	Final
SCM Type	None	Git	Git	Git	Git
Repository URL	None	https://github.com/example/repo.git	https://github.com/example/repo.git	https://github.com/example/repo.git	https://github.com/example/repo.git
Branch	None	None	main	main	main
Credentials	None	None	None	None	None
Workspace Code	Empty	Empty	Empty	Code from main branch	Code from main branch

Key Moments - 3 Insights

Why do we need to specify the branch in the SCM setup?

Specifying the branch tells Jenkins which version of the code to use. As shown in execution_table step 5, setting branch to 'main' ensures Jenkins checks out the correct code version.

What happens if credentials are missing for a private repository?

Without credentials, Jenkins cannot access private repos. In the execution_table, step 4 shows no credentials needed because the repo is public. For private repos, credentials must be added to avoid checkout failure.

How does Jenkins use the SCM configuration during the build?

At build time (step 7-9), Jenkins uses the SCM info to clone the repo and checkout the specified branch into the workspace, so the build uses the latest code.

Visual Quiz - 3 Questions

Look at the execution_table, what is the repository URL set at step 3?

A https://github.com/example/repo.git

B https://github.com/unknown/repo.git

C [e-mail]:example/repo.git

D No URL set

💡 Hint

Check the 'Input/Config' column at step 3 in the execution_table.

At which step does Jenkins actually clone the repository?

A Step 5

B Step 8

C Step 7

D Step 10

💡 Hint

Look for the step mentioning 'git clone' in the 'Result/Output' column.

If the branch was changed to 'develop' at step 5, what would change in the variable_tracker?

A SCM Type would change

B Repository URL would change

C Branch value after step 5 would be 'develop'

D Credentials would be added

💡 Hint

Check the 'Branch' row in variable_tracker after step 5.

Concept Snapshot

Jenkins Source Code Management Setup:
- Select SCM type (e.g., Git) in job config
- Enter repository URL
- Add credentials if repo is private
- Specify branch to build
- Save and trigger build
- Jenkins clones repo and checks out branch
- Build uses latest code from SCM

Full Transcript

This visual execution shows how to set up source code management in Jenkins. First, you open the job configuration and select the SCM type, such as Git. Then, you enter the repository URL and add credentials if needed. Next, specify the branch to build, like 'main'. After saving, when you trigger the build, Jenkins clones the repository and checks out the specified branch into the workspace. The build then runs using the latest source code. Variables like SCM type, repository URL, branch, and workspace code change step-by-step as shown. Key points include why specifying the branch matters, the need for credentials for private repos, and how Jenkins uses this setup during the build.

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