Files
horizon-airdef/tools/release_channels.py
T
Ludovic Marie 2a7303f76f Releases: beta and stable channels, promoted after 6 hours
Game releases go out as betas (GitHub pre-releases, never "latest") with the Mac mini's smoke
report attached. promote.yml (every 30 minutes, or by hand from a phone) runs
tools/release_channels.py, which makes the newest beta stable and latest once it has been out 6
hours, passed its smoke test and no release-blocker issue covers it, with notes rewritten to cover
everything since the last stable release. release_train.py counts merges from the newest release of
either channel, and a beta's notes say it is one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 15:34:03 +02:00

174 lines
8.5 KiB
Python

#!/usr/bin/env python3
"""Promotes Horizon's beta game releases to stable (.github/workflows/promote.yml, docs/release-flow.md).
python3 tools/release_channels.py promote # the newest beta that is due, if any
python3 tools/release_channels.py promote --tag v2026.10.19.03 # that beta now (by hand)
python3 tools/release_channels.py promote --tag v2026.10.19.03 --force # even if blocked or untested
python3 tools/release_channels.py promote --dry-run # say what would happen, change nothing
Every game release goes out as a beta (a GitHub pre-release). A beta is due for stable when:
- it is newer than the stable release (GitHub's "latest", which launchers and servers install by default),
- it has been out PROMOTE_AFTER (6 hours) without trouble; a promotion by hand (--tag) skips the wait,
- its release smoke test passed: release.yml attaches smoke-test.json only after the Mac mini ran the game,
- and no issue labelled release-blocker covers it. A blocker covers the betas from the version it names onwards
(every beta when it names none), published while it is open; one closed as completed keeps covering the betas
published before it closed (they still have the bug), one closed as not planned covers nothing.
The newest due beta is promoted: marked stable and latest, with notes covering everything since the previous
stable release (tools/release_train.py notes --stable). Older betas stay betas: the stable one contains them.
Issue text is only searched for version numbers; it never changes what this does beyond blocking.
"""
import argparse
import datetime as dt
import json
import os
from pathlib import Path
import re
import subprocess
import sys
import tempfile
ROOT = Path(__file__).resolve().parents[1]
REPO = os.environ.get("GITHUB_REPOSITORY", "ludovic111/horizon")
PROMOTE_AFTER = dt.timedelta(hours=6)
SMOKE_ASSET = "smoke-test.json"
BLOCKER = "release-blocker"
GAME_TAG = re.compile(r"v\d{4}\.\d{2}\.\d{2}(?:\.\d+)?")
# A version as people write it in an issue: with or without the v, a day's counter padded or not.
MENTION = re.compile(r"(?<![\w.])v?(\d{4})\.(\d{1,2})\.(\d{1,2})(?:\.(\d+))?(?!\w)")
def tag_key(tag):
"""A game tag's numbers, four of them (v2026.10.19 is (2026, 10, 19, 0)), so tags and mentions compare."""
return padded(tuple(int(part) for part in re.findall(r"\d+", tag)))
def padded(version):
return version + (0,) * (4 - len(version))
def parse_time(text):
return dt.datetime.fromisoformat(text.replace("Z", "+00:00")) if text else None
def mentioned_versions(text):
"""The game versions an issue names, as tag keys ((2026, 10, 19, 3) for v2026.10.19.03)."""
return {padded(tuple(int(part) for part in match.groups() if part is not None)) for match in MENTION.finditer(text or "")}
def covers(blocker, release):
"""Whether a release-blocker issue holds this beta back."""
if blocker.get("state") == "closed":
closed = parse_time(blocker.get("closed_at"))
if blocker.get("state_reason") != "completed" or not closed:
return False
if parse_time(release["published_at"]) >= closed:
return False
versions = mentioned_versions(f"{blocker.get('title', '')}\n{blocker.get('body') or ''}")
if not versions:
return True
return any(tag_key(release["tag_name"]) >= version for version in versions)
def stable(releases):
"""The newest stable (non pre-release) game release."""
stables = [r for r in releases if not r["prerelease"]]
return max(stables, key=lambda r: tag_key(r["tag_name"]), default=None)
def reasons_against(release, current, blockers, now, by_hand=False):
"""Why this beta can't become stable now: an empty list when it can."""
reasons = []
if not release["prerelease"]:
reasons.append("it is already stable")
if current and tag_key(release["tag_name"]) <= tag_key(current["tag_name"]):
reasons.append(f"it is not newer than the stable {current['tag_name']}")
age = now - parse_time(release["published_at"])
if not by_hand and age < PROMOTE_AFTER:
left = PROMOTE_AFTER - age
reasons.append(f"it has been out {age.seconds // 3600} h {age.seconds % 3600 // 60} min, "
f"{left.seconds // 3600} h {left.seconds % 3600 // 60} min to go")
if not any(asset["name"] == SMOKE_ASSET for asset in release.get("assets", [])):
reasons.append(f"it has no {SMOKE_ASSET}: the release smoke test did not run")
for blocker in blockers:
if covers(blocker, release):
reasons.append(f"release-blocker #{blocker['number']}")
return reasons
def choose(releases, blockers, now, tag=None, force=False):
"""(the beta to promote or None, a line saying why) for the game releases `releases`."""
games = [r for r in releases if not r["draft"] and GAME_TAG.fullmatch(r["tag_name"])]
current = stable(games)
if tag:
release = next((r for r in games if r["tag_name"] == tag), None)
if not release:
return None, f"no published game release is tagged {tag}"
reasons = reasons_against(release, current, blockers, now, by_hand=True)
if force:
reasons = [r for r in reasons if r == "it is already stable"]
if reasons:
return None, f"{tag} stays a beta: " + "; ".join(reasons)
return release, f"{tag} promoted by hand" + (" with force" if force else "")
betas = sorted((r for r in games if r["prerelease"]), key=lambda r: tag_key(r["tag_name"]), reverse=True)
held = []
for release in betas:
reasons = reasons_against(release, current, blockers, now)
if not reasons:
return release, f"{release['tag_name']} has been out {PROMOTE_AFTER.seconds // 3600} h, passed its smoke test " \
"and no release-blocker covers it"
held.append(f"{release['tag_name']}: " + "; ".join(reasons))
return None, "no beta is due" + (" (" + " / ".join(held[:3]) + ")" if held else "")
def gh(*arguments, capture=True):
result = subprocess.run(["gh", *arguments], cwd=ROOT, capture_output=capture, text=True)
if result.returncode:
raise SystemExit(f"gh {' '.join(arguments)}: {(result.stderr or '').strip()}")
return result.stdout
def gh_pages(path):
return [item for page in json.loads(gh("api", path, "--paginate", "--slurp") or "[]") for item in page]
def promote(release):
"""Marks the beta stable and latest, with notes covering everything since the previous stable release."""
tag = release["tag_name"]
with tempfile.TemporaryDirectory() as out:
subprocess.run([sys.executable, str(ROOT / "tools" / "release_train.py"), "notes", "--kind", "game", "--tag", tag,
"--head", tag, "--stable", "--out", out], cwd=ROOT, check=True, stdout=subprocess.DEVNULL)
title = (Path(out) / "title.txt").read_text().strip()
gh("release", "edit", tag, "--repo", REPO, "--prerelease=false", "--latest", "--title", title,
"--notes-file", str(Path(out) / "body.md"))
def main():
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("command", choices=["promote"])
parser.add_argument("--tag", help="promote this beta now (by hand: no 6-hour wait)")
parser.add_argument("--force", action="store_true", help="with --tag: even without a smoke test or with a blocker")
parser.add_argument("--dry-run", action="store_true", help="say what would be promoted, change nothing")
parser.add_argument("--now", help="the time to decide at (ISO 8601; default now)")
args = parser.parse_args()
if args.force and not args.tag:
parser.error("--force needs --tag: only a named beta is forced")
now = dt.datetime.fromisoformat(args.now) if args.now else dt.datetime.now(dt.timezone.utc)
releases = gh_pages(f"repos/{REPO}/releases?per_page=100")
blockers = [issue for issue in gh_pages(f"repos/{REPO}/issues?labels={BLOCKER}&state=all&per_page=100")
if "pull_request" not in issue]
release, reason = choose(releases, blockers, now, args.tag, args.force)
if release and not args.dry_run:
promote(release)
line = ("Would promote: " if release and args.dry_run else "") + reason
print(line)
if os.environ.get("GITHUB_STEP_SUMMARY"):
with open(os.environ["GITHUB_STEP_SUMMARY"], "a") as summary:
summary.write(f"### {line}\n")
return 1 if args.tag and not release else 0
if __name__ == "__main__":
sys.exit(main())