如何用Jenkins Pipeline检出Pull-Request？多仓库集成流水线构建需求

Got it, let's walk through building this Jenkins Pipeline exactly as you described. Since you're triggering it manually (not via a PR webhook) and can't rely on checkout scm, we'll handle API calls, repo cloning, and PR checkout manually. Here's a step-by-step implementation:

First, add a string parameter to your Pipeline so users can input the source branch name. Let's call it SOURCE_BRANCH — this will be the input that drives the rest of the workflow.

List all the GitHub repositories you want to scan for matching PRs. For example:

def repos = [
    "your-org/repo-1",
    "your-org/repo-2",
    "your-org/repo-3"
]

We’ll use GitHub’s REST API to find all PRs in each repo that originate from your specified SOURCE_BRANCH. You’ll need a GitHub personal access token (PAT) with the repo scope, stored as a secret credential in Jenkins (name it GITHUB_TOKEN for this example).

Here’s a helper function to call the API and parse results:

def getMatchingPRs(String repo) {
    def orgName = repo.split('/')[0]
    def apiUrl = "https://api.github.com/repos/${repo}/pulls?state=open&head=${orgName}:${params.SOURCE_BRANCH}"
    
    def response = httpRequest(
        url: apiUrl,
        authentication: 'GITHUB_TOKEN',
        contentType: 'APPLICATION_JSON',
        consoleLogResponseBody: false
    )
    
    return new groovy.json.JsonSlurper().parseText(response.content)
}

This fetches all open PRs where the head branch matches your input SOURCE_BRANCH. Adjust the state parameter to closed or all if you need to include merged/closed PRs too.

For each repo with matching PRs, perform a shallow clone and checkout the PR directly. Since checkout scm isn’t applicable here, we’ll use raw git commands:

def checkoutPR(String repo, int prNumber) {
    def repoUrl = "https://github.com/${repo}.git"
    def prBranchRef = "refs/pull/${prNumber}/head"
    def targetDir = "${repo}-pr-${prNumber}"
    
    sh """
        # Clean up any existing clones to avoid conflicts
        rm -rf ${targetDir}
        # Shallow clone the PR's head branch
        git clone --depth 1 --branch ${prBranchRef} ${repoUrl} ${targetDir}
        # Verify the checkout
        cd ${targetDir}
        echo "Successfully checked out PR #${prNumber} from ${repo}"
        git log --oneline -1
    """
}

The --depth 1 flag ensures a fast, shallow clone. We use the refs/pull/<PR_NUMBER>/head reference to directly target the PR’s latest commit.

Putting it all together, here’s the complete, runnable Pipeline:

pipeline {
    agent any
    parameters {
        string(
            name: 'SOURCE_BRANCH',
            description: 'Enter the source branch name to find PRs from',
            defaultValue: 'develop'
        )
    }
    environment {
        GITHUB_TOKEN = credentials('GITHUB_TOKEN')
    }
    stages {
        stage('Scan Repos for Matching PRs') {
            steps {
                script {
                    def repos = [
                        "your-org/repo-1",
                        "your-org/repo-2"
                    ]
                    
                    repos.each { repo ->
                        echo "🔍 Checking repository: ${repo}"
                        def matchingPRs = getMatchingPRs(repo)
                        
                        if (matchingPRs.isEmpty()) {
                            echo "ℹ️ No PRs found from branch ${params.SOURCE_BRANCH} in ${repo}"
                            return
                        }
                        
                        matchingPRs.each { pr ->
                            echo "✅ Found PR #${pr.number}: ${pr.title}"
                            checkoutPR(repo, pr.number)
                        }
                    }
                }
            }
        }
    }
}

// Helper function to fetch matching PRs from GitHub API
def getMatchingPRs(String repo) {
    def orgName = repo.split('/')[0]
    def apiUrl = "https://api.github.com/repos/${repo}/pulls?state=open&head=${orgName}:${params.SOURCE_BRANCH}"
    
    def response = httpRequest(
        url: apiUrl,
        authentication: 'GITHUB_TOKEN',
        contentType: 'APPLICATION_JSON',
        consoleLogResponseBody: false
    )
    
    return new groovy.json.JsonSlurper().parseText(response.content)
}

// Helper function to shallow clone and checkout a PR
def checkoutPR(String repo, int prNumber) {
    def repoUrl = "https://github.com/${repo}.git"
    def prBranchRef = "refs/pull/${prNumber}/head"
    def targetDir = "${repo}-pr-${prNumber}"
    
    sh """
        rm -rf ${targetDir}
        git clone --depth 1 --branch ${prBranchRef} ${repoUrl} ${targetDir}
        cd ${targetDir}
        echo "📌 Checked out PR #${prNumber} (latest commit):"
        git log --oneline -1
    """
}

• Authentication: Ensure your GitHub PAT has the repo scope (for private repos) or public_repo scope (for public repos). Store it as a "Secret text" credential in Jenkins.
• API Rate Limits: Authenticated requests get 5000 API calls per hour (vs. 60 for unauthenticated), so using a PAT avoids hitting rate limits quickly.
• Shallow Clone Limitations: --depth 1 only fetches the latest commit. If you need access to earlier history (e.g., for running tests), increase the depth or remove the flag.
• Error Handling: Add try/catch blocks around API calls and git commands if you want the Pipeline to continue even if one repo fails.
• PR State: Modify the state parameter in the API URL to closed or all if you need to include merged/closed PRs.

内容的提问来源于stack exchange，提问作者Thomas Hirsch