Automatically trigger the git-artifacts runs upon a completed tag-git run

This commit is part of Git for Windows' transition off of Azure
Pipelines onto GitHub workflows.

One thing that was changed during that transition is that the tasks were
split up into several workflow runs instead of having one ginormous `Git
Artifacts` Pipeline that does everything from tagging the Git version to
building the Pacman packages in matrix builds, to building the
installers/portable Gits/MinGits/etc in another set of matrix builds, to
generating the release notes as well as the announcement mail.

Now, the Git version is tagged in the `tag-git` workflow, and that
workflow also generates the release notes and announcement mail
template (the SHA-256s of the generated artifacts are part of both,
therefore the final version can only be constructed once those artifacts
are available).

Once the `tag-git` workflow has run successfully, the `git-artifacts`
workflow needs to be started multiple times, once per supported
architecture (currently x86_64 and i686, hopefully soon also aarch64).

This commit teaches GitForWindowsHelper to do that by reacting when a
`tag-git` run completed, triggering the `git-artifacts` runs.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>

Author: dscho

GitForWindowsHelper/cascading-runs.js

@@ -0,0 +1,117 @@
+module.exports = async (context, req) => {
+    const action = req.body.action
+    const checkRunOwner = req.body.repository.owner.login
+    const checkRunRepo = req.body.repository.name
+    const checkRun = req.body.check_run
+    const commitSHA = checkRun.head_sha
+    const name = checkRun.name
+    const conclusion = checkRun.conclusion
+    const text = checkRun.output.text
+
+    const getToken = (() => {
+        const tokens = {}
+
+        const get = async (owner, repo) => {
+            const getInstallationIdForRepo = require('./get-installation-id-for-repo')
+            const installationId = await getInstallationIdForRepo(context, owner, repo)
+            const getInstallationAccessToken = require('./get-installation-access-token')
+            return await getInstallationAccessToken(context, installationId)
+        }
+
+        return async (owner, repo) => tokens[[owner, repo]] || (tokens[[owner, repo]] = await get(owner, repo))
+    })()
+
+    if (action === 'completed') {
+        if (name === 'tag-git') {
+            if (checkRunOwner !== 'git-for-windows' || checkRunRepo !== 'git') {
+                throw new Error(`Refusing to handle cascading run in ${checkRunOwner}/${checkRunRepo}`)
+            }
+
+            if (conclusion !== 'success') {
+                throw new Error(`tag-git run ${checkRun.id} completed with ${conclusion}: ${checkRun.html_url}`)
+            }
+
+            const match = text.match(/For details, see \[this run\]\(https:\/\/github.com\/([^/]+)\/([^/]+)\/actions\/runs\/(\d+)\)/)
+            if (!match) throw new Error(`Unhandled 'text' attribute of tag-git run ${checkRun.id}: ${checkRun.url}`)
+            const owner = match[1]
+            const repo = match[2]
+            const workflowRunId = Number(match[3])
+            if (owner !== 'git-for-windows' || repo !== 'git-for-windows-automation') {
+                throw new Error(`Unexpected repository ${owner}/${repo} for tag-git run ${checkRun.id}: ${checkRun.url}`)
+            }
+
+            let res = ''
+
+            const architecturesToTrigger = []
+            const { listCheckRunsForCommit, queueCheckRun } = require('./check-runs')
+            for (const architecture of ['x86_64', 'i686']) {
+                const workflowName = `git-artifacts-${architecture}`
+                const runs = await listCheckRunsForCommit(
+                    context,
+                    await getToken(checkRunOwner, checkRunRepo),
+                    checkRunOwner,
+                    checkRunRepo,
+                    commitSHA,
+                    workflowName
+                )
+                const latest = runs
+                    .filter(run => run.output.summary.endsWith(`(tag-git run #${workflowRunId})`))
+                    .sort((a, b) => a.id - b.id)
+                    .pop()
+                if (latest && (latest.status !== 'completed' || latest.conclusion === 'success')) {
+                    // It either succeeded or is still running
+                    res = `${res}${workflowName} run already exists at ${latest.html_url}.\n`
+                } else {
+                    architecturesToTrigger.push(architecture)
+                }
+            }
+
+            if (architecturesToTrigger.length === 0) return `${res}No workflows need to be run!\n`
+
+            const gitVersionMatch = checkRun.output.summary.match(/^Tag Git (\S+) @([0-9a-f]+)$/)
+            if (!gitVersionMatch) {
+                throw new Error(`Could not parse Git version from summary '${checkRun.output.summary}' of tag-git run ${checkRun.id}: ${checkRun.url}`)
+            }
+            if (commitSHA !== gitVersionMatch[2]) {
+                throw new Error(`Expected ${commitSHA} in summary '${checkRun.output.summary}' of tag-git run ${checkRun.id}: ${checkRun.url}`)
+            }
+            const gitVersion = gitVersionMatch[1]
+
+            for (const architecture of architecturesToTrigger) {
+                const workflowName = `git-artifacts-${architecture}`
+                const title = `Build Git ${gitVersion} artifacts`
+                const summary = `Build Git ${gitVersion} artifacts from commit ${commitSHA} (tag-git run #${workflowRunId})`
+                await queueCheckRun(
+                    context,
+                    await getToken(checkRunOwner, checkRunRepo),
+                    checkRunOwner,
+                    checkRunRepo,
+                    commitSHA,
+                    workflowName,
+                    title,
+                    summary
+                )
+            }
+
+            const triggerWorkflowDispatch = require('./trigger-workflow-dispatch')
+            for (const architecture of architecturesToTrigger) {
+                const run = await triggerWorkflowDispatch(
+                    context,
+                    await getToken(owner, repo),
+                    owner,
+                    repo,
+                    'git-artifacts.yml',
+                    'main', {
+                        architecture,
+                        tag_git_workflow_run_id: workflowRunId
+                    }
+                )
+                res = `${res}The \`git-artifacts-${architecture}\` workflow run [was started](${run.html_url}).\n`
+            }
+
+            return res
+        }
+        return `Not a cascading run: ${name}; Doing nothing.`
+    }
+    return `Unhandled action: ${action}`
+}

GitForWindowsHelper/check-runs.js

@@ -71,8 +71,23 @@ const cancelWorkflowRun = async (context, token, owner, repo, workflowRunId) =>
     console.log(answer)
 }
 
+const listCheckRunsForCommit = async (context, token, owner, repo, rev, checkRunName) => {
+    const githubApiRequest = require('./github-api-request')
+
+    const answer = await githubApiRequest(
+        context,
+        token,
+        'GET',
+        `/repos/${owner}/${repo}/commits/${rev}/check-runs?per_page=100${
+            checkRunName ? `&check_name=${checkRunName}` : ''
+        }`
+    )
+    return answer.check_runs
+}
+
 module.exports = {
     queueCheckRun,
     updateCheckRun,
-    cancelWorkflowRun
+    cancelWorkflowRun,
+    listCheckRunsForCommit
 }

GitForWindowsHelper/index.js

@@ -44,6 +44,16 @@ module.exports = async function (context, req) {
         return withStatus(500, undefined, e.toString('utf-8'))
     }
 
+    try {
+        const cascadingRuns = require('./cascading-runs.js')
+        if (req.headers['x-github-event'] === 'check_run'
+            && req.body.repository.full_name === 'git-for-windows/git'
+            && req.body.action === 'completed') return ok(await cascadingRuns(context, req))
+    } catch (e) {
+        context.log(e)
+        return withStatus(500, undefined, e.toString('utf-8'))
+    }
+
     context.log("Got headers")
     context.log(req.headers)
     context.log("Got body")

__tests__/index.test.js

@@ -259,10 +259,23 @@ The MINGW workflow run [was started](dispatched-workflow-open-pr.yml)`
 
 let mockQueueCheckRun = jest.fn(() => 'check-run-id')
 let mockUpdateCheckRun = jest.fn()
+let mockListCheckRunsForCommit = jest.fn((_context, _token, _owner, _repo, _rev, checkRunName) => {
+    if (checkRunName === 'git-artifacts-x86_64') return [{
+        status: 'completed',
+        conclusion: 'success',
+        html_url: '<url-to-existing-x86_64-run>',
+        output: {
+            title: 'Build Git -rc1',
+            summary: 'Build Git -rc1 from commit c8edb521bdabec14b07e9142e48cab77a40ba339 (tag-git run #4322343196)'
+        }
+    }]
+    return []
+})
 jest.mock('../GitForWindowsHelper/check-runs', () => {
     return {
         queueCheckRun: mockQueueCheckRun,
-        updateCheckRun: mockUpdateCheckRun
+        updateCheckRun: mockUpdateCheckRun,
+        listCheckRunsForCommit: mockListCheckRunsForCommit
     }
 })
 
@@ -323,3 +336,57 @@ The workflow run [was started](dispatched-workflow-add-release-note.yml)`,
         type: 'feature'
     })
 })
+
+test('a completed `tag-git` run triggers `git-artifacts` runs', async () => {
+    const context = makeContext({
+        action: 'completed',
+        check_run: {
+            name: 'tag-git',
+            head_sha: 'c8edb521bdabec14b07e9142e48cab77a40ba339',
+            conclusion: 'success',
+            output: {
+                title: 'Tag Git v2.40.0-rc1.windows.1 @c8edb521bdabec14b07e9142e48cab77a40ba339',
+                summary: 'Tag Git v2.40.0-rc1.windows.1 @c8edb521bdabec14b07e9142e48cab77a40ba339',
+                text: 'For details, see [this run](https://github.com/git-for-windows/git-for-windows-automation/actions/runs/4322343196).\nTagged Git v2.40.0-rc1.windows.1\nDone!.'
+            }
+        },
+        installation: {
+            id: 123
+        },
+        repository: {
+            name: 'git',
+            owner: {
+                login: 'git-for-windows'
+            },
+            full_name: 'git-for-windows/git'
+        }
+    }, {
+        'x-github-event': 'check_run'
+    })
+
+    try {
+        expect(await index(context, context.req)).toBeUndefined()
+        expect(context.res).toEqual({
+            body: `git-artifacts-x86_64 run already exists at <url-to-existing-x86_64-run>.
+The \`git-artifacts-i686\` workflow run [was started](dispatched-workflow-git-artifacts.yml).
+`,
+            headers: undefined,
+            status: undefined
+        })
+        expect(mockGitHubApiRequest).toHaveBeenCalled()
+        expect(mockGitHubApiRequest.mock.calls[0].slice(1)).toEqual([
+            'installation-access-token',
+            'POST',
+            '/repos/git-for-windows/git-for-windows-automation/actions/workflows/git-artifacts.yml/dispatches', {
+                ref: 'main',
+                inputs: {
+                    architecture: 'i686',
+                    tag_git_workflow_run_id: 4322343196
+                }
+            }
+        ])
+    } catch (e) {
+        context.log.mock.calls.forEach(e => console.log(e[0]))
+        throw e;
+    }
+})