Jenkins多分支流水线：如何强制触发构建或基于master更新触发？

Alright, let's break down how to solve both of your Jenkins pipeline issues—forcing runs even when no branch changes are detected, and triggering other branches automatically when master gets updated. Here's what you can do:

If you need to run the pipeline regardless of whether the branch itself has code changes, try these practical approaches:

• Manually trigger a single branch: Navigate directly to the pipeline page for your target branch (e.g., http://your-jenkins-instance/job/your-multibranch-project/job/feature-x/), then click the Build Now button on the left. Jenkins will ignore the "no changes detected" check and start the build immediately.

• Trigger via Jenkins API for automation: For scripted or batch triggers, use the Jenkins REST API with curl. Example command (replace placeholders with your details):

  curl -X POST \
    --user "your-jenkins-username:your-api-token" \
    http://your-jenkins-url/job/your-multibranch-pipeline/job/target-branch/build
  

  You can generate an API token from your Jenkins user settings to authenticate these requests.

• Add a parameterized build toggle: Modify your Jenkinsfile to include a boolean parameter that lets you force runs when needed. Here's a snippet:

  pipeline {
    agent any
    parameters {
      booleanParam(
        name: 'FORCE_BUILD',
        defaultValue: false,
        description: 'Check this to run the pipeline even if no branch changes are detected'
      )
    }
    stages {
      stage('Validate Trigger') {
        steps {
          script {
            if (params.FORCE_BUILD) {
              echo "Starting forced pipeline execution..."
            }
          }
        }
      }
      // Your existing merge, push, and other stages go here
    }
  }
  

  When manually starting a build, check the FORCE_BUILD box to bypass the "no changes" check.

To automatically run merge pipelines for all non-master branches whenever master gets new commits, use one of these reliable solutions:

Option 1: Use Upstream Pipeline Triggers #

Since your multibranch pipeline includes the master branch, you can configure other branches to trigger when master's pipeline completes successfully. Add this to your non-master branches' Jenkinsfiles:

pipeline {
  agent any
  triggers {
    // Trigger current branch when master's pipeline succeeds
    upstream(
      upstreamProjects: 'your-multibranch-project-name/master',
      threshold: hudson.model.Result.SUCCESS
    )
  }
  stages {
    stage('Merge Master into Current Branch') {
      steps {
        script {
          // Example merge logic (adjust for your Git setup)
          sh 'git fetch origin master'
          sh 'git checkout $BRANCH_NAME'
          sh 'git merge origin/master --no-edit'
          sh 'git push origin $BRANCH_NAME'
        }
      }
    }
    // Add other stages as needed
  }
}

Replace your-multibranch-project-name with the name of your Jenkins multibranch job. Now, every time master has a new commit, its pipeline runs first—once it succeeds, all other branches' pipelines will trigger automatically to merge the latest master changes.

Option 2: Webhook + Master Update Check #

If you prefer not to rely on master's pipeline, configure a Git webhook to trigger branch scans, then add logic to your Jenkinsfile to check for master updates:

1. Set up Git Webhook: In your Git repository (GitHub/GitLab/etc.), add a webhook pointing to http://your-jenkins-url/github-webhook/ (for GitHub) or the appropriate Jenkins webhook endpoint. Set the trigger to fire only on pushes to the master branch.

2. Update Jenkinsfile to Check Master Changes: Even if Jenkins detects no changes to the current branch, manually check if master has new commits and run the merge if needed. Example snippet:

pipeline {
  agent any
  options {
    skipDefaultCheckout(true) // Bypass Jenkins' default checkout to control the process
  }
  stages {
    stage('Check for Master Updates') {
      steps {
        script {
          // Clone repo and fetch latest branches
          sh 'git clone https://your-git-repo-url.git .'
          sh 'git checkout $BRANCH_NAME'
          sh 'git fetch origin master'

          // Get the last commit where master was merged into current branch
          def lastMergeCommit = sh(
            script: 'git log --grep="Merge branch \'master\'" --oneline -n 1 | cut -d " " -f 1',
            returnStdout: true
          ).trim()

          // Get master's latest commit hash
          def masterLatestCommit = sh(
            script: 'git rev-parse origin/master',
            returnStdout: true
          ).trim()

          // Run merge if master has new changes or no prior merge exists
          if (!lastMergeCommit || lastMergeCommit != masterLatestCommit) {
            echo "Master has new changes—starting merge..."
            sh 'git merge origin/master --no-edit'
            sh 'git push origin $BRANCH_NAME'
          } else {
            echo "No new changes in master; skipping merge."
          }
        }
      }
    }
  }
}

Now, whenever master is pushed to, the webhook triggers Jenkins to scan your multibranch project. Each branch's pipeline will check if master has updates and run the merge logic if needed—even if the branch itself hasn't changed.

内容的提问来源于stack exchange，提问作者Jose Sanchez Robles