mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-21 16:52:19 +09:00
[CI, Docs] (.github/workflows, CONTRIBUTING.md, scripts/ci): validate and publish version tags
This commit is contained in:
1 parent
3a1058dbab
commit
6306b28af5
6 files changed
+408
-17
No files matched your search
@@ -0,0 +1,314 @@
|
||||
#!/usr/bin/env python3
|
||||
# MobileGL - scripts/ci/release.py
|
||||
# Copyright (c) 2025-2026 MobileGL-Dev
|
||||
# Licensed under the GNU Lesser General Public License v3.0:
|
||||
# https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
# https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
# SPDX-License-Identifier: LGPL-3.0-only
|
||||
# End of Source File Header
|
||||
|
||||
"""Validate and publish an annotated version tag after both required workflows succeed."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
from urllib.error import HTTPError, URLError
|
||||
from urllib.parse import quote, urlencode
|
||||
from urllib.request import Request, urlopen
|
||||
|
||||
|
||||
WORKFLOWS = {"test.yml": "Test", "apk.yml": "MobileGL APK"}
|
||||
WAIT_SECONDS = 330 * 60
|
||||
POLL_SECONDS = 30
|
||||
VERSION = re.compile(r"v[0-9]+\.[0-9]+(?:-(?:alpha|rc)\.[1-9][0-9]*)?")
|
||||
SHA = re.compile(r"[0-9a-f]{40}")
|
||||
LOGIN = re.compile(r"[a-zA-Z0-9][a-zA-Z0-9-]*(?:\[bot\])?")
|
||||
|
||||
|
||||
class ReleaseError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class GitHub:
|
||||
def __init__(self):
|
||||
self.repo = os.environ["GITHUB_REPOSITORY"]
|
||||
self.url = f"{os.environ['GITHUB_SERVER_URL']}/{self.repo}"
|
||||
self.api = f"{os.environ['GITHUB_API_URL']}/repos/{self.repo}"
|
||||
self.headers = {
|
||||
"Authorization": f"Bearer {os.environ['GH_TOKEN']}",
|
||||
"Accept": "application/vnd.github+json",
|
||||
"Content-Type": "application/json",
|
||||
"X-GitHub-Api-Version": "2026-03-10",
|
||||
}
|
||||
|
||||
def request(self, path, method="GET", body=None, *, deadline=None, allow_missing=False):
|
||||
data = json.dumps(body).encode() if body is not None else None
|
||||
request = Request(self.api + path, data=data, headers=self.headers, method=method)
|
||||
for attempt in range(3):
|
||||
remaining = deadline - time.monotonic() if deadline is not None else 20
|
||||
if remaining <= 0:
|
||||
raise ReleaseError("The 330-minute validation deadline elapsed.")
|
||||
try:
|
||||
with urlopen(request, timeout=min(20, remaining)) as response:
|
||||
raw = response.read()
|
||||
return json.loads(raw) if raw else None
|
||||
except HTTPError as exc:
|
||||
if exc.code == 404 and allow_missing:
|
||||
return None
|
||||
if method != "GET" or exc.code not in {429, 500, 502, 503, 504} or attempt == 2:
|
||||
raise ReleaseError(f"{method} {path} returned HTTP {exc.code}: "
|
||||
f"{exc.read().decode(errors='replace')}") from exc
|
||||
except (URLError, TimeoutError):
|
||||
if method != "GET" or attempt == 2:
|
||||
raise
|
||||
time.sleep(min(2 ** attempt, remaining))
|
||||
|
||||
def pages(self, path, params=(), key=None, deadline=None):
|
||||
for page in range(1, 1001):
|
||||
query = urlencode([*params, ("per_page", 100), ("page", page)])
|
||||
response = self.request(f"{path}?{query}", deadline=deadline)
|
||||
entries = response[key] if key else response
|
||||
yield from entries
|
||||
if len(entries) < 100:
|
||||
return
|
||||
raise ReleaseError(f"Too many result pages for {path}.")
|
||||
|
||||
def tag_object(self, tag):
|
||||
ref = self.request(f"/git/ref/tags/{quote(tag, safe='')}", allow_missing=True)
|
||||
return ref["object"] if ref else None
|
||||
|
||||
def release_for_tag(self, tag):
|
||||
return self.request(f"/releases/tags/{quote(tag, safe='')}", allow_missing=True)
|
||||
|
||||
def dispatch(self, workflow, ref, deadline):
|
||||
response = self.request(f"/actions/workflows/{workflow}/dispatches", "POST",
|
||||
{"ref": ref}, deadline=deadline)
|
||||
if not isinstance(response, dict) or not response.get("workflow_run_id"):
|
||||
raise ReleaseError(f"The dispatch for {workflow} did not return a run ID.")
|
||||
return response["workflow_run_id"]
|
||||
|
||||
def create_release(self, tag, commit, body, draft=False):
|
||||
return self.request("/releases", "POST", {
|
||||
"tag_name": tag,
|
||||
"target_commitish": commit,
|
||||
"name": tag,
|
||||
"body": body,
|
||||
"draft": draft,
|
||||
"prerelease": "-" in tag,
|
||||
"generate_release_notes": False,
|
||||
})
|
||||
|
||||
|
||||
def git(*args):
|
||||
return subprocess.check_output(["git", *args]).decode("utf-8")
|
||||
|
||||
|
||||
def ancestor_of(commit, ref):
|
||||
return subprocess.run(["git", "merge-base", "--is-ancestor", commit, ref],
|
||||
check=False).returncode == 0
|
||||
|
||||
|
||||
def event_candidate(github):
|
||||
event = json.loads(Path(os.environ["GITHUB_EVENT_PATH"]).read_text())
|
||||
tag = os.environ["GITHUB_REF_NAME"]
|
||||
if not VERSION.fullmatch(tag):
|
||||
raise ReleaseError(f"Unsupported version tag {tag!r}.")
|
||||
if event.get("deleted") or event.get("forced") or not event.get("created"):
|
||||
raise ReleaseError("Release requires a newly created version tag.")
|
||||
ref = f"refs/tags/{tag}"
|
||||
tag_sha = git("rev-parse", "--verify", ref).strip()
|
||||
if git("cat-file", "-t", tag_sha).strip() != "tag":
|
||||
raise ReleaseError("Release requires an annotated tag.")
|
||||
commit = git("rev-parse", "--verify", f"{ref}^{{commit}}").strip()
|
||||
if git("rev-parse", "--verify", "HEAD").strip() != commit:
|
||||
raise ReleaseError("The checkout differs from the tagged commit.")
|
||||
if event.get("after") not in {tag_sha, commit} or event.get("ref") != ref:
|
||||
raise ReleaseError("The tag differs from the original push event.")
|
||||
if not ancestor_of(commit, "refs/remotes/origin/main"):
|
||||
raise ReleaseError("The tagged commit must be reachable from upstream main.")
|
||||
remote_tag = github.tag_object(tag)
|
||||
if not remote_tag or remote_tag["type"] != "tag" or remote_tag["sha"] != tag_sha:
|
||||
raise ReleaseError("The remote annotated tag differs from the checkout.")
|
||||
# Read the tag object's message so paragraph breaks and signed tags are handled by Git.
|
||||
notes = git("for-each-ref", "--format=%(contents)", ref).rstrip("\n")
|
||||
signature = git("for-each-ref", "--format=%(contents:signature)", ref).strip()
|
||||
if signature and notes.endswith(signature):
|
||||
notes = notes.removesuffix(signature).rstrip("\n")
|
||||
if not notes.strip():
|
||||
raise ReleaseError("The annotated tag must contain release notes.")
|
||||
sender = event.get("sender", {}).get("login", "")
|
||||
if not LOGIN.fullmatch(sender):
|
||||
raise ReleaseError("The tag push event does not identify a GitHub account.")
|
||||
return tag, tag_sha, commit, notes, sender
|
||||
|
||||
|
||||
def release_already_exists(github, tag):
|
||||
release = github.release_for_tag(tag)
|
||||
if release and release["draft"]:
|
||||
raise ReleaseError(f"A draft Release already exists for {tag}.")
|
||||
if release:
|
||||
print(f"Release already published: {release['html_url']}")
|
||||
return bool(release)
|
||||
|
||||
|
||||
def eligible_run(run, repo, commit, tag):
|
||||
if run["head_sha"] != commit or (run.get("head_repository") or {}).get("full_name") != repo:
|
||||
return False
|
||||
if run["event"] == "push":
|
||||
return run["head_branch"] == "dev"
|
||||
return run["event"] == "workflow_dispatch" and run["display_title"] in {
|
||||
f"Release validation (refs/tags/{tag})",
|
||||
"Release validation (refs/heads/main)",
|
||||
}
|
||||
|
||||
|
||||
def latest_run(github, workflow, commit, tag, deadline):
|
||||
runs = github.pages(f"/actions/workflows/{workflow}/runs",
|
||||
[("head_sha", commit)], key="workflow_runs", deadline=deadline)
|
||||
return next((run for run in runs if eligible_run(run, github.repo, commit, tag)), None)
|
||||
|
||||
|
||||
def summarize(github, runs):
|
||||
with Path(os.environ["GITHUB_STEP_SUMMARY"]).open("a") as summary:
|
||||
summary.write("### Release validation\n\n")
|
||||
for workflow, run in runs.items():
|
||||
name = WORKFLOWS[workflow]
|
||||
status = run.get("conclusion") or run.get("status") or "dispatched"
|
||||
url = f"{github.url}/actions/runs/{run['id']}"
|
||||
summary.write(f"- [{name}]({url}) — {status}\n")
|
||||
|
||||
|
||||
def wait_for_runs(github, runs, commit, deadline):
|
||||
while True:
|
||||
all_success = True
|
||||
for workflow, run in runs.items():
|
||||
if run.get("conclusion") == "success":
|
||||
continue
|
||||
run = github.request(f"/actions/runs/{run['id']}", deadline=deadline)
|
||||
runs[workflow] = run
|
||||
if run["head_sha"] != commit or (run.get("head_repository") or {}).get("full_name") != github.repo:
|
||||
raise ReleaseError(f"{WORKFLOWS[workflow]} ran against an unexpected repository or commit.")
|
||||
if run["status"] == "completed" and run["conclusion"] != "success":
|
||||
raise ReleaseError(f"{WORKFLOWS[workflow]} concluded {run['conclusion']}.")
|
||||
all_success &= run["conclusion"] == "success"
|
||||
if all_success:
|
||||
return
|
||||
remaining = deadline - time.monotonic()
|
||||
if remaining <= 0:
|
||||
raise ReleaseError("The 330-minute validation deadline elapsed.")
|
||||
time.sleep(min(POLL_SECONDS, remaining))
|
||||
|
||||
|
||||
def validate_workflows(github, commit, tag=None):
|
||||
deadline = time.monotonic() + WAIT_SECONDS
|
||||
runs = {}
|
||||
try:
|
||||
if tag:
|
||||
for workflow in WORKFLOWS:
|
||||
run = latest_run(github, workflow, commit, tag, deadline)
|
||||
if run:
|
||||
runs[workflow] = run
|
||||
for workflow, run in runs.items():
|
||||
if run["status"] == "completed" and run["conclusion"] != "success":
|
||||
raise ReleaseError(f"{WORKFLOWS[workflow]} concluded {run['conclusion']}.")
|
||||
for workflow, name in WORKFLOWS.items():
|
||||
if workflow not in runs:
|
||||
runs[workflow] = {"id": github.dispatch(workflow, tag or "main", deadline)}
|
||||
print(f"{name}: {github.url}/actions/runs/{runs[workflow]['id']}", flush=True)
|
||||
wait_for_runs(github, runs, commit, deadline)
|
||||
finally:
|
||||
summarize(github, runs)
|
||||
|
||||
|
||||
def previous_release(github, tag, commit):
|
||||
for release in github.pages("/releases"):
|
||||
previous = release["tag_name"]
|
||||
if release["draft"] or previous == tag or not VERSION.fullmatch(previous):
|
||||
continue
|
||||
ref = f"refs/tags/{previous}"
|
||||
if ancestor_of(f"{ref}^{{commit}}", commit):
|
||||
return previous
|
||||
return None
|
||||
|
||||
|
||||
def contributors(github, revision):
|
||||
authors = {}
|
||||
data = git("log", "-z", "--format=%H%x00%aN%x00%aE", revision)
|
||||
fields = data.split("\0")
|
||||
for commit, name, email in zip(fields[::3], fields[1::3], fields[2::3]):
|
||||
authors.setdefault((name, email.casefold()), commit)
|
||||
credits = {}
|
||||
for (name, _email), commit in authors.items():
|
||||
author = github.request(f"/commits/{commit}").get("author") or {}
|
||||
login = author.get("login", "")
|
||||
escaped_name = "".join(f"\\{char}" if char in "\\@<>&*_[`]" else char
|
||||
for char in " ".join(name.split()))
|
||||
credit = f"@{login}" if LOGIN.fullmatch(login) else escaped_name
|
||||
if credit:
|
||||
credits.setdefault(credit.casefold(), credit)
|
||||
return ", ".join(sorted(credits.values(), key=str.casefold))
|
||||
|
||||
|
||||
def publish(github, tag, tag_sha, commit, notes, sender):
|
||||
if release_already_exists(github, tag):
|
||||
return
|
||||
previous = previous_release(github, tag, commit)
|
||||
revision = f"refs/tags/{previous}..{commit}" if previous else commit
|
||||
credits = contributors(github, revision)
|
||||
history = (f"[Compare {previous} to {tag}]({github.url}/compare/{previous}...{tag})"
|
||||
if previous else f"[Commit history for {tag}]({github.url}/commits/{tag})")
|
||||
parts = [notes, f"Released by @{sender}"]
|
||||
if credits:
|
||||
parts.append(f"**Contributors**\n\n{credits}")
|
||||
parts.extend([history, "Clone with submodules:\n\n"
|
||||
f"```sh\ngit clone --branch {tag} --recurse-submodules {github.url}.git\n```"])
|
||||
remote_tag = github.tag_object(tag)
|
||||
if not remote_tag or remote_tag["sha"] != tag_sha:
|
||||
raise ReleaseError("The remote tag changed while preparing the release.")
|
||||
release = github.create_release(tag, commit, "\n\n".join(parts))
|
||||
print(f"Published {release['html_url']}")
|
||||
|
||||
|
||||
def preflight(github):
|
||||
commit = os.environ["GITHUB_SHA"]
|
||||
if os.environ["GITHUB_REF"] != "refs/heads/main" or not SHA.fullmatch(commit):
|
||||
raise ReleaseError("Release preflight must run on main.")
|
||||
tag = f"release-preflight-{os.environ['GITHUB_RUN_ID']}-{os.environ['GITHUB_RUN_ATTEMPT']}"
|
||||
if github.tag_object(tag):
|
||||
raise ReleaseError("The preflight name is already a Git tag.")
|
||||
draft = github.create_release(tag, commit, "Verifies release permissions.", draft=True)
|
||||
if not draft["draft"]:
|
||||
raise ReleaseError("The preflight Release is not a draft.")
|
||||
github.request(f"/releases/{draft['id']}", "DELETE")
|
||||
if github.tag_object(tag):
|
||||
raise ReleaseError("Preflight unexpectedly created a Git tag.")
|
||||
print("Draft Release creation and cleanup succeeded.", flush=True)
|
||||
validate_workflows(github, commit)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("command", choices=("validate", "publish", "preflight"))
|
||||
command = parser.parse_args().command
|
||||
github = GitHub()
|
||||
if command == "preflight":
|
||||
preflight(github)
|
||||
return
|
||||
tag, tag_sha, commit, notes, sender = event_candidate(github)
|
||||
if command == "validate":
|
||||
if not release_already_exists(github, tag):
|
||||
validate_workflows(github, commit, tag)
|
||||
else:
|
||||
publish(github, tag, tag_sha, commit, notes, sender)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
main()
|
||||
except (ReleaseError, OSError, subprocess.CalledProcessError) as exc:
|
||||
sys.exit(str(exc))
|
||||
Reference in new issue
Block a user