Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions docs/release-chain.md
Original file line number Diff line number Diff line change
Expand Up @@ -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_<ROLE>_REPOSITORY` to the configured short repository names.
Expand Down
28 changes: 23 additions & 5 deletions scripts/release_fanout_check.py
Original file line number Diff line number Diff line change
Expand Up @@ -296,22 +296,39 @@ 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)
rows = []
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,
Expand All @@ -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")
Expand Down Expand Up @@ -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(),
Expand Down
181 changes: 178 additions & 3 deletions tests/test_release_fanout_check.py
Original file line number Diff line number Diff line change
Expand Up @@ -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)

Expand All @@ -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}
Expand All @@ -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",
Expand Down
Loading