From 5947201b80fd75cfe909f543832cb086266db930 Mon Sep 17 00:00:00 2001 From: luisleo526 Date: Tue, 10 Nov 2026 13:41:17 +0800 Subject: [PATCH] Honor the compute first-pair floor in release fanout checks --- docs/release-chain.md | 1 + scripts/release_fanout_check.py | 28 ++++- tests/test_release_fanout_check.py | 181 ++++++++++++++++++++++++++++- 3 files changed, 202 insertions(+), 8 deletions(-) diff --git a/docs/release-chain.md b/docs/release-chain.md index de5d6ac..e69165f 100644 --- a/docs/release-chain.md +++ b/docs/release-chain.md @@ -337,6 +337,7 @@ receiver run evidence without writes and prints stable JSON followed by a human table for every role. It returns nonzero for an enabled role with a missing delivery, missing receiver run or failed run, and for an unaccounted role; excluded roles are visible and do not require a delivery. +Historical all-consumer probes use `v1.8.0` onward, and compute follows the configured `RELEASE_COMPUTE_FIRST_PAIR` floor. An unavailable receiver API (including a 404) produces a failing role row while the check continues reporting the other roles. Set `RELEASE_TARGET__REPOSITORY` to the configured short repository names. diff --git a/scripts/release_fanout_check.py b/scripts/release_fanout_check.py index fb1afa7..ed63ec9 100644 --- a/scripts/release_fanout_check.py +++ b/scripts/release_fanout_check.py @@ -296,7 +296,16 @@ def check_release(hub_client, receiver_client, tag, *, roles=None, excluded=None excluded = pipeline.excluded_roles() roles = list(roles) excluded = list(excluded) - enabled = set(roles) + selected = set(roles) + compute_first_pair = None + first = os.environ.get("RELEASE_COMPUTE_FIRST_PAIR", "") + if "compute" in selected and first: + try: + compute_first_pair = pipeline.version(first) + except ValueError: + raise pipeline.ConfigurationError( + "RELEASE_COMPUTE_FIRST_PAIR value was not accepted") from None + enabled = set(pipeline.delivery_roles(tag.removeprefix("v"), roles, compute_first_pair)) excluded_set = set(excluded) targets = {} if targets is None else dict(targets) budget = ApiBudget(RECEIVER_CHECK_API_CALL_BUDGET) @@ -304,14 +313,22 @@ def check_release(hub_client, receiver_client, tag, *, roles=None, excluded=None for role in ROLES: target = targets.get(role, os.environ.get(TARGET_ENVIRONMENT[role], "")) public_target = PUBLIC_RECEIVER_REPOSITORIES.get(role) == target - accounted = role in enabled or role in excluded_set + accounted = role in selected or role in excluded_set if role not in enabled: + disabled = role == "compute" and role in selected + reason = ("excluded by configuration" if role in excluded_set + else "role is not accounted for") + if disabled: + reason = ("compute first-pair policy: RELEASE_COMPUTE_FIRST_PAIR is unset" + if compute_first_pair is None else + "compute first-pair policy: release " + tag + + " is below RELEASE_COMPUTE_FIRST_PAIR=" + first) rows.append({ "role": role, "enabled": False, "excluded": role in excluded_set, "accounted": accounted, - "ok": role in excluded_set, + "ok": disabled or role in excluded_set, "repository": None, "dispatched": False, "receiver_run_found": False, @@ -320,7 +337,7 @@ def check_release(hub_client, receiver_client, tag, *, roles=None, excluded=None "conclusion": None, "url": None, "event_id_match": None, - "error": "excluded by configuration" if role in excluded_set else "role is not accounted for", + "error": reason, }) continue delivery = release_asset(hub_client, release, f"delivery-{role}.json") @@ -384,7 +401,8 @@ def render_human(report): "role | state | repository | dispatched | receiver_run | conclusion | url | error", ] for row in report.get("roles", []): - state = "enabled" if row.get("enabled") else "excluded" if row.get("excluded") else "unaccounted" + state = ("enabled" if row.get("enabled") else "excluded" if row.get("excluded") + else "disabled" if row.get("accounted") else "unaccounted") lines.append("{} | {} | {} | {} | {} | {} | {} | {}".format( row.get("role", ""), state, row.get("repository") or "-", str(row.get("dispatched", False)).lower(), diff --git a/tests/test_release_fanout_check.py b/tests/test_release_fanout_check.py index c08dd79..4c2573d 100644 --- a/tests/test_release_fanout_check.py +++ b/tests/test_release_fanout_check.py @@ -65,7 +65,7 @@ def __init__(self, release, assets): def api(self, route): self.routes.append(route) - if route == f"repos/{contract.HUB}/releases/tags/{TAG}": + if route == f"repos/{contract.HUB}/releases/tags/{self.release['tag_name']}": return copy.deepcopy(self.release) raise AssertionError("unexpected hub route: " + route) @@ -75,10 +75,10 @@ def request(self, url, **kwargs): return self.assets[asset_id] -def release_with_delivery(roles=("hosted",)): +def release_with_delivery(roles=("hosted",), *, tag=TAG): ready = contract.canonical({"event_id": EVENT_ID, "timestamp": DISPATCHED_AT}) release = { - "tag_name": TAG, "draft": False, + "tag_name": tag, "draft": False, "assets": [{"id": 1, "name": "release-ready.json", "state": "uploaded"}], } assets = {1: ready} @@ -95,6 +95,181 @@ def release_with_delivery(roles=("hosted",)): class ReleaseFanoutCheckTests(unittest.TestCase): + def setUp(self): + # Existing receiver-evidence fixtures need an eligible compute pair. + # The floor-policy targets below supply their own complete environment. + floor = patch.dict(os.environ, {"RELEASE_COMPUTE_FIRST_PAIR": TAG.removeprefix("v")}) + floor.start() + self.addCleanup(floor.stop) + + def test_selected_compute_below_first_pair_is_disabled_without_receiver_calls(self): + delivered = [role for role in contract.ROLES if role != "compute"] + targets = {role: "fixture-" + role for role in contract.ROLES} + for tag in ("v2.9.9", "v2.10.0-rc.1"): + with self.subTest(tag=tag), patch.dict(os.environ, { + "RELEASE_READY_CONSUMERS": ",".join(contract.ROLES), + "RELEASE_READY_EXCLUDE": "", + "RELEASE_COMPUTE_FIRST_PAIR": "2.10.0", + }, clear=True): + hub = release_with_delivery(delivered, tag=tag) + receiver = ReceiverClient([receiver_run(conclusion="success", event_id=EVENT_ID)]) + report = fanout.check_release(hub, receiver, tag, targets=targets) + rows = {row["role"]: row for row in report["roles"]} + compute = rows["compute"] + self.assertEqual(list(rows), list(contract.ROLES)) + self.assertTrue(report["ok"]) + self.assertEqual(report["excluded"], []) + self.assertFalse(compute["enabled"]) + self.assertFalse(compute["excluded"]) + self.assertTrue(compute["accounted"]) + self.assertTrue(compute["ok"]) + self.assertFalse(compute["dispatched"]) + self.assertFalse(compute["receiver_run_found"]) + for field in ("repository", "run_id", "status", "conclusion", "url", "event_id_match"): + self.assertIsNone(compute[field]) + self.assertIn("first-pair policy", compute["error"]) + self.assertIn("RELEASE_COMPUTE_FIRST_PAIR", compute["error"]) + self.assertIn("compute | disabled |", fanout.render_human(report)) + for role in delivered: + self.assertTrue(rows[role]["enabled"]) + self.assertTrue(rows[role]["ok"]) + self.assertTrue(rows[role]["receiver_run_found"]) + self.assertEqual(len(receiver.routes), len(delivered)) + self.assertFalse(any("/fixture-compute/" in route for route in receiver.routes)) + + def test_selected_compute_at_or_above_first_pair_requires_delivery_and_receiver(self): + excluded = [role for role in contract.ROLES if role != "compute"] + outcomes = { + "success": None, + "missing delivery": "delivery asset missing", + "failed delivery": "delivery asset identity differs", + "missing receiver": "receiver run missing", + "failed receiver": "receiver run concluded failure", + } + for tag in ("v2.10.0", "v2.11.0"): + for outcome, expected_error in outcomes.items(): + with self.subTest(tag=tag, outcome=outcome), patch.dict(os.environ, { + "RELEASE_READY_CONSUMERS": "compute", + "RELEASE_READY_EXCLUDE": ",".join(excluded), + "RELEASE_COMPUTE_FIRST_PAIR": "2.10.0", + }, clear=True): + hub = release_with_delivery( + [] if outcome == "missing delivery" else ["compute"], tag=tag) + if outcome == "failed delivery": + delivery = contract.decode(hub.assets[2]) + delivery["state"] = "failed" + hub.assets[2] = contract.canonical(delivery) + run = receiver_run( + conclusion="failure" if outcome == "failed receiver" else "success", + event_id=EVENT_ID, workflow="release-pair") + receiver = ReceiverClient([] if outcome == "missing receiver" else [run]) + report = fanout.check_release( + hub, receiver, tag, targets={"compute": "fixture-compute"}) + compute = next(row for row in report["roles"] if row["role"] == "compute") + dispatched = outcome not in ("missing delivery", "failed delivery") + found = outcome in ("success", "failed receiver") + self.assertEqual(report["ok"], outcome == "success") + self.assertEqual(report["excluded"], excluded) + self.assertTrue(compute["enabled"]) + self.assertFalse(compute["excluded"]) + self.assertTrue(compute["accounted"]) + self.assertEqual(compute["ok"], outcome == "success") + self.assertEqual(compute["dispatched"], dispatched) + self.assertEqual(compute["receiver_run_found"], found) + self.assertEqual(compute["run_id"], run["id"] if found else None) + self.assertEqual(compute["error"], expected_error) + self.assertEqual(len(receiver.routes), 1 if dispatched else 0) + if found: + self.assertEqual(compute["event_id_match"], "exact") + + for first in ("v2.10.0", "not-semver", " "): + with self.subTest(malformed_floor=first), patch.dict(os.environ, { + "RELEASE_READY_CONSUMERS": "compute", + "RELEASE_READY_EXCLUDE": ",".join(excluded), + "RELEASE_COMPUTE_FIRST_PAIR": first, + }, clear=True): + hub = release_with_delivery(["compute"], tag="v2.11.0") + receiver = ReceiverClient([receiver_run( + conclusion="success", event_id=EVENT_ID, workflow="release-pair")]) + with self.assertRaisesRegex( + fanout.pipeline.ConfigurationError, + "^RELEASE_COMPUTE_FIRST_PAIR value was not accepted$"): + fanout.check_release( + hub, receiver, "v2.11.0", targets={"compute": "fixture-compute"}) + self.assertEqual(receiver.routes, []) + self.assertNotIn( + f"https://api.github.com/repos/{contract.HUB}/releases/assets/2", hub.routes) + + def test_selected_compute_without_first_pair_is_disabled_even_with_stale_delivery(self): + excluded = [role for role in contract.ROLES if role != "compute"] + for first in (None, ""): + environment = { + "RELEASE_READY_CONSUMERS": "compute", + "RELEASE_READY_EXCLUDE": ",".join(excluded), + } + if first is not None: + environment["RELEASE_COMPUTE_FIRST_PAIR"] = first + with self.subTest(first=first), patch.dict(os.environ, environment, clear=True): + hub = release_with_delivery(["compute"], tag="v99.0.0") + receiver = ReceiverClient([receiver_run( + conclusion="success", event_id=EVENT_ID, workflow="release-pair")]) + report = fanout.check_release( + hub, receiver, "v99.0.0", targets={"compute": "fixture-compute"}) + compute = next(row for row in report["roles"] if row["role"] == "compute") + self.assertTrue(report["ok"]) + self.assertEqual(report["excluded"], excluded) + self.assertFalse(compute["enabled"]) + self.assertFalse(compute["excluded"]) + self.assertTrue(compute["accounted"]) + self.assertTrue(compute["ok"]) + self.assertFalse(compute["dispatched"]) + self.assertFalse(compute["receiver_run_found"]) + for field in ("repository", "run_id", "status", "conclusion", "url", "event_id_match"): + self.assertIsNone(compute[field]) + self.assertIn("first-pair policy", compute["error"]) + self.assertIn("RELEASE_COMPUTE_FIRST_PAIR", compute["error"]) + self.assertIn("unset", compute["error"]) + self.assertIn("compute | disabled |", fanout.render_human(report)) + self.assertEqual(receiver.routes, []) + self.assertNotIn( + f"https://api.github.com/repos/{contract.HUB}/releases/assets/2", hub.routes) + + def test_unselected_compute_preserves_exclusion_or_missing_accounting_above_floor(self): + for compute_excluded in (True, False): + excluded = [ + role for role in contract.ROLES + if role != "hosted" and (role != "compute" or compute_excluded) + ] + with self.subTest(compute_excluded=compute_excluded), patch.dict(os.environ, { + "RELEASE_READY_CONSUMERS": "hosted", + "RELEASE_READY_EXCLUDE": ",".join(excluded), + "RELEASE_COMPUTE_FIRST_PAIR": "2.10.0", + }, clear=True): + hub = release_with_delivery(["hosted", "compute"], tag="v99.0.0") + receiver = ReceiverClient([receiver_run(conclusion="success", event_id=EVENT_ID)]) + report = fanout.check_release( + hub, receiver, "v99.0.0", + targets={"hosted": "fixture-hosted", "compute": "fixture-compute"}) + rows = {row["role"]: row for row in report["roles"]} + compute = rows["compute"] + self.assertEqual(report["ok"], compute_excluded) + self.assertEqual(report["excluded"], excluded) + self.assertTrue(rows["hosted"]["ok"]) + self.assertFalse(compute["enabled"]) + self.assertEqual(compute["excluded"], compute_excluded) + self.assertEqual(compute["accounted"], compute_excluded) + self.assertEqual(compute["ok"], compute_excluded) + self.assertFalse(compute["dispatched"]) + self.assertFalse(compute["receiver_run_found"]) + self.assertIsNone(compute["run_id"]) + self.assertEqual( + compute["error"], + "excluded by configuration" if compute_excluded else "role is not accounted for") + self.assertEqual(len(receiver.routes), 1) + self.assertIn("/fixture-hosted/", receiver.routes[0]) + self.assertNotIn( + f"https://api.github.com/repos/{contract.HUB}/releases/assets/3", hub.routes) + def test_configuration_preserves_explicit_dispatch_selection(self): with patch.dict(os.environ, { "RELEASE_READY_CONSUMERS": "hosted",