run-github-actions-workflow-generator.yml

name: Run GitHub Actions Workflow Generator

run-name: "Run GitHub Actions Workflow Generator${{ inputs.dry_run != false && ' - Dry Run' || '' }}"

on:
  workflow_dispatch:
    inputs:
      generator-version:
        description: 'Version of github-actions-workflow-generator to use (e.g. 0.0.5). Defaults to latest release.'
        required: false
        type: string
        default: ''
      sha:
        description: 'Commit SHA of this repo to copy release-train action files from. Defaults to the commit that triggered this workflow.'
        required: false
        type: string
        default: ''
      projects:
        description: 'Comma-separated list of Spring Cloud project names to run against (e.g. spring-cloud-build,spring-cloud-config). When empty, all projects in projects.json are processed.'
        required: false
        type: string
        default: ''
      dry_run:
        description: 'Dry run, if checked no changes will be committed or pushed, but you can see what would be updated'
        required: false
        type: boolean
        default: true
      token:
        description: 'GitHub token with write access to all target repos. Falls back to GH_ACTIONS_REPO_TOKEN.'
        required: false
        type: string
        default: ''

permissions:
  contents: read

jobs:
  setup:
    name: Build Matrix
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.build-matrix.outputs.matrix }}
      generator-version: ${{ steps.find-generator.outputs.version }}
      generator-url: ${{ steps.find-generator.outputs.url }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Find generator version and download URL
        id: find-generator
        env:
          GH_TOKEN: ${{ inputs.token || secrets.GH_ACTIONS_REPO_TOKEN }}
        run: |
          if [[ -n "${{ inputs.generator-version }}" ]]; then
            version="${{ inputs.generator-version }}"
            tag="v${version}"
          else
            response=$(gh api repos/spring-io/github-actions-workflow-generator/releases/latest)
            tag=$(echo "$response" | jq -r '.tag_name')
            version="${tag#v}"
          fi
          url="https://github.com/spring-io/github-actions-workflow-generator/releases/download/${tag}/github-actions-workflow-generator-${version}.jar"
          echo "version=${version}" >> "$GITHUB_OUTPUT"
          echo "url=${url}" >> "$GITHUB_OUTPUT"
          echo "Generator version : ${version}"
          echo "Download URL      : ${url}"

      - name: Build matrix
        id: build-matrix
        env:
          GH_TOKEN: ${{ inputs.token || secrets.GH_ACTIONS_REPO_TOKEN }}
          PROJECTS_FILTER: ${{ inputs.projects }}
        run: |
          node - << 'JSEOF'
          const { execFileSync } = require('child_process');
          const fs = require('fs');

          // Fetch projects.json from the main branch
          const b64 = execFileSync('gh', [
            'api', 'repos/spring-cloud/spring-cloud-github-actions/contents/config/projects.json',
            '-X', 'GET', '-f', 'ref=main', '--jq', '.content'
          ], { encoding: 'utf8' }).trim();
          const projects = JSON.parse(Buffer.from(b64, 'base64').toString('utf8'));

          const defaults = projects.defaults || {};

          const projectsFilterRaw = (process.env.PROJECTS_FILTER || '').trim();
          const projectsFilter = projectsFilterRaw
            ? new Set(projectsFilterRaw.split(',').map(p => p.trim()).filter(Boolean))
            : new Set();

          function getJdks(projectKey, typeKey, branch) {
            const typeCfg = (projects[projectKey] || {})[typeKey] || {};
            const jdkmap = typeCfg.jdkVersions || {};
            if (jdkmap[branch]) return jdkmap[branch];
            if (jdkmap['default']) return jdkmap['default'];
            const defJdkmap = (defaults[typeKey] || {}).jdkVersions || {};
            if (defJdkmap[branch]) return defJdkmap[branch];
            return defJdkmap['default'] || ['17', '21', '25'];
          }

          function primaryJdk(jdks) {
            return jdks.includes('8') ? '8' : '17';
          }

          const entries = [];
          const seen = new Set();

          function addEntry(repo, branch, typeKey, projectKey) {
            const key = `${repo}@${branch}`;
            if (seen.has(key)) return;
            seen.add(key);
            const jdks = getJdks(projectKey, typeKey, branch);
            entries.push({ repo, branch, primary_jdk: primaryJdk(jdks) });
          }

          // Build entries from projects.json
          for (const [projectKey, config] of Object.entries(projects)) {
            if (projectKey === 'defaults') continue;
            if (projectsFilter.size > 0 && !projectsFilter.has(projectKey)) continue;
            for (const typeKey of ['oss', 'commercial']) {
              const typeCfg = config[typeKey];
              if (!typeCfg) continue;
              const repo = typeKey === 'commercial'
                ? `spring-cloud/${projectKey}-commercial`
                : `spring-cloud/${projectKey}`;
              for (const branch of (typeCfg.branches || {}).scheduled || []) {
                // release/* and *-internal branches are rebased onto the .x branches and
                // pick up the regenerated workflows that way, so never generate them directly.
                if (branch.startsWith('release/') || branch.endsWith('-internal')) continue;
                addEntry(repo, branch, typeKey, projectKey);
              }
            }
          }

          const matrix = { include: entries };
          fs.appendFileSync(process.env.GITHUB_OUTPUT, `matrix=${JSON.stringify(matrix)}\n`);
          console.log(`Matrix built: ${entries.length} entries`);
          JSEOF

  generate:
    name: "Generate — ${{ matrix.repo }}@${{ matrix.branch }}"
    needs: setup
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix: ${{ fromJson(needs.setup.outputs.matrix) }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          ref:   ${{ inputs.sha || github.sha }}
          token: ${{ inputs.token || secrets.GH_ACTIONS_REPO_TOKEN }}

      - name: Generate workflows
        id: generate
        uses: ./.github/actions/generate-workflows-for-branch
        with:
          repo:              ${{ matrix.repo }}
          branch:            ${{ matrix.branch }}
          primary-jdk:       ${{ matrix.primary_jdk }}
          generator-version: ${{ needs.setup.outputs.generator-version }}
          dry-run:           ${{ inputs.dry_run }}
          token:             ${{ inputs.token || secrets.GH_ACTIONS_REPO_TOKEN }}

      - name: Record result
        if: always()
        id: record
        env:
          REPO: ${{ matrix.repo }}
          BRANCH: ${{ matrix.branch }}
          CHANGED: ${{ steps.generate.outputs.changed }}
          FILES: ${{ steps.generate.outputs.files }}
        run: |
          safe="${REPO//\//-}-${BRANCH//\//-}"
          safe="${safe//./-}"
          echo "safe-name=${safe}" >> "$GITHUB_OUTPUT"
          jq -n -c \
            --arg repo "$REPO" \
            --arg branch "$BRANCH" \
            --argjson changed "${CHANGED:-false}" \
            --argjson files "${FILES:-[]}" \
            '{repo: $repo, branch: $branch, changed: $changed, files: $files}' \
            > "result-${safe}.json"

      - name: Upload result
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: result-${{ steps.record.outputs.safe-name }}
          path: result-${{ steps.record.outputs.safe-name }}.json

  summary:
    name: Summary
    needs: generate
    runs-on: ubuntu-latest
    if: always()
    steps:
      - name: Download results
        uses: actions/download-artifact@v4
        with:
          pattern: result-*
          merge-multiple: true
          path: results

      - name: Write summary
        env:
          DRY_RUN: ${{ inputs.dry_run }}
        run: |
          node - << 'JSEOF'
          const fs = require('fs');
          const path = require('path');

          const files = fs.readdirSync('results').filter(f => f.endsWith('.json'));
          const results = files
            .map(f => JSON.parse(fs.readFileSync(path.join('results', f), 'utf8')))
            .sort((a, b) => {
              if (a.changed !== b.changed) return a.changed ? -1 : 1;
              return `${a.repo}@${a.branch}`.localeCompare(`${b.repo}@${b.branch}`);
            });

          const updated   = results.filter(r => r.changed);
          const unchanged = results.filter(r => !r.changed);

          const dryRun = (process.env.DRY_RUN || 'false') === 'true';

          let md = dryRun
            ? '## Workflow Generator Results (dry run — nothing pushed)\n\n'
            : '## Workflow Generator Results\n\n';

          if (updated.length > 0) {
            md += `### ${dryRun ? 'Would update' : 'Updated'} (${updated.length})\n\n`;
            const statusLabels = { A: 'added', M: 'modified', D: 'deleted', R: 'renamed', C: 'copied', T: 'type changed' };
            md += '| Repository | Branch | Files |\n|---|---|---|\n';
            for (const r of updated) {
              const fileList = (r.files || [])
                .map(f => `\`${f.path}\` (${statusLabels[f.status] || f.status})`)
                .join('<br>') || '_unknown_';
              md += `| \`${r.repo}\` | \`${r.branch}\` | ${fileList} |\n`;
            }
            md += '\n';
          } else {
            md += '> No changes were made.\n\n';
          }

          if (unchanged.length > 0) {
            md += `<details><summary>Unchanged (${unchanged.length})</summary>\n\n`;
            md += '| Repository | Branch |\n|---|---|\n';
            for (const r of unchanged) {
              md += `| \`${r.repo}\` | \`${r.branch}\` |\n`;
            }
            md += '\n</details>\n';
          }

          fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, md);
          console.log(md);
          JSEOF