diff --git a/.github/runners.json b/.github/runners.json index 8ec79e0702e5..39dcbacca97d 100644 --- a/.github/runners.json +++ b/.github/runners.json @@ -65,9 +65,9 @@ "Only a pool marked hosted may name a GitHub-hosted label, and it says why." ], "linux": { - "why": "Every Linux job: the runner set's Blacksmith sizes (Leo, 2026-10-28: \"just pin the set of the shit that isn't hilariously slow\")", + "why": "Every Linux job: the runner set's Blacksmith sizes (Leo, 2026-10-28: \"just pin the set of the shit that isn't hilariously slow\"), smallest first. Blacksmith now caps us on vCPUs at once, so a 32 vCPU job holds the room of eight 4 vCPU jobs, and on 2026-10-31 the live member was 32 vCPU: 106,443 jobs and 193,021 billed minutes (about $12.4k of $19.3k) ran there, most of them checks under a minute (pr-perf-section-check 2,940 runs at 0.1 min). A stalled 4 vCPU moves the pool to 16 vCPU; 8 vCPU is not a member because the bounded selectors (vars.LINUX_RUNNER in 4/16/32, else 4) would send its readers back to 4 (Leo, 2026-11-01: \"we clearly are not able to use them. so we should have resized a long-ass time ago.\"). A job that needs more cores names its size, not this pool", "members": [ - "blacksmith-32vcpu-ubuntu-2404", + "blacksmith-4vcpu-ubuntu-2404", "blacksmith-16vcpu-ubuntu-2404" ] }, diff --git a/.github/workflows/ci-cloud-overflow-probe.yml b/.github/workflows/ci-cloud-overflow-probe.yml index b57e145e4284..00a4bea60047 100644 --- a/.github/workflows/ci-cloud-overflow-probe.yml +++ b/.github/workflows/ci-cloud-overflow-probe.yml @@ -69,7 +69,7 @@ jobs: strategy: fail-fast: false matrix: - label: ${{ fromJSON(github.event_name == 'workflow_dispatch' && inputs.probe_label != '' && format('["{0}"]', inputs.probe_label) || '["blacksmith-32vcpu-ubuntu-2404", "blacksmith-16vcpu-ubuntu-2404"]') }} + label: ${{ fromJSON(github.event_name == 'workflow_dispatch' && inputs.probe_label != '' && format('["{0}"]', inputs.probe_label) || '["blacksmith-4vcpu-ubuntu-2404", "blacksmith-16vcpu-ubuntu-2404"]') }} runs-on: ${{ github.repository_owner != 'manaflow-ai' && 'ubuntu-24.04' || matrix.label }} timeout-minutes: 2 permissions: {} diff --git a/docs/ci-runners.md b/docs/ci-runners.md index a0e1dc389d6d..c74a897aa691 100644 --- a/docs/ci-runners.md +++ b/docs/ci-runners.md @@ -1056,8 +1056,8 @@ on a dead pool needs force-cancel and then rerun. Blacksmith is overflow, so when it stops starting jobs the fix is to stop sending overflow there, not to reroute a lane. `ci-cloud-overflow-probe.yml` does that automatically (`scripts/ci/cloud_overflow_switch.py`). Every 10 -minutes its `probe` jobs ask for each Blacksmith Linux size compiles run on -(`PROBE_LABELS`: `blacksmith-32vcpu-ubuntu-2404` and +minutes its `probe` jobs ask for each member of the linux pool +(`PROBE_LABELS`: `blacksmith-4vcpu-ubuntu-2404` and `blacksmith-16vcpu-ubuntu-2404`, one matrix job each) and print a line, and its `watch` job waits for them. Never one label: on 2026-10-28 the 4 vCPU label alone stalled four times while the other sizes started jobs, and each diff --git a/scripts/ci/cloud_overflow_switch.py b/scripts/ci/cloud_overflow_switch.py index abd107f04836..efcc96be2b50 100644 --- a/scripts/ci/cloud_overflow_switch.py +++ b/scripts/ci/cloud_overflow_switch.py @@ -9,7 +9,7 @@ variables at the owned pools and GitHub-hosted Linux by hand. ci-cloud-overflow-probe.yml runs this every 10 minutes. Its `probe` jobs ask -for each Blacksmith Linux size in PROBE_LABELS (32 and 16 vCPU), one job per +for each Blacksmith Linux size in PROBE_LABELS (4 and 16 vCPU), one job per label, and only print a line. This script, in the `watch` job on Blacksmith macOS, waits for them: @@ -88,21 +88,22 @@ OVERRIDES_VARIABLE = "CI_CLOUD_FAILOVER" PAID_OVERFLOW_VARIABLE = "CI_PAID_MACOS_OVERFLOW" CLOUD_PREFIX = pr_runner_pool.EPHEMERAL_PREFIX # "blacksmith-" -# What the probe asks for: the Blacksmith Linux sizes compiles run on, every -# one of them (the workflow's probe matrix restates this). Overflow goes off +# What the probe asks for: every member of the linux pool in .github/runners.json +# (tests/test_ci_runner_pools.py; the workflow's probe matrix restates this). Overflow goes off # only when none of them starts its probe; one that starts means Blacksmith # serves. A single probed label is a pin: on 2026-10-28 the 4 vCPU label # alone queued past 5 minutes at 21:59Z, 22:13Z, 22:53Z and 23:30Z while the # other sizes started jobs, and each time the whole fleet failed over. -PROBE_LABELS = ("blacksmith-32vcpu-ubuntu-2404", "blacksmith-16vcpu-ubuntu-2404") +PROBE_LABELS = ("blacksmith-4vcpu-ubuntu-2404", "blacksmith-16vcpu-ubuntu-2404") # Where Linux overflow goes while the probed label stalls: another Blacksmith # Linux size, never GitHub-hosted Ubuntu. CI_TRUSTED_RUNNER's readers accept # only ubuntu-24.04 and the 2 and 4 vCPU labels (docs/ci-runners.md), so it # takes 2 vCPU. LINUX_FAILOVER = "blacksmith-16vcpu-ubuntu-2404" TRUSTED_FAILOVER = "blacksmith-2vcpu-ubuntu-2404" -# When the probed label is that failover itself, the next size over. -ALTERNATE_FAILOVERS = {LINUX_FAILOVER: "blacksmith-32vcpu-ubuntu-2404", +# When the probed label is that failover itself, the other size: a probed one, so +# toward_started() can pick it, and one the bounded LINUX_RUNNER selectors accept. +ALTERNATE_FAILOVERS = {LINUX_FAILOVER: "blacksmith-4vcpu-ubuntu-2404", TRUSTED_FAILOVER: "blacksmith-4vcpu-ubuntu-2404"} # The only Blacksmith labels CI_TRUSTED_RUNNER's readers accept. TRUSTED_BLACKSMITH_LABELS = frozenset({"blacksmith-2vcpu-ubuntu-2404", "blacksmith-4vcpu-ubuntu-2404"}) @@ -304,8 +305,9 @@ def plan_on(record: Mapping[str, Any], current: Mapping[str, str | None], With `started` (the labels whose probes started in this run), a Linux variable goes back only onto a label whose probe started: an older - record's before (blacksmith-4vcpu-ubuntu-2404 from when that one label was - the probe, or unset, whose readers fall back to an unprobed literal) may + record's before (a size no longer probed, such as blacksmith-32vcpu-ubuntu-2404 + before the linux pool went smallest first, or unset, whose readers fall back + to an unprobed literal) may still be stalled, and once the record is deleted nothing would see it. Such a variable stays where it is. A GitHub-hosted label is never put back. """ diff --git a/tests/test_ci_cloud_overflow_switch.py b/tests/test_ci_cloud_overflow_switch.py index 85015d9274f3..62e9637e5ad8 100644 --- a/tests/test_ci_cloud_overflow_switch.py +++ b/tests/test_ci_cloud_overflow_switch.py @@ -390,7 +390,7 @@ def test_probe_minutes_are_clamped(self) -> None: def test_the_probe_set_is_the_compile_sizes(self) -> None: # Never one label: one stalled size must not flip the fleet (Leo's no-pins order, 2026-10-28). - self.assertEqual(switch.PROBE_LABELS, ("blacksmith-32vcpu-ubuntu-2404", "blacksmith-16vcpu-ubuntu-2404")) + self.assertEqual(switch.PROBE_LABELS, ("blacksmith-4vcpu-ubuntu-2404", "blacksmith-16vcpu-ubuntu-2404")) def test_stuck_job_needs_a_blacksmith_label_and_the_wait(self) -> None: jobs = [ @@ -460,8 +460,8 @@ def test_a_stall_writes_the_record_first_then_the_failovers_then_moves_stuck_run self.assertIn("merge_group run", summary) def test_a_started_probe_restores_and_deletes_the_record(self) -> None: - record = {"since": ago(60), "probe": "blacksmith-4vcpu-ubuntu-2404", "changed": { - "LINUX_RUNNER": {"before": "blacksmith-4vcpu-ubuntu-2404", "after": "blacksmith-16vcpu-ubuntu-2404"}, + record = {"since": ago(60), "probe": "blacksmith-32vcpu-ubuntu-2404", "changed": { + "LINUX_RUNNER": {"before": "blacksmith-32vcpu-ubuntu-2404", "after": "blacksmith-16vcpu-ubuntu-2404"}, "CI_PAID_MACOS_OVERFLOW": {"before": None, "after": "1"}, "MACOS_RUNNER_PR": {"before": "blacksmith-6vcpu-macos-26", "after": "glaeda-std-xcode-26.6"}}} env = {"VAR_CI_CLOUD_OVERFLOW_SAVED": json.dumps(record), "VAR_LINUX_RUNNER": "blacksmith-16vcpu-ubuntu-2404", @@ -471,17 +471,17 @@ def test_a_started_probe_restores_and_deletes_the_record(self) -> None: code, out, summary = run_main(env, actions, writer) self.assertEqual(code, 0) self.assertIn("outcome=started", out) - # Review of this change: 4 vCPU is not probed and may still be stalled, so LINUX_RUNNER stays on - # the 16 vCPU size whose probe started rather than going back to a label nobody watches. + # Review of this change: 32 vCPU is no longer probed and may still be stalled, so LINUX_RUNNER stays + # on the 16 vCPU size whose probe started rather than going back to a label nobody watches. self.assertEqual(writer.writes, [("CI_PAID_MACOS_OVERFLOW", None), ("CI_CLOUD_OVERFLOW_SAVED", None)]) - self.assertIn("stays blacksmith-16vcpu-ubuntu-2404; its value before, blacksmith-4vcpu-ubuntu-2404", summary) + self.assertIn("stays blacksmith-16vcpu-ubuntu-2404; its value before, blacksmith-32vcpu-ubuntu-2404", summary) self.assertIn("left alone", summary) # A before that is a probed size goes back as before. restores = switch.plan_on({"changed": {"LINUX_RUNNER": { - "before": "blacksmith-32vcpu-ubuntu-2404", "after": "blacksmith-16vcpu-ubuntu-2404"}}}, + "before": "blacksmith-4vcpu-ubuntu-2404", "after": "blacksmith-16vcpu-ubuntu-2404"}}}, {"LINUX_RUNNER": "blacksmith-16vcpu-ubuntu-2404"}, switch.PROBE_LABELS) self.assertEqual([(r.name, r.value, r.skipped) for r in restores], - [("LINUX_RUNNER", "blacksmith-32vcpu-ubuntu-2404", "")]) + [("LINUX_RUNNER", "blacksmith-4vcpu-ubuntu-2404", "")]) self.assertEqual(actions.calls, []) def test_a_stalled_record_finishes_a_partial_switch(self) -> None: @@ -566,10 +566,10 @@ def test_a_linux_failover_names_only_a_size_that_started(self) -> None: self.assertEqual(switch.toward_started({"LINUX_RUNNER": "blacksmith-16vcpu-ubuntu-2404", "MACOS_RUNNER_PR": "glaeda-std-xcode-26.6"}, []), {"MACOS_RUNNER_PR": "glaeda-std-xcode-26.6"}) - # Only 32 vCPU started: the chain moves on to it. + # Only 4 vCPU started: the chain moves on to it. self.assertEqual(switch.toward_started({"LINUX_RUNNER": "blacksmith-16vcpu-ubuntu-2404"}, - ["blacksmith-32vcpu-ubuntu-2404"]), - {"LINUX_RUNNER": "blacksmith-32vcpu-ubuntu-2404"}) + ["blacksmith-4vcpu-ubuntu-2404"]), + {"LINUX_RUNNER": "blacksmith-4vcpu-ubuntu-2404"}) self.assertEqual(switch.toward_started({"LINUX_RUNNER": "blacksmith-16vcpu-ubuntu-2404"}, switch.PROBE_LABELS), {"LINUX_RUNNER": "blacksmith-16vcpu-ubuntu-2404"}) @@ -584,7 +584,9 @@ def test_one_stalled_size_changes_nothing(self) -> None: stalled = probe_job(6) started = {**probe_job(6, runner_name="bs-1", status="in_progress"), "name": switch.probe_job_name(switch.PROBE_LABELS[1])} - self.assertEqual(switch.probe_set_outcome([stalled, started], switch.PROBE_LABELS, NOW, 5), + # Every size but the first starts. + rest = [{**started, "name": switch.probe_job_name(label)} for label in switch.PROBE_LABELS[1:]] + self.assertEqual(switch.probe_set_outcome([stalled, *rest], switch.PROBE_LABELS, NOW, 5), ("partial", [switch.PROBE_LABELS[0]])) self.assertEqual(switch.probe_set_outcome([stalled], switch.PROBE_LABELS, NOW, 5), ("waiting", [switch.PROBE_LABELS[0]])) @@ -600,16 +602,16 @@ def test_one_stalled_size_changes_nothing(self) -> None: env = {"VAR_CI_CLOUD_OVERFLOW_SAVED": json.dumps(record), "VAR_MACOS_RUNNER_PR": "glaeda-std-xcode-26.6", "VAR_CMUX_CI_XCODE_APP_PR": PIN} writer = FakeSwitch() - code, out, _ = run_main(env, FakeActions([stalled, started]), writer) + code, out, _ = run_main(env, FakeActions([stalled, *rest]), writer) self.assertEqual((code, writer.writes), (0, [])) self.assertIn("outcome=partial", out) # Nor does it turn overflow off when there is no record. writer = FakeSwitch() - code, out, _ = run_main(BLACKSMITH_STEADY, FakeActions([stalled, started]), writer) + code, out, _ = run_main(BLACKSMITH_STEADY, FakeActions([stalled, *rest]), writer) self.assertEqual((code, writer.writes), (0, [])) # Per-label health is written either way, for the pool reconciler to read. self.assertEqual(writer.health[-1]["labels"], {switch.PROBE_LABELS[0]: "stalled", - switch.PROBE_LABELS[1]: "started"}) + **{label: "started" for label in switch.PROBE_LABELS[1:]}}) self.assertEqual(writer.health[-1]["run"], "https://github.com/manaflow-ai/cmux/actions/runs/1") # Every size started: the record is put back and deleted. writer = FakeSwitch() @@ -624,22 +626,23 @@ def test_a_partial_result_writes_nothing_but_health(self) -> None: stalled = probe_job(6) started = {**probe_job(6, runner_name="bs-1", status="in_progress"), "name": switch.probe_job_name(switch.PROBE_LABELS[1])} - env = {"VAR_LINUX_RUNNER": "blacksmith-32vcpu-ubuntu-2404", "VAR_MACOS_RUNNER_PR": "blacksmith-6vcpu-macos-26", + rest = [{**started, "name": switch.probe_job_name(label)} for label in switch.PROBE_LABELS[1:]] + env = {"VAR_LINUX_RUNNER": "blacksmith-4vcpu-ubuntu-2404", "VAR_MACOS_RUNNER_PR": "blacksmith-6vcpu-macos-26", "VAR_CMUX_CI_XCODE_APP_PR": PIN} writer = FakeSwitch() - code, out, _ = run_main(env, FakeActions([stalled, started]), writer) + code, out, _ = run_main(env, FakeActions([stalled, *rest]), writer) self.assertEqual((code, writer.writes), (0, [])) self.assertIn("outcome=partial", out) self.assertEqual(writer.health[-1]["labels"][switch.PROBE_LABELS[0]], "stalled") def test_a_restore_goes_back_only_onto_a_size_that_started(self) -> None: - # Review at 437df955: a legacy CI_TRUSTED_RUNNER record (before 4 vCPU, never probed). + # Review at 437df955: a legacy CI_TRUSTED_RUNNER record (before a size that is not probed). record = {"changed": { - "CI_TRUSTED_RUNNER": {"before": "blacksmith-4vcpu-ubuntu-2404", "after": "blacksmith-2vcpu-ubuntu-2404"}, + "CI_TRUSTED_RUNNER": {"before": "blacksmith-2vcpu-ubuntu-2404", "after": "blacksmith-4vcpu-ubuntu-2404"}, "LINUX_RUNNER": {"before": None, "after": "blacksmith-16vcpu-ubuntu-2404"}, "MACOS_RUNNER_PR": {"before": "blacksmith-6vcpu-macos-26", "after": "glaeda-std-xcode-26.6"}, "MACOS_RUNNER_15": {"before": "macos-15", "after": "glaeda-std-xcode-26.6"}}} - current = {"CI_TRUSTED_RUNNER": "blacksmith-2vcpu-ubuntu-2404", "LINUX_RUNNER": "blacksmith-16vcpu-ubuntu-2404", + current = {"CI_TRUSTED_RUNNER": "blacksmith-4vcpu-ubuntu-2404", "LINUX_RUNNER": "blacksmith-16vcpu-ubuntu-2404", "MACOS_RUNNER_PR": "glaeda-std-xcode-26.6", "MACOS_RUNNER_15": "glaeda-std-xcode-26.6"} restores = {r.name: r for r in switch.plan_on(record, current, switch.PROBE_LABELS)} self.assertTrue(restores["CI_TRUSTED_RUNNER"].skipped) diff --git a/tests/test_ci_fork_runner_routing.py b/tests/test_ci_fork_runner_routing.py index 2a51fb33433e..a506f11b2e9e 100644 --- a/tests/test_ci_fork_runner_routing.py +++ b/tests/test_ci_fork_runner_routing.py @@ -1404,8 +1404,12 @@ def test_the_bounded_selector_yields_only_its_labels_for_any_value(self) -> None self.assertEqual(evaluate_runs_on(tree, {"github.repository_owner": "manaflow-ai", "vars.LINUX_RUNNER": "glaeda-std-xcode-26.6"}), "blacksmith-4vcpu-ubuntu-2404") + # Each is a declared Blacksmith Linux label: a linux pool member, or a literal listed for + # actionlint (32 vCPU left the pool on 2026-11-01 but stays a size jobs may name). + declared = (ROOT / ".github/runners.json").read_text(encoding="utf-8") + \ + (ROOT / ".github/actionlint.yaml").read_text(encoding="utf-8") for label in BOUNDED_LINUX_LABELS: - self.assertIn(label, (ROOT / ".github/runners.json").read_text(encoding="utf-8")) + self.assertIn(label, declared) def test_the_app_key_runner_rule_refuses_a_variable(self) -> None: fork = "github.repository_owner != 'manaflow-ai' && 'ubuntu-24.04' || " diff --git a/tests/test_ci_runner_pools.py b/tests/test_ci_runner_pools.py index ddc880ff73dc..ad00f7d3620d 100644 --- a/tests/test_ci_runner_pools.py +++ b/tests/test_ci_runner_pools.py @@ -6,6 +6,7 @@ import copy import datetime as dt import json +import re import sys import tempfile import unittest @@ -44,8 +45,23 @@ def test_the_declared_pools_are_valid(self) -> None: def test_the_linux_pool_is_the_runner_set(self) -> None: # Leo, 2026-10-28: "just pin the set of the shit that isn't hilariously slow". + # Smallest first: Blacksmith caps vCPUs at once, so the live member is the small size (2026-11-01). self.assertEqual(runner_pools.load_pools()["linux"]["members"], - ["blacksmith-32vcpu-ubuntu-2404", "blacksmith-16vcpu-ubuntu-2404"]) + ["blacksmith-4vcpu-ubuntu-2404", "blacksmith-16vcpu-ubuntu-2404"]) + + def test_every_bounded_selector_accepts_every_linux_member(self) -> None: + # Review of #30340: a member a bounded selector refuses (contains([...], vars.LINUX_RUNNER) && ... || '<4 vCPU>') + # sends its readers back to the stalled size when the pool steps onto it. + selector = re.compile(r"contains\(fromJSON\('(\[[^']*\])'\), (?:vars\.LINUX_RUNNER|fromJSON\(vars\.RUNNER_POOLS[^)]*\)\.linux)\)" + r" && (?:vars\.LINUX_RUNNER|fromJSON\(vars\.RUNNER_POOLS[^)]*\)\.linux) \|\| '(blacksmith-4vcpu-ubuntu-2404)'") + members = runner_pools.load_pools()["linux"]["members"] + found = 0 + for workflow in sorted((ROOT / ".github/workflows").glob("*.y*ml")): + for match in selector.finditer(workflow.read_text(encoding="utf-8")): + found += 1 + with self.subTest(workflow=workflow.name): + self.assertLessEqual(set(members), set(json.loads(match.group(1)))) + self.assertGreater(found, 0) def test_no_pool_names_a_reused_machine(self) -> None: # A job reading a pool, a fork's pull request included, never lands on an owned Mac: @@ -269,8 +285,8 @@ def set_variable(self, name, value): def test_a_stalled_size_flips_linux_once(self) -> None: switch = self.Switch({runner_pools.HEALTH_VARIABLE: json.dumps(health({ - "blacksmith-32vcpu-ubuntu-2404": "stalled", "blacksmith-16vcpu-ubuntu-2404": "started"})), - "LINUX_RUNNER": "blacksmith-32vcpu-ubuntu-2404"}) + "blacksmith-4vcpu-ubuntu-2404": "stalled", "blacksmith-16vcpu-ubuntu-2404": "started"})), + "LINUX_RUNNER": "blacksmith-4vcpu-ubuntu-2404"}) with tempfile.TemporaryDirectory() as tmp: env = {"RUNNER_POOLS": "", "GITHUB_STEP_SUMMARY": f"{tmp}/summary"} self.assertEqual(runner_pools.main([], env, api=self.Api(RECORDED), switch=switch, now=NOW), 0) @@ -281,14 +297,15 @@ def test_a_stalled_size_flips_linux_once(self) -> None: self.assertEqual(mirrored, ("LINUX_RUNNER", "blacksmith-16vcpu-ubuntu-2404")) def test_linux_runner_on_a_size_outside_the_set_follows_the_pool(self) -> None: - # 2026-10-31: RUNNER_POOLS.linux was live but LINUX_RUNNER still named the stalled 4 vCPU size. - pools = {"linux": "blacksmith-32vcpu-ubuntu-2404"} + # 2026-10-31: RUNNER_POOLS.linux was live but LINUX_RUNNER still named a size outside the pool + # (then the stalled 4 vCPU size; since the pool went smallest first, 32 vCPU). + pools = {"linux": "blacksmith-4vcpu-ubuntu-2404"} current, _ = runner_pools.parse_value(json.dumps(pools), runner_pools.load_pools()) value, _ = runner_pools.reconcile(current, runner_pools.load_pools(), dead_now=(), served_now=(), now=NOW) env = {"RUNNER_POOLS": runner_pools.render(value)} - switch = self.Switch({"LINUX_RUNNER": "blacksmith-4vcpu-ubuntu-2404"}) + switch = self.Switch({"LINUX_RUNNER": "blacksmith-32vcpu-ubuntu-2404"}) self.assertEqual(runner_pools.main([], env, api=self.Api(None), switch=switch, now=NOW), 0) - self.assertEqual(switch.writes, [("LINUX_RUNNER", "blacksmith-32vcpu-ubuntu-2404")]) + self.assertEqual(switch.writes, [("LINUX_RUNNER", "blacksmith-4vcpu-ubuntu-2404")]) def test_linux_runner_is_left_to_the_overflow_switch_and_to_a_deliberate_value(self) -> None: value = {"linux": "blacksmith-32vcpu-ubuntu-2404"} @@ -315,8 +332,8 @@ def get_variable(self, name): def test_check_fails_while_linux_runner_is_outside_the_linux_pool(self) -> None: value, _ = runner_pools.reconcile({}, runner_pools.load_pools(), dead_now=(), served_now=(), now=NOW) env = {"RUNNER_POOLS": runner_pools.render(value)} - self.assertEqual(runner_pools.main(["--check"], dict(env, LINUX_RUNNER="blacksmith-32vcpu-ubuntu-2404")), 0) - self.assertEqual(runner_pools.main(["--check"], dict(env, LINUX_RUNNER="blacksmith-4vcpu-ubuntu-2404")), 1) + self.assertEqual(runner_pools.main(["--check"], dict(env, LINUX_RUNNER="blacksmith-4vcpu-ubuntu-2404")), 0) + self.assertEqual(runner_pools.main(["--check"], dict(env, LINUX_RUNNER="blacksmith-32vcpu-ubuntu-2404")), 1) self.assertEqual(runner_pools.main(["--check"], env), 1) self.assertEqual(runner_pools.main(["--check"], dict(env, LINUX_RUNNER="ubuntu-24.04", CI_CLOUD_OVERFLOW_SAVED='{"changed": {}}')), 0) @@ -348,7 +365,7 @@ def test_the_overflow_watch_hands_in_what_the_mirror_reads(self) -> None: self.assertEqual(step["env"].get(name), "${{ vars.%s }}" % name) def test_nothing_changed_writes_nothing(self) -> None: - switch = self.Switch({"LINUX_RUNNER": "blacksmith-32vcpu-ubuntu-2404"}) + switch = self.Switch({"LINUX_RUNNER": "blacksmith-4vcpu-ubuntu-2404"}) env = {"RUNNER_POOLS": ""} runner_pools.main([], env, api=self.Api(RECORDED), switch=switch, now=NOW) env["RUNNER_POOLS"] = switch.writes[0][1]