## Jenkins Pipeline 功能总结

### 概述

这是一个 **Jenkins 批量自动化构建脚本**，用于定时或手动触发指定目录下的所有 Job，支持并发分批构建和串行构建两种模式。

---

### 触发方式

| 方式 | 说明 |
|------|------|
| 定时触发 | 每周六 UTC 17:00（北京时间周日凌晨 1:00）自动执行 |
| 手动触发 | 支持自定义参数手动触发 |

---

### 参数说明

| 参数 | 默认值 | 说明 |
|------|--------|------|
| `FOLDER_NAME` | `UAT` | 扫描的 Jenkins 目录 |
| `BRANCH` | `release` | 构建分支 |
| `BATCH_SIZE` | `5` | 并发批次大小 |
| `SPECIFIC_JOBS` | 空 | 手动指定 Job 列表（含参数覆盖） |

---

### 核心流程

```
开始
 ├─ 1. 扫描 MAVEN_API_MODE 标记
 │      检测上次构建参数，自动识别需要 JAR-Only 模式的 Job
 │
 ├─ 2. 生成任务列表
 │      ├─ 手动模式：解析 SPECIFIC_JOBS（支持 :: 分隔传参）
 │      └─ 自动模式：扫描目录，按 MODULE × Deploy_Env 笛卡尔积展开任务
 │
 ├─ 3. 任务分类
 │      ├─ 普通任务     → 并发分批执行
 │      └─ rapidtrade-* → 串行逐个执行（CPU 密集型保护）
 │
 ├─ 4. 第一阶段：普通任务并发构建
 │      按 BATCH_SIZE 分批，批内并发，批间顺序
 │      自动注入 BRANCH、MODULE、Deploy_Env、MAVEN_API_MODE 等参数
 │
 └─ 5. 第二阶段：rapidtrade-* 串行构建
        全部走默认参数，一次只跑 1 个，等待完成后再触发下一个
```

---

### 关键设计点

**自动参数展开**：Job 若同时有 `MODULE` 和 `Deploy_Env` 两个选项参数，会自动进行笛卡尔积展开，为每个组合各触发一次构建。

**MAVEN_API_MODE 自动识别**：不需要手动标记，脚本读取该 Job 上次构建的实际参数，自动继承 `MAVEN_API_MODE=true`。

**CPU 密集型保护**：`rapidtrade-` 开头的 Job 被识别为 CPU 密集型，强制串行执行，避免并发抢占资源。

**构建异常不中断**：每个 Job 用 `try/catch` + `propagate: false` 包裹，单个 Job 失败不影响后续任务继续执行。

pipeline {
  agent any

  triggers {
    cron('0 17 * * 6')
  }

  parameters {
    string(name: 'FOLDER_NAME', defaultValue: 'UAT', description: '目录名称')
    string(name: 'BRANCH', defaultValue: 'release', description: '构建分支（不需要加 origin/ 前缀）')
    string(name: 'BATCH_SIZE', defaultValue: '5', description: '每批并发数量')
    text(
      name: 'SPECIFIC_JOBS',
      defaultValue: '',
      description: '''手动指定任务（每行一个），不填则自动扫描目录下所有 Job：
UAT/job-name
UAT/job-name::MODULE=pigeon-gw
UAT/job-name::Deploy_Env=uat-shard-30
UAT/job-name::MODULE=pigeon-gw::Deploy_Env=uat-shard-30'''
    )
  }

  stages {
    stage('扫描并生成任务列表') {
      steps {
        script {
          def allTasks = []

          // ============================================================
          // 自动检测哪些 Job 需要 MAVEN_API_MODE = true (Build JAR Only)
          // 通过读取最近一次成功构建的实际参数值来判断
          // ============================================================
          def jarOnlyJobs = [] as Set
          def scanFolder = Jenkins.instance.getItemByFullName(params.FOLDER_NAME)
          if (scanFolder) {
            scanFolder.getItems().each { job ->
              def paramsDef = job.getProperty(hudson.model.ParametersDefinitionProperty.class)
              if (!paramsDef) return
              def mavenParam = paramsDef.getParameterDefinitions().find { it.name == 'MAVEN_API_MODE' }
              if (!mavenParam) return
              // 查最近一次构建的实际值
              def lastBuild = job.getLastBuild()
              if (lastBuild) {
                def action = lastBuild.getAction(hudson.model.ParametersAction.class)
                if (action) {
                  def p = action.getParameter('MAVEN_API_MODE')
                  if (p && p.getValue() == true) {
                    jarOnlyJobs << job.fullName
                  }
                }
              }
            }
          }
          if (jarOnlyJobs) {
            echo "===== 以下 Job 将自动勾选 MAVEN_API_MODE=true (Build JAR Only) ====="
            jarOnlyJobs.sort().each { echo "  ☑️ ${it}" }
          }

          if (params.SPECIFIC_JOBS?.trim()) {
            params.SPECIFIC_JOBS.trim().split('\n').each { line ->
              line = line.trim()
              if (!line) return
              def parts = line.split('::')
              def jobName = parts[0].trim()
              def extraParams = [:]
              for (int i = 1; i < parts.size(); i++) {
                def kv = parts[i].trim().split('=')
                if (kv.size() == 2) extraParams[kv[0].trim()] = kv[1].trim()
              }
              allTasks << [job: jobName, extra: extraParams]
            }
            echo "手动模式，共 ${allTasks.size()} 个任务"

          } else {
            echo "自动扫描 [${params.FOLDER_NAME}] 目录..."

            def folder = Jenkins.instance.getItemByFullName(params.FOLDER_NAME)
            if (!folder) error("目录 [${params.FOLDER_NAME}] 不存在")

            folder.getItems().each { job ->
              def paramsDef = job.getProperty(hudson.model.ParametersDefinitionProperty.class)
              if (!paramsDef) {
                allTasks << [job: job.fullName, extra: [:]]
                return
              }

              def moduleChoices    = []
              def deployEnvChoices = []

              paramsDef.getParameterDefinitions().each { p ->
                if (p.name == 'MODULE' && p instanceof hudson.model.ChoiceParameterDefinition) {
                  moduleChoices = p.choices.collect { it.trim() }.findAll { it }
                }
                if (p.name == 'Deploy_Env' && p instanceof hudson.model.ChoiceParameterDefinition) {
                  deployEnvChoices = p.choices.collect { it.trim() }.findAll { it }
                }
              }

              def buildTask = { extra -> [job: job.fullName, extra: extra] }

              if (moduleChoices && deployEnvChoices) {
                moduleChoices.each { m ->
                  deployEnvChoices.each { d ->
                    allTasks << buildTask([MODULE: m, Deploy_Env: d])
                  }
                }
              } else if (moduleChoices) {
                moduleChoices.each { m ->
                  allTasks << buildTask([MODULE: m])
                }
              } else if (deployEnvChoices) {
                deployEnvChoices.each { d ->
                  allTasks << buildTask([Deploy_Env: d])
                }
              } else {
                allTasks << buildTask([:])
              }
            }

            echo "自动扫描完成，共 ${allTasks.size()} 个任务"
          }

          if (allTasks.isEmpty()) error("没有找到任何任务")

          // ============================================================
          // 分离 rapidtrade- 开头的 CPU 密集型任务（串行执行）
          // 和普通任务（按批次并发执行）
          // ============================================================
          def rapidtradeTasks = []
          def normalTasks = []
          allTasks.each { task ->
            // 取 Job 名称最后一段（去掉目录前缀）做匹配
            def shortName = task.job.contains('/') ? task.job.split('/').last() : task.job
            if (shortName.startsWith('rapidtrade-')) {
              rapidtradeTasks << task
            } else {
              normalTasks << task
            }
          }

          if (rapidtradeTasks) {
            echo "===== rapidtrade-* 任务 (串行执行, CPU密集型) ====="
            rapidtradeTasks.each {
              def extraStr = it.extra.collect { k, v -> "$k=$v" }.join(', ')
              echo "  - ${it.job}" + (extraStr ? "  [$extraStr]" : "") + "  [默认参数]"
            }
          }

          echo "===== 普通任务列表 ====="
          normalTasks.each {
            def extraStr = it.extra.collect { k, v -> "$k=$v" }.join(', ')
            def jarTag = jarOnlyJobs.contains(it.job) ? '  [JAR_ONLY ☑️]' : ''
            echo "  - ${it.job}" + (extraStr ? "  [$extraStr]" : "") + "  [BRANCH=${params.BRANCH}]" + jarTag
          }

          // ============================================================
          // 第一阶段：普通任务按批次并发执行
          // ============================================================
          if (normalTasks) {
            def batchSize = params.BATCH_SIZE.toInteger()
            def batches = []
            for (int i = 0; i < normalTasks.size(); i += batchSize) {
              batches << new ArrayList(normalTasks.subList(i, Math.min(i + batchSize, normalTasks.size())))
            }

            echo "===== 普通任务共 ${normalTasks.size()} 个，分 ${batches.size()} 批，每批最多 ${batchSize} 个 ====="

            for (int b = 0; b < batches.size(); b++) {
              def batch = batches[b]
              echo "===== 第 ${b + 1} 批，共 ${batch.size()} 个任务 ====="

              def parallelJobs = [:]
              for (int j = 0; j < batch.size(); j++) {
                def task    = batch[j]
                def taskKey = task.extra ? "${task.job}[${task.extra.collect { k,v -> "$k=$v" }.join('_')}]" : task.job

                parallelJobs[taskKey] = {
                  def extraInfo = task.extra.collect { k, v -> "$k=$v" }.join(', ')
                  def isJarOnly = jarOnlyJobs.contains(task.job)
                  echo "触发构建: ${task.job}" + (extraInfo ? " [$extraInfo]" : "") + " (BRANCH=${params.BRANCH})" + (isJarOnly ? " [MAVEN_API_MODE=true]" : "")
                  try {
                    def buildParams = []
                    buildParams << string(name: 'BRANCH', value: params.BRANCH)
                    task.extra.each { k, v -> buildParams << string(name: k, value: v) }

                    // 自动为需要的 Job 勾选 MAVEN_API_MODE
                    if (isJarOnly) {
                      buildParams << booleanParam(name: 'MAVEN_API_MODE', value: true)
                    }

                    build job: task.job,
                          parameters: buildParams,
                          wait: true,
                          propagate: false
                    echo "✅ ${taskKey} 构建完成" + (isJarOnly ? " (JAR Only)" : "")
                  } catch (e) {
                    echo "❌ ${taskKey} 构建异常: ${e.message}"
                  }
                }
              }

              parallel parallelJobs
              echo "第 ${b + 1} 批完成，继续下一批..."
            }
          }

          // ============================================================
          // 第二阶段：rapidtrade-* 任务逐个串行执行（CPU密集型，一次只跑1个）
          // 所有参数走默认，直接触发构建
          // ============================================================
          if (rapidtradeTasks) {
            echo "===== 开始 rapidtrade-* 串行构建（共 ${rapidtradeTasks.size()} 个）====="
            for (int r = 0; r < rapidtradeTasks.size(); r++) {
              def task = rapidtradeTasks[r]
              def taskKey = task.extra ? "${task.job}[${task.extra.collect { k,v -> "$k=$v" }.join('_')}]" : task.job
              echo "串行构建 [${r + 1}/${rapidtradeTasks.size()}]: ${task.job} (默认参数)"
              try {
                // rapidtrade-* 走默认参数，不传 BRANCH 等自定义参数
                build job: task.job,
                      wait: true,
                      propagate: false
                echo "✅ ${taskKey} 构建完成 (串行)"
              } catch (e) {
                echo "❌ ${taskKey} 构建异常: ${e.message}"
              }
            }
          }

          echo "===== 全部构建完成 ====="
        }
      }
    }
  }
}