Merge pull request #1981 from ludovic111/ci/parity-main

🤖 Agent: merged on verify. CI speed (Ludovic's focus tonight); measurements in the body and in horizon-parity/ci-speed/LOG.md.
This commit is contained in:
Ludovic Marie
2026-10-26 00:48:22 +01:00
committed by GitHub
9 changed files with 356 additions and 17 deletions
+32 -2
View File
@@ -3,7 +3,8 @@ name: checks
# check main requires, so it never has a condition: a skipped job counts as passed, and every run of this workflow
# must report a real verify (a pull request that changes no Rust finishes it in seconds instead).
# parity: the vanilla harnesses a pull request's changes can affect, on the Mac mini's runner, which holds the
# maintainer's own Minecraft files (Horizon never downloads the game); .github/workflows/parity.yml. A fork's pull
# maintainer's own Minecraft files (Horizon never downloads the game); .github/workflows/parity.yml. Only for a pull
# request that changes a harness, oracle, probe or the runner: the rest are checked on main by parity-main. A fork's pull
# request runs it only when a maintainer adds the run-parity label (.github/workflows/run-parity.yml), so labels
# never start this workflow. See docs/release-flow.md.
on:
@@ -72,8 +73,37 @@ jobs:
run: |
cargo +stable test --workspace --lib --bins --tests --features horizon-client/mods,horizon-mods/pack
cargo +stable test --workspace --doc --features horizon-client/mods,horizon-mods/pack
parity:
# Most pull requests leave the harnesses to parity-main, which runs them on main a batch of merges at a time
# (.github/workflows/parity-main.yml; releases wait for it). A pull request still runs them itself when it changes
# a harness, an oracle, a probe or the runner, or carries the run-parity label (run-parity.yml, when it is added).
parity-scope:
if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
runs-on: ubuntu-latest
outputs:
run: ${{ steps.scope.outputs.run }}
steps:
- uses: actions/checkout@v4
with:
ref: ${{ github.event.pull_request.head.sha }}
fetch-depth: 0
persist-credentials: false
- id: scope
env:
BASE_SHA: ${{ github.event.pull_request.base.sha }}
LABELS: ${{ join(github.event.pull_request.labels.*.name, ' ') }}
run: |
changed=$(git diff --name-only "$(git merge-base "$BASE_SHA" HEAD)" HEAD)
harness=$(grep -E '^(tools/test_[a-z0-9_]+_parity\.py|tools/(parity[a-z_]*|lab)\.py|tools/parity_hosts\.json|mods/horizon/src/test/|crates/[^/]+/examples/|crates/horizon-client/src/game/[a-z_]*(fixture|harness)\.rs|\.github/workflows/parity[a-z-]*\.yml)' <<< "$changed" || true)
if [ -n "$harness" ] || [[ " $LABELS " == *" run-parity "* ]]; then
echo "run=true" >> "$GITHUB_OUTPUT"
echo "The pull request runs its harnesses: ${harness:-label run-parity}"
else
echo "run=false" >> "$GITHUB_OUTPUT"
echo "No harness, oracle, probe or runner change: parity-main checks this on main"
fi
parity:
needs: parity-scope
if: needs.parity-scope.outputs.run == 'true'
uses: ./.github/workflows/parity.yml
with:
base: ${{ github.event.pull_request.base.sha }}
+70
View File
@@ -0,0 +1,70 @@
name: parity-main
# The vanilla harnesses on main, a batch of merges at a time (docs/release-flow.md#parity-on-main), on the Mac mini's
# runner. One run at a time: merges that land while a run goes on wait in one pending run (GitHub keeps only the
# newest), which checks every merge since main's last green parity-main (tools/parity_main.py base). On a failure it
# bisects the failing harnesses over those merges and comments on the pull request that broke them. Releases ship
# only a commit whose parity-main passed (tools/release_train.py), so nothing a harness catches reaches players.
on:
push:
branches: [main]
workflow_dispatch:
permissions:
contents: read
# The comment on the merge that broke a harness.
pull-requests: write
# tools/parity_main.py base reads earlier runs.
actions: read
concurrency:
group: parity-main
cancel-in-progress: false
env:
# Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
HORIZON_TELEMETRY_URL: "off"
jobs:
parity-main:
runs-on: [self-hosted, horizon-game]
timeout-minutes: 240 # a core-crate batch reruns ~300 harnesses (~60-90 min), a bisect a few rounds of the failures
steps:
- uses: actions/checkout@v4
with:
ref: ${{ github.sha }}
fetch-depth: 0
persist-credentials: false
# Keeps .local/ (parity state, probe builds, oracle results) and target/ between runs.
clean: false
- uses: dtolnay/rust-toolchain@stable
- name: Tools from the runner
run: bash tools/ci/runner-env.sh
- name: Vanilla data, and resources prepared by this preparer
run: bash tools/ci/vanilla-data.sh
- name: Main's last green parity-main
id: base
env:
GH_TOKEN: ${{ github.token }}
run: echo "sha=$(python3 tools/parity_main.py base)" >> "$GITHUB_OUTPUT"
- name: The harnesses the merges since then can affect
env:
PARITY_HOSTS: ''
BASE_SHA: ${{ steps.base.outputs.sha }}
run: |
echo "Merges since ${BASE_SHA}:"
git log --first-parent --format=' %h %s' "$BASE_SHA..HEAD"
python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400
- name: The merge that broke them
if: failure()
env:
GH_TOKEN: ${{ github.token }}
PARITY_HOSTS: ''
BASE_SHA: ${{ steps.base.outputs.sha }}
run: |
rm -rf .local/parity-main-logs && cp -R .local/parity-runner/logs .local/parity-main-logs 2>/dev/null || true
python3 tools/parity_main.py bisect "$BASE_SHA" --comment
- name: Logs of the failed harnesses
if: failure()
uses: actions/upload-artifact@v4
with:
name: parity-main-logs
path: .local/parity-main-logs/
if-no-files-found: ignore
retention-days: 7
+6 -4
View File
@@ -1,6 +1,7 @@
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:
# release waiting for merges to settle goes out without another merge) and by hand, tools/release_train.py decides,
# for a commit whose checks and parity-main (the vanilla harnesses on main) both passed:
# 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.
@@ -18,7 +19,8 @@ name: release
# gh workflow run release -f dry_run=false -f force=true # on main: release now, whatever the rules say
on:
workflow_run:
workflows: [checks]
# A game release ships a commit both passed on (parity-main runs on batches: the newest commit it passed on).
workflows: [checks, parity-main]
types: [completed]
branches: [main]
schedule:
@@ -64,8 +66,8 @@ jobs:
env:
GH_TOKEN: ${{ github.token }}
RELEASES_PAUSED: ${{ vars.RELEASES_PAUSED }}
# The commit whose checks just passed; a dry run builds the branch it was started on; otherwise
# main's newest commit with green checks.
# The commit whose checks or parity-main just passed; a dry run builds the branch it was started on;
# otherwise main's newest commit with green checks and parity-main.
HEAD_SHA: ${{ github.event.workflow_run.head_sha || (steps.mode.outputs.dry_run == 'true' && github.sha) || '' }}
FORCE: ${{ inputs.force && 'yes' || '' }}
run: |
+2
View File
@@ -20,6 +20,8 @@ python3 tools/parity.py --changed origin/main # those a branch's changes ca
python3 tools/parity.py --changed-files paths.txt # the same for listed paths, in a copy without Git (tools/pr_ready.py)
```
On CI, a pull request runs the parity job only when it changes a harness, an oracle, a probe or the runner; everything else is checked on main by `parity-main`, a batch of merges at a time, which bisects a failure to the merge that caused it (`tools/parity_main.py`; [release-flow.md](release-flow.md#parity-on-main)). Game releases wait for it.
Each harness runs unmodified under a tracer that records the files it depended on: its Python modules, its Java oracle and the oracle sources javac pulled in, other repository files it read, and the Rust sources of the probes it ran (from Cargo's `.d` dep-info files). A pass stands until one of those files, the pinned vanilla artifacts, `Cargo.lock` or the Rust/Java toolchains change. State and logs are in `.local/parity-runner/`; each harness's own outputs stay in its `.local/<name>/` directory.
Vanilla oracle runs are reused as well. `tools/parity_shim.py` stands in for `java` and `javac`: it records each oracle run's outputs and the content of every file under the paths its arguments name, and replays the run while those are unchanged. After a Rust-only change a harness pays only for its Rust side (`block_update`: 53 s to 5 s). Files an oracle writes outside its named paths aren't tracked, so a harness that fails while reusing oracle results is rerun fresh, and stops reusing them if it then passes. `--all` and `--fresh` never reuse them.
+27 -3
View File
@@ -13,7 +13,7 @@ reopened; labels never start it):
| Job | Runs on | What | Time |
| --- | --- | --- | --- |
| `verify` | GitHub `ubuntu-latest` | Public-tree check, Python tests, rustfmt, clippy with warnings denied, Rust tests. Dependencies and the workspace build come from a cache saved by main's runs | ~4 min cold, less warm |
| `parity / parity` | The Mac mini's runner (`ludovics-mac-mini`, label `horizon-game`) | The vanilla harnesses the change can affect (`tools/parity.py --changed <base>`) | seconds when nothing is affected; minutes per affected harness |
| `parity / parity` | The Mac mini's runner (`ludovics-mac-mini`, label `horizon-game`) | Only for a change to a harness, an oracle, a probe or the runner (or the `run-parity` label): the vanilla harnesses the change can affect (`tools/parity.py --changed <base>`). Other pull requests skip it: [parity-main](#parity-on-main) checks them on main | seconds when nothing is affected; minutes per affected harness |
Pushes to main run `verify` only; the nightly audit covers main's harnesses.
@@ -87,10 +87,34 @@ gh api -X POST repos/ludovic111/horizon/branches/main/protection/required_status
A skipped `parity` (a fork's pull request without the label) counts as passed, so requiring it never blocks a
fork's pull request; the maintainer decides whether to run it.
## Parity on main
Most pull requests merge on `verify` alone and leave the vanilla harnesses to `.github/workflows/parity-main.yml`,
which runs them on main a batch of merges at a time, on the Mac mini's runner:
- It starts on every push to main, one run at a time (`concurrency: parity-main`). Merges that land while a run
goes on wait in one pending run: GitHub keeps only the newest and cancels the others, so the next run takes them
all.
- `tools/parity_main.py base` gives the newest commit main contains whose parity-main passed (else the last
merge's parent), and the run is `tools/parity.py --changed <that commit>`: the union of the harnesses every merge
since then can affect, once, with every earlier pass reused.
- On a failure, `tools/parity_main.py bisect` checks out the batch's first-parent merges by halves and runs only
the failing harnesses, names the first merge they fail on in the run's summary and comments on its pull request
(`🤖 Agent: parity-main found that this merge breaks ...`). Fix it with a pull request as usual; the next
run checks from the last green commit again.
- Game releases ship only a commit both `checks` and `parity-main` passed on (`tools/release_train.py`, see
below), so a broken merge holds releases instead of reaching players. `release.yml` also starts when a
parity-main run finishes. A forced release (`force=true`) doesn't wait for parity-main.
A pull request still runs its own parity job when it changes a harness script, an oracle
(`mods/horizon/src/test/`), a probe (`crates/*/examples/`, `game/*_fixture.rs`, `game/*_harness.rs`), the runner
(`tools/parity*.py`, `tools/lab.py`, `tools/parity_hosts.json`, `parity*.yml`), or carries the `run-parity` label
(`run-parity.yml` runs it when the label is added).
## Game releases
`.github/workflows/release.yml` releases the game by itself. It starts after every green `checks` run of a push
to main, every 10 minutes (so a release waiting for merges to settle goes out without another merge), and by hand.
`.github/workflows/release.yml` releases the game by itself. It starts after every green `checks` or `parity-main`
run of a push to main (it releases a commit only once both passed on it), every 10 minutes (so a release waiting for merges to settle goes out without another merge), and by hand.
```mermaid
flowchart LR
+43
View File
@@ -0,0 +1,43 @@
"""tools/parity_main.py: the base of a parity-main run, and the bisect after a failure."""
from pathlib import Path
import tempfile
import unittest
from unittest import mock
from tools import parity_main
class ParityMainTests(unittest.TestCase):
def test_first_bad_finds_the_first_failing_merge(self):
commits = list("abcdefgh") # h failed; the base before a passed
for culprit in commits:
tried = []
fails = lambda commit: tried.append(commit) or commit >= culprit
self.assertEqual(parity_main.first_bad(commits, fails), culprit)
self.assertLessEqual(len(tried), 3, "log2 of 8 merges")
self.assertEqual(parity_main.first_bad(["a"], lambda commit: self.fail("nothing to try")), "a")
def test_base_is_the_newest_green_run_head_contains(self):
with tempfile.TemporaryDirectory() as tmp, mock.patch.object(parity_main, "ROOT", Path(tmp)):
git = lambda *arguments: parity_main.git(*arguments).stdout.strip()
git("init", "-q")
for n in range(3):
git("-c", "user.name=t", "-c", "user.email=t@t", "commit", "-q", "--allow-empty", "-m", str(n))
head, parent, grandparent = git("rev-parse", "HEAD"), git("rev-parse", "HEAD^1"), git("rev-parse", "HEAD~2")
git("checkout", "-q", "-b", "side", grandparent)
git("-c", "user.name=t", "-c", "user.email=t@t", "commit", "-q", "--allow-empty", "-m", "side")
side = git("rev-parse", "HEAD")
git("checkout", "-q", head)
self.assertEqual(parity_main.base(runs=[side, grandparent, parent]), grandparent,
"a run on a commit HEAD doesn't contain is skipped")
self.assertEqual(parity_main.base(runs=[]), parent, "no green run yet: the last merge")
self.assertEqual(parity_main.base(runs=[head]), head)
def test_a_harness_a_commit_does_not_have_cannot_fail_there(self):
with mock.patch.object(parity_main.subprocess, "run") as run:
self.assertFalse(parity_main.run_harnesses(["not_a_harness_yet"], 60))
run.assert_not_called()
if __name__ == "__main__":
unittest.main()
+21
View File
@@ -2,6 +2,7 @@ import datetime as dt
from pathlib import Path
import tempfile
import unittest
from unittest import mock
from tools import release_train as train
@@ -147,6 +148,26 @@ class ReleaseTrainTests(unittest.TestCase):
self.assertFalse(train.decision("game", [], NOW, new_line="0.3", blockers=[7])[0])
self.assertTrue(train.decision("game", [pr(1)], NOW, blockers=[])[0])
def test_game_releases_ship_only_what_parity_main_passed(self):
def runs(parity, checks):
def gh_json(*arguments):
table = parity if "parity-main" in arguments else checks
if "--commit" in arguments:
sha = arguments[arguments.index("--commit") + 1]
return [{"status": s, "conclusion": c} for h, s, c in table if h == sha]
return [{"headSha": h, "status": s, "conclusion": c} for h, s, c in table]
return mock.patch.object(train, "gh_json", gh_json)
checks = [("c", "in_progress", ""), ("b", "completed", "success"), ("a", "completed", "success")]
with runs([("c", "queued", ""), ("b", "completed", "cancelled"), ("a", "completed", "success")], checks):
self.assertEqual(train.green_main_head(), "b", "checks alone: the newest green checks")
self.assertEqual(train.green_main_head(parity=True), "a", "a superseded parity-main run counts for nothing")
self.assertTrue(train.passed_on("parity-main", "a"))
self.assertFalse(train.passed_on("parity-main", "b"))
with runs([("b", "completed", "failure"), ("a", "completed", "success")], checks):
self.assertIsNone(train.green_main_head(parity=True), "a failed batch holds releases until fixed")
with runs([("c", "completed", "success")], checks):
self.assertIsNone(train.green_main_head(parity=True), "its checks must pass too")
def test_a_release_is_published_only_after_its_smoke_test_and_with_no_blocker(self):
drew = {"error": None, "frames": 12710, "chunks": 81, "meshed_sections": 550, "player": [160.5, 71.0, 156.5]}
self.assertIsNone(train.gate(drew, []))
+129
View File
@@ -0,0 +1,129 @@
#!/usr/bin/env python3
"""parity-main (.github/workflows/parity-main.yml): the vanilla harnesses run on main, a batch of merges at a time.
python3 tools/parity_main.py base # the commit this run checks from: main's last green parity-main
python3 tools/parity_main.py bisect BASE # after a failure: the first merge since BASE that broke a harness
`base` prints the newest commit on main whose parity-main run passed and that HEAD contains, else HEAD's first parent,
so a run tests every merge since the last green one (`tools/parity.py --changed <base>`), however many landed while
the previous run went on. `bisect` reads the harnesses that failed (.local/parity-runner/last-run.json), checks out
the first-parent merges between BASE and HEAD by halves and runs only those harnesses, then names the first merge they
fail on (written to $GITHUB_STEP_SUMMARY and, with --comment, on its pull request). HEAD is checked out again at the end.
"""
import argparse
import json
import os
from pathlib import Path
import re
import subprocess
import sys
ROOT = Path(__file__).resolve().parents[1]
REPO = os.environ.get("GITHUB_REPOSITORY", "ludovic111/horizon")
LAST_RUN = ROOT / ".local" / "parity-runner" / "last-run.json"
def git(*arguments, check=True):
result = subprocess.run(["git", *arguments], cwd=ROOT, capture_output=True, text=True)
if check and result.returncode:
sys.exit(f"git {' '.join(arguments)}: {result.stderr.strip()}")
return result
def green_runs():
"""Head commits of main's passing parity-main runs, newest first."""
result = subprocess.run(["gh", "run", "list", "--repo", REPO, "--workflow", "parity-main", "--branch", "main",
"--status", "success", "--limit", "30", "--json", "headSha"], capture_output=True, text=True)
if result.returncode:
print(f"note: no parity-main history ({result.stderr.strip()})", file=sys.stderr)
return []
return [run["headSha"] for run in json.loads(result.stdout or "[]")]
def base(head="HEAD", runs=None):
for sha in green_runs() if runs is None else runs:
if git("merge-base", "--is-ancestor", sha, head, check=False).returncode == 0:
return git("rev-parse", sha).stdout.strip()
return git("rev-parse", f"{head}^1").stdout.strip()
def first_bad(commits, fails):
"""The first of commits (oldest first, the last known to fail; the one before them known to pass) where fails()."""
good, bad = -1, len(commits) - 1
while bad - good > 1:
middle = (good + bad) // 2
if fails(commits[middle]):
bad = middle
else:
good = middle
return commits[bad]
def harness_exists(name):
return (ROOT / "tools" / f"test_{name.split('#')[0]}_parity.py").exists()
def run_harnesses(names, timeout):
"""Whether any of the harnesses fails at the checked-out commit (those it doesn't have yet can't)."""
present = [name for name in names if harness_exists(name)]
if not present:
return False
return subprocess.run([sys.executable, "tools/parity.py", *present, "--timeout", str(timeout)], cwd=ROOT).returncode != 0
def bisect(since, timeout, comment):
failed = []
if LAST_RUN.exists():
failed = json.loads(LAST_RUN.read_text(encoding="utf-8")).get("failed") or []
if not failed:
print("No failed harness recorded: nothing to bisect.")
return 0
head = git("rev-parse", "HEAD").stdout.strip()
commits = git("rev-list", "--first-parent", "--reverse", f"{since}..{head}").stdout.split()
if not commits:
print("No merge since the base.")
return 0
def fails(commit):
print(f"--- {commit[:9]} {git('log', '-1', '--format=%s', commit).stdout.strip()}", flush=True)
git("checkout", "-q", "--detach", commit)
return run_harnesses(failed, timeout)
try:
culprit = first_bad(commits, fails) if len(commits) > 1 else commits[0]
finally:
git("checkout", "-q", "--detach", head)
subject = git("log", "-1", "--format=%s", culprit).stdout.strip()
number = re.search(r"Merge pull request #(\d+)", subject)
line = (f"parity-main: {', '.join(failed)} first fail at {culprit[:9]} ({subject}), "
f"of {len(commits)} merges since {since[:9]}.")
print(line)
if os.environ.get("GITHUB_STEP_SUMMARY"):
with open(os.environ["GITHUB_STEP_SUMMARY"], "a", encoding="utf-8") as summary:
summary.write(f"### {line}\n")
if comment and number:
url = f"{os.environ.get('GITHUB_SERVER_URL', 'https://github.com')}/{REPO}/actions/runs/{os.environ.get('GITHUB_RUN_ID', '')}"
body = (f"🤖 Agent: parity-main found that this merge breaks {', '.join(f'`{name}`' for name in failed)} on main "
f"(bisected over {len(commits)} merges: {url}). Releases wait until parity-main passes again.")
subprocess.run(["gh", "pr", "comment", number.group(1), "--repo", REPO, "--body", body])
return 0
def main():
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
commands = parser.add_subparsers(dest="command", required=True)
commands.add_parser("base")
bisecting = commands.add_parser("bisect")
bisecting.add_argument("since", help="the last commit known to pass (the run's base)")
bisecting.add_argument("--timeout", type=int, default=2400, help="seconds per harness")
bisecting.add_argument("--comment", action="store_true", help="comment on the breaking merge's pull request")
args = parser.parse_args()
if args.command == "base":
print(base())
return 0
return bisect(args.since, args.timeout, args.comment)
if __name__ == "__main__":
sys.exit(main())
+26 -8
View File
@@ -414,13 +414,26 @@ def gather(kind, head, releases=None):
return last, prs
def green_main_head():
"""The newest commit on main whose checks passed: what an automatic release builds."""
runs = gh_json("run", "list", "--repo", REPO, "--workflow", "checks", "--branch", "main", "--event", "push",
def passed_on(workflow, sha):
"""Whether the newest finished push run of workflow on main for commit sha passed."""
runs = gh_json("run", "list", "--repo", REPO, "--workflow", workflow, "--branch", "main", "--event", "push",
"--commit", sha, "--limit", "5", "--json", "status,conclusion")
done = [entry for entry in runs if entry["status"] == "completed" and entry["conclusion"] != "cancelled"]
return bool(done) and done[0]["conclusion"] == "success"
def green_main_head(parity=False):
"""The newest commit on main whose checks passed: what an automatic release builds. With parity (game
releases), the newest commit parity-main passed on, if its checks passed too: parity-main runs on batches of
merges, so the commits a run skipped are covered by the next one, and a superseded run counts for nothing."""
workflow = "parity-main" if parity else "checks"
runs = gh_json("run", "list", "--repo", REPO, "--workflow", workflow, "--branch", "main", "--event", "push",
"--limit", "10", "--json", "headSha,status,conclusion")
for entry in runs:
if entry["status"] == "completed":
return entry["headSha"] if entry["conclusion"] == "success" else None
if entry["status"] == "completed" and entry["conclusion"] != "cancelled":
if entry["conclusion"] != "success":
return None
return entry["headSha"] if not parity or passed_on("checks", entry["headSha"]) else None
return None
@@ -437,7 +450,7 @@ def main():
parser.add_argument("--kind", choices=["game", "launcher"], required=True)
parser.add_argument("--head", help="the commit to release (default: the newest commit on main whose checks passed)")
parser.add_argument("--tag", help="notes: the release's tag")
parser.add_argument("--force", action="store_true", help="release even without player-facing changes, before merges settle or while paused")
parser.add_argument("--force", action="store_true", help="release even without player-facing changes, before merges settle, while paused or before parity-main passed")
parser.add_argument("--out", type=Path, help="notes: write title.txt and body.md here")
parser.add_argument("--now", help="the time to decide at (ISO 8601; default now)")
parser.add_argument("--smoke", type=Path, help="gate: the release smoke test's report (smoke-test.json)")
@@ -456,9 +469,12 @@ def main():
summary.write(f"### {line}\n")
return 1 if problem else 0
head = args.head or green_main_head()
# Game releases ship only a commit the vanilla harnesses passed on (parity-main, docs/release-flow.md).
parity = args.kind == "game" and args.command == "decide" and not args.force
head = args.head or green_main_head(parity)
if not head:
result = {"release": False, "reason": "main's latest checks did not pass"}
result = {"release": False, "reason": "main's latest checks did not pass" + (
" or parity-main did not pass on them" if parity else "")}
print(json.dumps(result, indent=1))
write_outputs({"release": "false", "reason": result["reason"]})
return 0
@@ -482,6 +498,8 @@ def main():
blockers = open_blockers() if args.kind == "game" else []
release, reason = decision(args.kind, prs, now, os.environ.get("RELEASES_PAUSED") == "1", args.force, new_line,
blockers)
if release and args.head and parity and not (passed_on("parity-main", head) and passed_on("checks", head)):
release, reason = False, f"waiting for checks and parity-main to pass on {head[:9]}"
minor = any("feature" in pr["labels"] for pr in prs if pr["paths"])
tag = next_game_tag(tags, now.date(), line) if args.kind == "game" else next_launcher_tag(tags, minor, line)
result = {