From e61e6345bc951793a098c451d0d6099190839a2c Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 24 Oct 2026 13:47:19 +0200 Subject: [PATCH] Releases: in batches of 5 pull requests, or when the oldest has waited 6 hours One release per merge made about 40 releases in 31 hours, hard for players to follow (asked on Discord). release-now still releases at once. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/release.yml | 4 ++-- docs/release-flow.md | 9 ++++----- tests/test_release_train.py | 15 ++++++++++----- tools/release_train.py | 20 ++++++++++++++------ 4 files changed, 30 insertions(+), 18 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index a0953c73a..6b0fb2e0f 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -1,8 +1,8 @@ name: release # Automatic game releases (docs/release-flow.md). After every green `checks` run on main, every 10 minutes (so a # release waiting for merges to settle goes out without another merge) and by hand, tools/release_train.py decides: -# a release when pull requests merged since the last one changed what players run and the newest merged 5 minutes -# ago (the oldest 20 minutes ago, if merges never pause), or at once for a pull request labelled release-now. +# a release when 5 pull requests merged since the last one changed what players run and the newest merged 5 minutes +# ago, or when the oldest has waited 6 hours, or at once for a pull request labelled release-now. # RELEASES_PAUSED=1 (repository variable) stops them; so does an open issue labelled release-blocker, forced runs too. # Builds Linux (an older Ubuntu, so the binary runs on any recent distribution and on NixOS through nix-ld) and # Windows on GitHub, macOS on the Mac mini's runner (MAC_RUNNER=macos-latest sends it to GitHub), then diff --git a/docs/release-flow.md b/docs/release-flow.md index 72a5c53a9..758f254ee 100644 --- a/docs/release-flow.md +++ b/docs/release-flow.md @@ -116,10 +116,9 @@ commits) since the last **published** game release: `xtask/`, `packaging/`, `Cargo.toml`, `Cargo.lock`, `research-lock.json`, or an exporter `horizon-prepare` compiles (the `mods/horizon/src/test/java/dev/horizonlab/parity/*.java` files its sources name). Markdown never counts. -- It releases when at least one pull request counts and the newest of them merged at least 5 minutes ago, so a wave - of merges becomes one release; if merges never pause, it releases once the oldest has waited 20 minutes. There is - no minimum time between releases: every settled player-facing change ships, limited only by the release already - building: many releases a day. +- It releases in batches, so players get a few releases a day rather than one per merge: once 5 pull requests count + and the newest of them merged at least 5 minutes ago (a wave of merges becomes one release), or once the oldest has + waited 6 hours, however few they are. - A pull request labelled `release-now` (a crash or a blocker) releases at once. - A pull request labelled `skip-release` (work players don't see) doesn't count and isn't listed in the notes. - An open issue labelled `release-blocker` holds every game release, forced ones too (`held by release-blocker #N`). @@ -299,7 +298,7 @@ and by hand; pushes to `launcher` and `launcher-*` branches only build. - `tools/release_train.py decide --kind launcher` counts the pull requests merged since the last published launcher release that changed those paths (not `launcher/links.json`, which the launcher reads from main, nor - tests or Markdown), with the same settling rule (5 minutes, at most 20), `release-now`, `skip-release` and `RELEASES_PAUSED`. + tests or Markdown), with the same batching rule (5 pull requests settled 5 minutes, or the oldest 6 hours), `release-now`, `skip-release` and `RELEASES_PAUSED`. - The tag is `launcher@X.Y.Z` on the release line (`launcher@0.2.0` first; the game and the launcher count their patches separately). Without `.github/release-line.txt`, `launcher-vX.Y.Z`: the patch after the last launcher tag, or the next minor (`X.Y+1.0`) when one of those pull requests is labelled `feature`. `launcher-v0.2.0` was taken diff --git a/tests/test_release_train.py b/tests/test_release_train.py index 298077352..dde734c7d 100644 --- a/tests/test_release_train.py +++ b/tests/test_release_train.py @@ -120,15 +120,20 @@ class ReleaseTrainTests(unittest.TestCase): def test_decision(self): minute = dt.timedelta(minutes=1) decide = lambda prs, **kw: train.decision("game", prs, NOW, **kw)[0] - self.assertTrue(decide([pr(1, merged=6 * minute)]), "settled for the debounce") - self.assertFalse(decide([pr(1, merged=2 * minute)]), "merged moments ago") - self.assertFalse(decide([pr(1, merged=15 * minute), pr(2, merged=2 * minute)]), "a burst still merging") - self.assertTrue(decide([pr(1, merged=21 * minute), pr(2, merged=minute)]), "merges that never pause still ship") + hour = 60 * minute + five = lambda newest: [pr(n, merged=newest + n * minute) for n in range(5)] + self.assertTrue(decide(five(6 * minute)), "a batch, settled for the debounce") + self.assertFalse(decide(five(2 * minute)), "a batch still merging") + self.assertFalse(decide(five(6 * minute)[:4]), "not yet a batch") + self.assertFalse(decide([pr(1, merged=5 * hour)]), "a lone fix waits for others") + self.assertTrue(decide([pr(1, merged=6 * hour)]), "until the oldest has waited 6 hours") + self.assertTrue(decide([pr(1, merged=7 * hour), pr(2, merged=minute)]), "merges that never pause still ship") + self.assertFalse(decide([pr(n, merged=6 * minute) for n in range(4)] + [pr(9, labels=["skip-release"])]), + "work players don't see doesn't fill a batch") self.assertTrue(decide([pr(1, labels=["release-now"], merged=minute)])) self.assertFalse(decide([pr(1, paths=[])]), "nothing players run") self.assertFalse(decide([pr(1, labels=["skip-release"])])) self.assertFalse(decide([pr(1, labels=["release-now", "skip-release"])])) - self.assertFalse(decide([pr(1, merged=3 * minute), pr(2, labels=["skip-release"], merged=minute)]), "the settled one waits for nothing") self.assertFalse(decide([pr(1)], paused=True)) self.assertTrue(decide([], paused=True, force=True)) diff --git a/tools/release_train.py b/tools/release_train.py index b8d6468bb..6ec2739d9 100644 --- a/tools/release_train.py +++ b/tools/release_train.py @@ -7,9 +7,9 @@ python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json [--blockers] # before publishing A kind releases when a pull request merged into main since its last published release changed one of its -player-facing paths (GAME_PATHS, LAUNCHER_PATHS) and the newest of them merged at least DEBOUNCE ago (a burst -of merges becomes one release), or the oldest at least MAX_WAIT ago (merges that never pause still ship), or when one -of those pull requests is labelled release-now. Pull requests labelled skip-release (work players don't see) don't count +player-facing paths (GAME_PATHS, LAUNCHER_PATHS), once BATCH of them are waiting and the newest merged at least +DEBOUNCE ago (a burst of merges becomes one release), or once the oldest has waited MAX_WAIT (a lone fix still ships), +or at once when one of those pull requests is labelled release-now. Pull requests labelled skip-release (work players don't see) don't count towards a release and aren't listed in the notes. RELEASES_PAUSED=1 (a repository variable) stops automatic releases, and an open issue labelled release-blocker stops game releases, even forced ones, until it is closed. @@ -40,9 +40,11 @@ import sys ROOT = Path(__file__).resolve().parents[1] REPO = os.environ.get("GITHUB_REPOSITORY", "ludovic111/horizon") -# Releases ship constantly: a merge starts a release within minutes, once its wave of merges has settled. +# Releases ship in batches, so players get a few releases a day rather than one per merge: BATCH player-facing pull +# requests, settled for DEBOUNCE, or whatever is waiting once the oldest has waited MAX_WAIT. +BATCH = 5 DEBOUNCE = dt.timedelta(minutes=5) -MAX_WAIT = dt.timedelta(minutes=20) +MAX_WAIT = dt.timedelta(hours=6) # Kept as typed in release titles, where the clauses after the first are lowercased. PROPER = {"Horizon", "Horizon's", "Minecraft", "Mojang", "Microsoft", "Java", "Xbox", "PlayStation", "Steam", "Windows", "Linux", "LAN", "Kira", "Discord", "Wayland", "Hyprland", "F3", "GUI", "UI"} @@ -288,7 +290,13 @@ def decision(kind, prs, now, paused=False, force=False, new_line=None, blockers= return False, "no merged pull request changed what players run" if urgent: return True, "release-now: " + ", ".join(f"#{pr['number']}" for pr in urgent) - if merged and now - max(merged) < DEBOUNCE and now - min(merged) < MAX_WAIT: + if merged and now - min(merged) >= MAX_WAIT: + return True, f"{len(counted)} pull requests changed what players run; the oldest has waited {MAX_WAIT.seconds // 3600} hours" + if len(counted) < BATCH: + wait = MAX_WAIT - (now - min(merged)) if merged else MAX_WAIT + return False, (f"{len(counted)} of {BATCH} pull requests: waiting for more, or {wait.seconds // 60 + 1} more " + "minutes for the oldest") + if merged and now - max(merged) < DEBOUNCE: wait = DEBOUNCE - (now - max(merged)) return False, f"{len(counted)} pull requests: waiting {wait.seconds // 60 + 1} more minutes for merges to settle" return True, f"{len(counted)} pull requests changed what players run"