BitBucket仓库A主分支提交后，如何定时触发Jenkins流水线部署？

针对你的需求，这里有几个高效的实现方式，按推荐程度排序：

方案1：定时触发+变更检查（最推荐） #

取消BitBucket的即时触发，改用Jenkins的定时触发器固定在周末执行，同时在流水线中检查仓库A的master分支是否有新提交，有变更才执行后续流程：

1. 在Jenkins项目配置中添加定时触发器，比如设置为每周六、周日早8点执行：

   0 8 * * 6,0
   

2. 在Jenkinsfile中加入变更检查逻辑，确保只有仓库A有新提交时才继续执行：

   pipeline {
       agent any
       triggers {
           cron('0 8 * * 6,0') // 每周六、周日8点触发
       }
       stages {
           stage('检查仓库A是否有新提交') {
               steps {
                   script {
                       def hasNewCommits = true
                       def lastSuccessBuild = currentBuild.previousSuccessfulBuild
                       if (lastSuccessBuild) {
                           // 拉取仓库A最近的提交记录，对比上次成功构建时间
                           def lastBuildTime = lastSuccessBuild.time.format("yyyy-MM-dd HH:mm:ss")
                           def commitCount = sh(
                               script: """
                                   git clone --depth 50 https://bitbucket.org/your-team/repoA.git temp_repoA
                                   cd temp_repoA
                                   git log --since="${lastBuildTime}" --oneline | wc -l
                               """,
                               returnStdout: true
                           ).trim().toInteger()
                           hasNewCommits = commitCount > 0
                       }
                       if (!hasNewCommits) {
                           echo "仓库A自上次成功部署后无新提交，终止流水线"
                           currentBuild.result = 'ABORTED'
                           return
                       }
                   }
               }
           }
           stage('克隆仓库B') {
               steps {
                   git url: 'https://bitbucket.org/your-team/repoB.git', branch: 'master'
               }
           }
           stage('编译与部署') {
               steps {
                   // 这里放你的编译、部署命令
                   sh './build.sh'
                   sh './deploy.sh'
               }
           }
       }
   }
   

这个方案的优势是不占用工作日的Jenkins资源，周末自动检查变更并执行，完全匹配你的需求。

方案2：即时触发+阶段条件判断 #

保留BitBucket的webhook触发器，仓库A提交后立即触发构建，但通过条件判断跳过非周末的部署阶段：

1. 配置BitBucket的webhook，监听仓库A的master分支提交事件，触发Jenkins构建。
2. 在Jenkinsfile中给部署相关阶段添加周末判断条件：

   pipeline {
       agent any
       triggers {
           bitbucketPush() // 监听BitBucket提交触发
       }
       stages {
           stage('前置检查（工作日可执行）') {
               steps {
                   // 可以放代码静态检查、依赖扫描等不涉及部署的步骤
                   sh './lint.sh'
               }
           }
           stage('克隆仓库B') {
               when {
                   expression {
                       def today = new Date()
                       // 判断是否为周六(6)或周日(0)
                       return today.day in [0, 6]
                   }
               }
               steps {
                   git url: 'https://bitbucket.org/your-team/repoB.git', branch: 'master'
               }
           }
           stage('编译与部署') {
               when {
                   expression {
                       def today = new Date()
                       return today.day in [0, 6]
                   }
               }
               steps {
                   sh './build.sh'
                   sh './deploy.sh'
               }
           }
       }
       post {
           always {
               cleanWs()
           }
       }
   }
   

这个方案适合需要在工作日先完成部分前置验证的场景，缺点是工作日触发的构建会跳过部署阶段，需要团队注意构建状态。

方案3：延迟队列插件（不推荐长期延迟） #

如果需要提交后自动延迟到周末执行，可以使用Jenkins的Delay Queue Plugin，计算当前时间到下一个周末的时间差，延迟执行部署：

pipeline {
    agent any
    triggers {
        bitbucketPush()
    }
    stages {
        stage('延迟到周末执行') {
            steps {
                script {
                    def today = new Date()
                    def targetTime
                    if (today.day in [0, 6]) {
                        targetTime = today
                    } else {
                        // 计算到下周六早上8点的时间
                        def daysToSaturday = 6 - today.day
                        targetTime = today.plus(daysToSaturday)
                        targetTime.set(Calendar.HOUR_OF_DAY, 8)
                        targetTime.set(Calendar.MINUTE, 0)
                        targetTime.set(Calendar.SECOND, 0)
                    }
                    def delayMs = targetTime.time - today.time
                    if (delayMs > 0) {
                        echo "将延迟 ${delayMs/3600000} 小时执行部署"
                        sleep(time: delayMs, unit: 'MILLISECONDS')
                    }
                }
            }
        }
        // 后续克隆、编译、部署步骤同前
    }
}

注意：这个方案会在延迟期间占用Jenkins agent资源，不适合工作日提交后等待多天的场景，仅适合临近周末的提交。

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