From a73cc957ccca99b72d90abcd40969f0f6e48239b Mon Sep 17 00:00:00 2001 From: DontBlameMe Date: Sun, 1 Nov 2026 00:40:34 +0100 Subject: [PATCH 1/2] fix(release): recheck exact tags on retry Revalidate current and target remote tags before each release attempt mutates the version. Preserve lookup errors and cover Git tail matching with real local remotes in the ordinary gate. Refresh Nixpkgs for the standard commit hooks. Exclude only the unexpanded release-asset URL template from link checks and clean fixture remotes. --- .github/workflows/ci.yml | 3 + .github/workflows/release.yml | 32 +++- flake.lock | 6 +- flake.nix | 17 ++ lychee.toml | 2 + scripts/ci-local.sh | 2 + scripts/test_release_retry.py | 296 ++++++++++++++++++++++++++++++++++ 7 files changed, 353 insertions(+), 5 deletions(-) create mode 100644 scripts/test_release_retry.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 99c1263..6adb7ce 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -162,6 +162,9 @@ jobs: - name: the release workflow's dry_run gating run: nix build .#checks.x86_64-linux.dry-run-gating --no-link --print-build-logs + - name: release-only retries recheck remote tags before bumping + run: nix build .#checks.x86_64-linux.release-retry --no-link --print-build-logs + # Unknown actions, bad expressions and shell mistakes, caught before the run. - name: lint the workflows run: nix develop . -c actionlint diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index d36d47f..6479958 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -111,7 +111,9 @@ jobs: set -euo pipefail version=$(scripts/release-tags.sh | sed -n 's/^version=//p') echo "version=$version" >>"$GITHUB_OUTPUT" - if ! git ls-remote --exit-code --tags origin "refs/tags/v$version" >/dev/null 2>&1; then + remote=$(git ls-remote --refs --tags origin "refs/tags/v$version") + remote=$(printf '%s\n' "$remote" | awk -v ref="refs/tags/v$version" '$2 == ref') + if [ -z "$remote" ]; then { echo "refusing: Cargo.toml carries $version and the remote has no tag v$version." echo @@ -137,7 +139,9 @@ jobs: set -euo pipefail # The last line of stdout is the version, and the only line on it. next=$(scripts/bump-version.sh "$BUMP" --dry-run | tail -n 1) - if git ls-remote --exit-code --tags origin "refs/tags/v$next" >/dev/null 2>&1; then + remote=$(git ls-remote --refs --tags origin "refs/tags/v$next") + remote=$(printf '%s\n' "$remote" | awk -v ref="refs/tags/v$next" '$2 == ref') + if [ -n "$remote" ]; then { echo "refusing: v$next already exists on the remote; nothing was written or pushed." echo @@ -201,6 +205,30 @@ jobs: # against the previous release's tag, which has to be a local ref for it. fetch-depth: 0 + # A release-only retry can reuse a successful plan after remote tags changed. + - name: recheck release tag preconditions before bumping + env: + TARGET: ${{ needs.plan.outputs.version }} + run: | + set -euo pipefail + current=$(sed -n 's/^version = "\(.*\)"$/\1/p' Cargo.toml | head -n 1) + if [ -z "$current" ]; then + echo "refusing: could not read the original version from Cargo.toml" >&2 + exit 1 + fi + current_tag=$(git ls-remote --refs --tags origin "refs/tags/v${current}") + current_tag=$(printf '%s\n' "$current_tag" | awk -v ref="refs/tags/v${current}" '$2 == ref') + target_tag=$(git ls-remote --refs --tags origin "refs/tags/v${TARGET}") + target_tag=$(printf '%s\n' "$target_tag" | awk -v ref="refs/tags/v${TARGET}" '$2 == ref') + if [ -z "$current_tag" ]; then + echo "refusing: the remote no longer has the current release tag v${current}; nothing was bumped" >&2 + exit 1 + fi + if [ -n "$target_tag" ]; then + echo "refusing: target tag v${TARGET} already exists on the remote; nothing was bumped" >&2 + exit 1 + fi + - name: bump the version this release carries env: BUMP: ${{ inputs.bump }} diff --git a/flake.lock b/flake.lock index 0b0f992..d34b652 100644 --- a/flake.lock +++ b/flake.lock @@ -72,11 +72,11 @@ }, "nixpkgs": { "locked": { - "lastModified": 1789149629, - "narHash": "sha256-H6GwaZzZf+4npqv0tph94w9tZddSjFjmQrVsW0z78uk=", + "lastModified": 1793341285, + "narHash": "sha256-Y1CiZ4SoBUjLQyQM/pY+rS2dXD3CHLPstF0lmOc73D4=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "eaad089433ca2bb662274377d33df3d0e51ef28b", + "rev": "1c89083e451e891152365b799595cf7790a43325", "type": "github" }, "original": { diff --git a/flake.nix b/flake.nix index 80f64a5..ae02c71 100644 --- a/flake.nix +++ b/flake.nix @@ -352,6 +352,23 @@ touch $out ''; + # Exercise plan, retry and exact remote tag checks without publishing. + release-retry = + pkgs.runCommand "release-retry-test" { + nativeBuildInputs = [ + (pkgs.python3.withPackages (ps: [ps.pyyaml])) + pkgs.bash + pkgs.coreutils + pkgs.gnused + pkgs.gawk + pkgs.git + ]; + } '' + RELEASE_WORKFLOW=${./.github/workflows/release.yml} \ + python3 -B ${./scripts/test_release_retry.py} + touch $out + ''; + # The guard around a workflow's `dry_run` input: a plan step prints what a # real run would do, and every step after it has to be excluded from a dry # run. `actionlint` lints those diff --git a/lychee.toml b/lychee.toml index a4c7fd5..e5733aa 100644 --- a/lychee.toml +++ b/lychee.toml @@ -19,6 +19,8 @@ root_dir = "." exclude = [ "https://fsf.org/", + # The runner expands this workflow template before fetching the release asset. + '^[h]ttps://github[.]com/lycheeverse/lychee/releases/download/lychee-v[$]([{]|%7[Bb])LYCHEE_VERSION', # The public demo's front proxying to its sibling containers by their Compose # service names (`deploy/`). Those names resolve only inside that # deployment's own network. diff --git a/scripts/ci-local.sh b/scripts/ci-local.sh index b6f862e..20c5788 100755 --- a/scripts/ci-local.sh +++ b/scripts/ci-local.sh @@ -124,6 +124,8 @@ job_checks() { # one where a step after the plan can still run on a dry run. say "checks: the release workflow's dry_run gating" nix build .#checks.x86_64-linux.dry-run-gating --no-link --print-build-logs + say "checks: release-only retries recheck remote tags before bumping" + nix build .#checks.x86_64-linux.release-retry --no-link --print-build-logs say "checks: lint the workflows" nix develop . -c actionlint # The same check the pre-commit hook runs: a commit made outside the dev shell cannot diff --git a/scripts/test_release_retry.py b/scripts/test_release_retry.py new file mode 100644 index 0000000..8df1450 --- /dev/null +++ b/scripts/test_release_retry.py @@ -0,0 +1,296 @@ +"""Exercise release tag checks from the workflow, without building or publishing.""" + +import json +import os +import shutil +import subprocess +import sys +import tempfile +import unittest +from pathlib import Path + +import yaml + +ROOT = Path(__file__).resolve().parent.parent +WORKFLOW = Path(os.environ.get("RELEASE_WORKFLOW", ROOT / ".github/workflows/release.yml")) +GUARD = "recheck release tag preconditions before bumping" +MANIFEST = Path("Cargo.toml") +ORIGINAL = '[workspace.package]\nversion = "1.2.3"\n' +BUMP = "bump the version this release carries" +CURRENT_REF = "refs/tags/v1.2.3" +TARGET_REF = "refs/tags/v1.2.4" +BASH = shutil.which("bash") +REAL_GIT = shutil.which("git") + +GIT_STUB = '''\ +import json +import sys +import subprocess +from pathlib import Path + +args = sys.argv[1:] +with Path("git.log").open("a") as log: + log.write(json.dumps(args) + "\\n") +if args[0] == "ls-remote": + fixture = Path("fixture-remote") + if fixture.exists(): + args[args.index("origin")] = fixture.read_text() + sys.exit(subprocess.run([REAL_GIT, *args], timeout=5).returncode) + state = json.loads(Path("remote.json").read_text()) + ref = args[-1] + result = state.get(ref, "") + if isinstance(result, int): + print("a" * 40 + "\\t" + ref) + print("remote read failed", file=sys.stderr) + sys.exit(result) + if result: + print(result + "\\t" + ref) +elif args != ["diff", "--name-only"]: + sys.exit("unexpected git invocation: " + repr(args)) +''' + + +class ReleaseRetryTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + if BASH is None or REAL_GIT is None: + raise RuntimeError("release tag tests require bash and real Git on PATH") + + def setUp(self): + scratch = Path(os.environ.get("TMPDIR", ROOT / ".tmp")) + scratch.mkdir(parents=True, exist_ok=True) + self.temp = tempfile.TemporaryDirectory(prefix="release-retry-", dir=scratch) + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + manifest = self.root / MANIFEST + manifest.parent.mkdir(parents=True, exist_ok=True) + manifest.write_text(ORIGINAL) + scripts = self.root / "scripts" + scripts.mkdir() + bump = scripts / "bump-version.sh" + bump.write_text( + f'#!{BASH}\nset -euo pipefail\n' + 'if [ "${2:-}" = --dry-run ]; then echo 1.2.4; exit 0; fi\n' + 'printf bumped > bump.log\n' + f"printf 'version = \"1.2.4\"\\n' > {MANIFEST}\n" + ) + bump.chmod(0o755) + tags = scripts / "release-tags.sh" + tags.write_text(f"#!{BASH}\nprintf 'version=1.2.3\\n'\n") + tags.chmod(0o755) + bin_dir = self.root / "bin" + bin_dir.mkdir() + git = bin_dir / "git" + git.write_text(f"#!{sys.executable}\nREAL_GIT = {REAL_GIT!r}\n" + GIT_STUB) + git.chmod(0o755) + self.env = { + **os.environ, + "PATH": str(bin_dir) + os.pathsep + os.environ["PATH"], + "RUNNER_TEMP": str(self.root), + # A job output or ambient variable must not replace the checkout's version. + "CURRENT": "9.9.9", + } + jobs = yaml.safe_load(WORKFLOW.read_text())["jobs"] + self.steps = jobs["release"]["steps"] + self.plan_steps = jobs["plan"]["steps"][2:4] + self.remote({CURRENT_REF: "a" * 40}) + + def remote(self, refs): + (self.root / "remote.json").write_text(json.dumps(refs)) + + def attempt(self): + outputs = { + "${{ needs.plan.outputs.version }}": "1.2.4", + "${{ needs.plan.outputs.current }}": "1.2.3", + "${{ inputs.bump }}": "patch", + } + # Checkout is represented by the original fixture. Run the actual shell bodies, + # including the bump boundary, but never reach a build, commit, tag or push. + for step in self.steps[1:]: + self.assertIn("run", step, "an action was inserted before the bump") + env = {key: outputs.get(value, value) for key, value in step.get("env", {}).items()} + result = self.run_step(step, env) + if result.returncode or step.get("name") == BUMP: + return result + self.fail("release job has no bump boundary") + + def run_step(self, step, env=None): + return subprocess.run( + [BASH, "--noprofile", "--norc", "-e", "-o", "pipefail", "-c", step["run"]], + cwd=self.root, env={**self.env, **(env or {})}, + text=True, capture_output=True, timeout=5, + ) + + def plan(self): + for step in self.plan_steps: + result = self.run_step(step, { + "BUMP": "patch", "GITHUB_OUTPUT": str(self.root / "plan-output"), + }) + if result.returncode: + return result + return result + + def fixture_remote(self, refs): + remote = Path(tempfile.mkdtemp(prefix="release-tag-remote-", dir=self.root.parent)) + self.addCleanup(shutil.rmtree, remote) + + def git(*args, text=None): + result = subprocess.run( + [REAL_GIT, "-C", str(remote), *args], input=text, text=True, + capture_output=True, timeout=5, + ) + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + return result.stdout.strip() + + git("init", "--bare", "--quiet", "--initial-branch=main") + objects = {} + for ref, value in refs.items(): + annotated = isinstance(value, tuple) + sha = git("hash-object", "-w", "--stdin", text=value[0] if annotated else value) + objects[ref] = sha + if annotated: + sha = git("mktag", text=( + f"object {sha}\ntype blob\ntag fixture\n" + "tagger Release Test 1 +0000\n\nfixture\n" + )) + git("update-ref", ref, sha) + (self.root / "fixture-remote").write_text(str(remote)) + return remote, objects + + def test_exact_ref_git_tail_pattern_really_returns_nested_tag(self): + alias = "refs/tags/" + CURRENT_REF + remote, objects = self.fixture_remote({alias: "released"}) + result = subprocess.run( + [REAL_GIT, "ls-remote", "--refs", "--tags", str(remote), CURRENT_REF], + capture_output=True, text=True, timeout=5, + ) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout, f"{objects[alias]}\t{alias}\n") + (remote / "tail-match-proof.log").write_text(result.stdout) + print(f"real Git tail-match proof ({remote}): {result.stdout.strip()}") + + def test_exact_ref_nested_current_only_is_refused_by_plan_and_retry(self): + self.fixture_remote({"refs/tags/" + CURRENT_REF: "released"}) + for run in (self.plan, self.attempt): + with self.subTest(stage=run.__name__): + result = run() + self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertIn("v1.2.3", result.stderr) + self.assertFalse((self.root / "bump.log").exists()) + self.assertEqual((self.root / MANIFEST).read_text(), ORIGINAL) + + def test_exact_ref_nested_target_only_is_free_for_plan_and_retry(self): + self.fixture_remote({ + CURRENT_REF: "released", "refs/tags/" + CURRENT_REF: "other", + "refs/tags/" + TARGET_REF: "other", + }) + for run in (self.plan, self.attempt): + with self.subTest(stage=run.__name__): + result = run() + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + + def test_exact_ref_mixed_aliases_do_not_hide_exact_target_collision(self): + self.fixture_remote({ + CURRENT_REF: "released", "refs/tags/" + CURRENT_REF: "other", + TARGET_REF: "target", "refs/tags/" + TARGET_REF: "other", + }) + result = self.plan() + self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertIn("v1.2.4", result.stderr) + self.assert_refused() + + def test_plan_remote_errors_abort_before_filtering_either_query(self): + for ref in (CURRENT_REF, TARGET_REF): + for status in (2, 128): + with self.subTest(ref=ref, status=status): + self.remote({CURRENT_REF: "a" * 40, ref: status}) + result = self.plan() + self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertIn("remote read failed", result.stderr) + self.assertFalse((self.root / "bump.log").exists()) + + def remote_calls(self): + log = self.root / "git.log" + calls = [json.loads(line) for line in log.read_text().splitlines()] if log.exists() else [] + return [args for args in calls if args[0] == "ls-remote"] + + def assert_refused(self): + result = self.attempt() + self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertFalse((self.root / "bump.log").exists(), "stale plan reached the bump") + self.assertEqual((self.root / MANIFEST).read_text(), ORIGINAL) + return result + + def test_current_tag_disappears_after_cached_plan(self): + self.remote({}) + result = self.assert_refused() + self.assertIn("v1.2.3", result.stderr) + + def test_target_tag_appears_after_cached_plan(self): + self.remote({CURRENT_REF: "a" * 40, TARGET_REF: "b" * 40}) + result = self.assert_refused() + self.assertIn("v1.2.4", result.stderr) + + def test_unchanged_remote_allows_bump_and_queries_exact_original_refs(self): + result = self.attempt() + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertTrue((self.root / "bump.log").exists()) + self.assertEqual(self.remote_calls(), [ + ["ls-remote", "--refs", "--tags", "origin", CURRENT_REF], + ["ls-remote", "--refs", "--tags", "origin", TARGET_REF], + ]) + + def test_remote_errors_fail_closed_for_either_query(self): + for ref in (CURRENT_REF, TARGET_REF): + for status in (2, 128): + with self.subTest(ref=ref, status=status): + self.remote({CURRENT_REF: "a" * 40, ref: status}) + result = self.assert_refused() + self.assertIn("remote read failed", result.stderr) + + def test_cached_current_cannot_substitute_for_original_manifest(self): + original = ORIGINAL.replace("1.2.3", "1.2.2") + (self.root / MANIFEST).write_text(original) + # Only the cached current is tagged; the actual checkout version is not. + result = self.attempt() + self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertFalse((self.root / "bump.log").exists()) + self.assertEqual((self.root / MANIFEST).read_text(), original) + + def test_unreadable_or_missing_version_fails_before_remote_or_bump(self): + manifest = self.root / MANIFEST + for contents in (None, "no version here\n"): + with self.subTest(contents=contents): + if contents is None: + manifest.unlink() + else: + manifest.write_text(contents) + result = self.attempt() + self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertFalse((self.root / "bump.log").exists()) + self.assertEqual(self.remote_calls(), []) + + def test_each_release_attempt_rechecks_remote(self): + result = self.attempt() + self.assertEqual(result.returncode, 0, result.stderr) + # A release-only retry gets the same checkout and cached output, not a new plan. + (self.root / MANIFEST).write_text(ORIGINAL) + (self.root / "bump.log").unlink() + self.remote({CURRENT_REF: "a" * 40, TARGET_REF: "b" * 40}) + self.assert_refused() + self.assertEqual(len(self.remote_calls()), 4) + + def test_guard_is_unconditional_between_checkout_and_first_bump(self): + self.assertTrue(self.steps[0]["uses"].startswith("actions/checkout@")) + self.assertEqual(self.steps[1]["name"], GUARD) + self.assertNotIn("if", self.steps[1]) + self.assertEqual(self.steps[1]["env"]["TARGET"], "${{ needs.plan.outputs.version }}") + self.assertEqual(self.steps[2]["name"], BUMP) + for step in self.steps[:2]: + self.assertNotIn("scripts/bump-version.sh", step.get("run", "")) + self.assertNotIn("git commit", step.get("run", "")) + self.assertNotIn("git push", step.get("run", "")) + + +if __name__ == "__main__": + unittest.main() From 3ae6333e85e0ddfc4946665df1b36c6df39bcbd0 Mon Sep 17 00:00:00 2001 From: DontBlameMe Date: Sun, 1 Nov 2026 00:54:48 +0100 Subject: [PATCH 2/2] test(release): preserve lookup failure evidence Assert the remote command exit status before ref filtering. Distinguish lookup errors from ordinary tag-precondition refusals. --- scripts/test_release_retry.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/scripts/test_release_retry.py b/scripts/test_release_retry.py index 8df1450..d1be2ea 100644 --- a/scripts/test_release_retry.py +++ b/scripts/test_release_retry.py @@ -205,8 +205,9 @@ def test_plan_remote_errors_abort_before_filtering_either_query(self): with self.subTest(ref=ref, status=status): self.remote({CURRENT_REF: "a" * 40, ref: status}) result = self.plan() - self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertEqual(result.returncode, status, result.stdout + result.stderr) self.assertIn("remote read failed", result.stderr) + self.assertNotIn("refusing", result.stderr) self.assertFalse((self.root / "bump.log").exists()) def remote_calls(self): @@ -246,7 +247,9 @@ def test_remote_errors_fail_closed_for_either_query(self): with self.subTest(ref=ref, status=status): self.remote({CURRENT_REF: "a" * 40, ref: status}) result = self.assert_refused() + self.assertEqual(result.returncode, status, result.stdout + result.stderr) self.assertIn("remote read failed", result.stderr) + self.assertNotIn("refusing", result.stderr) def test_cached_current_cannot_substitute_for_original_manifest(self): original = ORIGINAL.replace("1.2.3", "1.2.2")