Jenkins: How to disable SonarQube analysis for a specific branch

Introduction

Jenkins, an open-source automation server, significantly enhances software development processes by facilitating continuous integration and continuous delivery (CI/CD). SonarQube, on the other hand, is a powerful tool for continuously inspecting code quality and security vulnerabilities. While SonarQube analysis is beneficial for maintaining code health, there may be scenarios where you want to disable analysis for specific branches, such as feature or development branches, to optimize resources or avoid noise in the analysis dashboard.

In this tutorial, we will dive into how to conditionally disable SonarQube analysis for a specific branch in Jenkins. We will start with basic approaches and gradually move to more advanced techniques, ensuring you have the necessary knowledge to tailor SonarQube analysis to your project’s needs.

Prerequisites

• A Jenkins server with admin privileges.
• SonarQube server integrated with Jenkins.
• Basic understanding of Jenkins pipelines (Groovy syntax).
• Familiarity with Git and branching strategies.

Basic Conditional Execution in Pipeline

First, let’s start with the most straightforward approach by adding a conditional statement in your Jenkinsfile to check the name of the current branch and decide whether to execute SonarQube analysis.

pipeline {
  agent any
  stages {
    stage('SonarQube Analysis') {
      when {
        not {
          branch 'develop'
        }
      }
      steps {
        echo 'Running SonarQube Analysis...'
        // SonarQube analysis steps go here
      }
    }
  }
}

This basic example uses the when directive combined with not and branch conditions to exclude the develop branch from SonarQube analysis. For any branch other than develop, the analysis steps inside the { ... } block will be executed.

Using Environment Variables and Script Block

For a more dynamic approach, you can utilize environment variables with a script block inside your Jenkinsfile. This method provides flexibility in handling various conditions for disabling SonarQube analysis.

pipeline {
  agent any
  environment {
    SKIP_SONAR = 'false'
  }
  stages {
    stage('Check Branch') {
      steps {
        script {
          if (env.BRANCH_NAME == 'develop') {
            env.SKIP_SONAR = 'true'
          }
        }
      }
    }
    stage('SonarQube Analysis') {
      when {
        expression { env.SKIP_SONAR != 'true' }
      }
      steps {
        echo 'Performing SonarQube Analysis...'
        // Detailed SonarQube analysis steps.
      }
    }
  }
}

In this example, you use the environment directive to declare a variable called SKIP_SONAR which is initially set to false. In the Check Branch stage, you assess the current branch name using env.BRANCH_NAME, and if it matches develop, you set SKIP_SONAR to true. Thus, SonarQube analysis is skipped if the SKIP_SONAR variable is true.

Advanced Branch Filtering with Groovy Script

For projects with more complex gating criteria or multiple branches that require exclusion from analysis, integrating a Groovy script in your Jenkins pipeline can provide the needed flexibility. Below is an example that combines Groovy scripting with Jenkins Pipeline.

def shouldAnalyzeBranch() {
  def skipBranches = ['develop', 'feature/*', 'hotfix/*']
  return !(env.BRANCH_NAME in skipBranches)
}

pipeline {
  agent any
  stages {
    stage('SonarQube Analysis') {
      when {
        expression { shouldAnalyzeBranch() }
      }
      steps {
        echo 'Proceeding with SonarQube Analysis...'
        // SonarQube analysis script.
      }
    }
  }
}

This approach uses a Groovy function shouldAnalyzeBranch that returns false if the current branch matches any branch pattern defined in the skipBranches list. The when directive’s expression clause then uses the function’s return value to decide whether to proceed with the analysis.

Conclusion

Disabling SonarQube analysis for specific branches in Jenkins requires a combination of Jenkins Pipeline syntax and strategic use of Groovy scripting. Whether you need to exclude a single branch or implement more complex exclusionary logic, Jenkins provides the tools to tailor SonarQube analysis to your project’s needs, ensuring efficient resource utilization and focused analysis results.