diff options
| author | Onur Gündüz <ogunduz@gmail.com> | 2026-09-29 15:50:58 +0200 |
|---|---|---|
| committer | Onur Gündüz <ogunduz@gmail.com> | 2026-09-29 15:50:58 +0200 |
| commit | cc70af2a5d8850218fa336e6acb2f46ee8207f40 (patch) | |
| tree | 4157f1864623005e829d2181697a1b136389cc85 | |
| parent | c50e5e10c0d8df6cf54b94194ffb514db390ed4a (diff) | |
| download | ele-cc70af2a5d8850218fa336e6acb2f46ee8207f40.tar.gz ele-cc70af2a5d8850218fa336e6acb2f46ee8207f40.zip | |
Automate tested branch releases for Linux and macOS
| -rw-r--r-- | .github/workflows/ci.yml | 3 | ||||
| -rw-r--r-- | .github/workflows/release.yml | 228 | ||||
| -rw-r--r-- | scripts/release.py | 155 | ||||
| -rw-r--r-- | scripts/test_release.py | 163 |
4 files changed, 549 insertions, 0 deletions
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0285c9d..0dc642b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -4,6 +4,7 @@ on: push: pull_request: workflow_dispatch: + workflow_call: permissions: contents: read @@ -40,6 +41,8 @@ jobs: persist-credentials: false - name: Install Rust tools run: rustup toolchain install stable --profile minimal --component rustfmt --component clippy + - name: Test release automation + run: python3 -B -m unittest discover -s scripts -p 'test_*.py' - name: Check formatting run: cargo +stable fmt --all -- --check - name: Check lints diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..ffb6559 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,228 @@ +name: release + +on: + workflow_dispatch: + inputs: + version: + description: Version impact (the first release is 0.1.0 or X.0.0) + required: true + default: patch + type: choice + options: [minor, patch] + dry_run: + description: Build and test artifacts without pushing or publishing + required: true + default: true + type: boolean + +concurrency: + group: release-${{ github.ref_name }} + cancel-in-progress: false + +permissions: + contents: read + +defaults: + run: + shell: bash + +env: + RELEASE_RUST: "1.88.0" + +jobs: + prepare: + runs-on: ubuntu-24.04 + timeout-minutes: 15 + outputs: + version: ${{ steps.version.outputs.version }} + tag: ${{ steps.version.outputs.tag }} + commit: ${{ steps.version.outputs.commit }} + base: ${{ steps.version.outputs.base }} + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + fetch-depth: 0 + persist-credentials: false + - name: Require a release branch + env: + REF_TYPE: ${{ github.ref_type }} + RELEASE_BRANCH: ${{ github.ref_name }} + run: | + test "$REF_TYPE" = branch + python3 -B -c 'import sys; sys.path.insert(0, "scripts"); from release import branch_major; branch_major(sys.argv[1])' "$RELEASE_BRANCH" + - name: Install Rust + run: rustup toolchain install "$RELEASE_RUST" --profile minimal + - name: Select release toolchain + run: rustup override set "$RELEASE_RUST" + - name: Prepare version and source bundle + id: version + env: + RELEASE_BRANCH: ${{ github.ref_name }} + IMPACT: ${{ inputs.version }} + run: | + python3 -B scripts/release.py prepare --branch "$RELEASE_BRANCH" --impact "$IMPACT" \ + --bundle target/release-source.bundle --output "$GITHUB_OUTPUT" + - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 + with: + name: release-source + path: target/release-source.bundle + if-no-files-found: error + retention-days: 7 + overwrite: true + + checks: + needs: prepare + uses: ./.github/workflows/ci.yml + + build: + needs: prepare + runs-on: ${{ matrix.os }} + timeout-minutes: 30 + strategy: + fail-fast: false + matrix: + include: + - os: ubuntu-24.04 + target: x86_64-unknown-linux-musl + - os: macos-15 + target: aarch64-apple-darwin + env: + TARGET: ${{ matrix.target }} + VERSION: ${{ needs.prepare.outputs.version }} + RELEASE_COMMIT: ${{ needs.prepare.outputs.commit }} + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 + with: + name: release-source + path: target/release-input + - name: Check out versioned source + run: | + git fetch target/release-input/release-source.bundle HEAD + test "$(git rev-parse FETCH_HEAD)" = "$RELEASE_COMMIT" + git checkout --detach "$RELEASE_COMMIT" + - name: Install Rust + run: rustup toolchain install "$RELEASE_RUST" --profile minimal --target "$TARGET" + - name: Select release toolchain + run: rustup override set "$RELEASE_RUST" + - name: Set macOS deployment target + if: runner.os == 'macOS' + run: echo 'MACOSX_DEPLOYMENT_TARGET=11.0' >> "$GITHUB_ENV" + - name: Test release target + run: | + cargo test --locked --target "$TARGET" + cargo test --locked --target "$TARGET" --features serde_json/arbitrary_precision + cargo test --release --locked --target "$TARGET" + - name: Build and check CLI + run: | + cargo build --release --locked --target "$TARGET" + binary="target/$TARGET/release/aip-filter" + test "$("$binary" --version)" = "aip-filter $VERSION" + printf '{"n":1}\n{"n":2}\n' | "$binary" 'n > 1' > target/smoke.jsonl + printf '{"n":2}\n' > target/expected.jsonl + cmp target/expected.jsonl target/smoke.jsonl + - name: Verify static Linux executable + if: runner.os == 'Linux' + run: | + readelf -l "target/$TARGET/release/aip-filter" > target/elf-headers + if grep -q INTERP target/elf-headers; then + echo 'The Linux executable requires a dynamic loader.' >&2 + exit 1 + fi + - name: Archive CLI + run: | + mkdir -p target/release-dist + COPYFILE_DISABLE=1 tar -czf "target/release-dist/aip-filter-v$VERSION-$TARGET.tar.gz" \ + -C "target/$TARGET/release" aip-filter -C "$GITHUB_WORKSPACE" LICENSE README.md + - name: Verify library package + if: runner.os == 'Linux' + run: | + cargo package --locked + cargo test --locked --manifest-path "target/package/aip_filter-$VERSION/Cargo.toml" + cp "target/package/aip_filter-$VERSION.crate" target/release-dist/ + - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 + with: + name: release-assets-${{ matrix.target }} + path: target/release-dist/* + if-no-files-found: error + retention-days: 7 + compression-level: 0 + overwrite: true + + publish: + needs: [prepare, checks, build] + runs-on: ubuntu-24.04 + timeout-minutes: 15 + permissions: + contents: write + env: + RELEASE_BRANCH: ${{ github.ref_name }} + VERSION: ${{ needs.prepare.outputs.version }} + TAG: ${{ needs.prepare.outputs.tag }} + BASE: ${{ needs.prepare.outputs.base }} + RELEASE_COMMIT: ${{ needs.prepare.outputs.commit }} + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + fetch-depth: 0 + - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 + with: + name: release-source + path: target/release-input + - name: Check out tested source + run: | + git fetch target/release-input/release-source.bundle HEAD + test "$(git rev-parse FETCH_HEAD)" = "$RELEASE_COMMIT" + git checkout --detach "$RELEASE_COMMIT" + - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 + with: + pattern: release-assets-* + merge-multiple: true + path: target/release-dist + - name: Verify asset set and generate checksums + run: | + test -f "target/release-dist/aip-filter-v$VERSION-x86_64-unknown-linux-musl.tar.gz" + test -f "target/release-dist/aip-filter-v$VERSION-aarch64-apple-darwin.tar.gz" + test -f "target/release-dist/aip_filter-$VERSION.crate" + test "$(find target/release-dist -maxdepth 1 -type f | wc -l)" -eq 3 + cd target/release-dist + sha256sum *.tar.gz *.crate > SHA256SUMS + sha256sum --check SHA256SUMS + - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 + with: + name: release-downloads + path: target/release-dist/* + if-no-files-found: error + retention-days: 7 + compression-level: 0 + overwrite: true + - name: Push tested release references + if: ${{ !inputs.dry_run }} + run: | + python3 -B scripts/release.py push --branch "$RELEASE_BRANCH" \ + --version "$VERSION" --base "$BASE" --commit "$RELEASE_COMMIT" + - name: Publish GitHub release + if: ${{ !inputs.dry_run }} + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + if draft=$(gh release view "$TAG" --json isDraft --jq '.isDraft'); then + if test "$draft" != true; then + echo 'The release is already public; refusing to replace its assets.' >&2 + exit 1 + fi + else + gh release create "$TAG" --verify-tag --draft --generate-notes --title "$TAG" --target "$RELEASE_COMMIT" + fi + gh release upload "$TAG" target/release-dist/* --clobber + release_id=$(gh api "repos/$GITHUB_REPOSITORY/releases/tags/$TAG" --jq '.id') + gh api --method PATCH "repos/$GITHUB_REPOSITORY/releases/$release_id" \ + -F draft=false -f make_latest=legacy > /dev/null + - name: Record result + env: + DRY_RUN: ${{ inputs.dry_run }} + run: | + printf 'Version: `%s`\n\nCommit: `%s`\n\nDry run: `%s`\n\nDownload the `release-downloads` artifact for the CLI archives, Cargo source package, and SHA256SUMS.\n' \ + "$TAG" "$RELEASE_COMMIT" "$DRY_RUN" >> "$GITHUB_STEP_SUMMARY" diff --git a/scripts/release.py b/scripts/release.py new file mode 100644 index 0000000..512feab --- /dev/null +++ b/scripts/release.py @@ -0,0 +1,155 @@ +"""Prepare versioned source bundles and publish tested Git references.""" + +import argparse +import copy +from pathlib import Path +import re +import subprocess +import tomllib + +VERSION = r"(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)" + + +def run(*args): + return subprocess.check_output(args, text=True).strip() + + +def branch_major(branch): + match = re.fullmatch(r"v(0|[1-9][0-9]*)\.x", branch) + if not match: + raise ValueError("release branch must be named vX.x, for example v0.x") + return int(match[1]) + + +def version_tuple(version): + match = re.fullmatch(VERSION, version) + if not match: + raise ValueError(f"expected a stable major.minor.patch version: {version}") + return tuple(map(int, match.groups())) + + +def next_version(branch, impact, tags): + major = branch_major(branch) + if impact not in ("patch", "minor"): + raise ValueError("impact must be patch or minor") + versions = [ + version_tuple(tag[1:]) for tag in tags + if re.fullmatch("v" + VERSION, tag) and version_tuple(tag[1:])[0] == major + ] + if not versions: + return f"{major}.{1 if major == 0 else 0}.0" + _, minor, patch = max(versions) + return f"{major}.{minor + 1}.0" if impact == "minor" else f"{major}.{minor}.{patch + 1}" + + +def require_ancestor(ancestor, commit): + subprocess.run(["git", "merge-base", "--is-ancestor", ancestor, commit], check=True) + + +def set_version(version): + manifest = Path("Cargo.toml") + text = manifest.read_text() + package = tomllib.loads(text)["package"] + if package["name"] != "aip_filter": + raise ValueError("expected the aip_filter package") + current = package["version"] + if version_tuple(current) > version_tuple(version): + raise ValueError(f"manifest version {current} exceeds the planned release {version}") + if current == version: + return + section = re.search(r"(?ms)^\[package\]\n.*?(?=^\[|\Z)", text) + if not section: + raise ValueError("expected an explicit [package] section") + body, count = re.subn(r'(?m)^version\s*=\s*"[^"]+"', f'version = "{version}"', section[0]) + if count != 1: + raise ValueError("expected one explicit package version") + expected_lock = copy.deepcopy(tomllib.loads(Path("Cargo.lock").read_text())) + packages = [p for p in expected_lock["package"] if p["name"] == "aip_filter" and "source" not in p] + if len(packages) != 1 or packages[0]["version"] != current: + raise ValueError("manifest and lockfile versions must agree") + packages[0]["version"] = version + manifest.write_text(text[:section.start()] + body + text[section.end():]) + subprocess.run(["cargo", "update", "--workspace"], check=True) + if tomllib.loads(Path("Cargo.lock").read_text()) != expected_lock: + raise ValueError("version update changed dependencies; refusing to prepare a release") + + +def prepare(branch, impact, bundle): + branch_major(branch) + if run("git", "status", "--porcelain"): + raise ValueError("release preparation requires a clean working tree") + base = run("git", "rev-parse", "HEAD") + if any(re.fullmatch("v" + VERSION, tag) for tag in run("git", "tag", "--points-at", base).splitlines()): + raise ValueError("this commit already has a release tag; rerun a failed publish job to resume it") + tags = run("git", "tag", "--list").splitlines() + version = next_version(branch, impact, tags) + for tag in tags: + if re.fullmatch("v" + VERSION, tag) and version_tuple(tag[1:])[0] == branch_major(branch): + require_ancestor(tag, base) + set_version(version) + subprocess.run(["git", "add", "Cargo.toml", "Cargo.lock"], check=True) + if run("git", "diff", "--cached", "--name-only"): + subprocess.run([ + "git", "-c", "user.name=github-actions[bot]", + "-c", "user.email=41898282+github-actions[bot]@users.noreply.github.com", + "-c", "commit.gpgsign=false", "commit", "-m", f"Release v{version}", + ], check=True) + commit = run("git", "rev-parse", "HEAD") + bundle.parent.mkdir(parents=True, exist_ok=True) + subprocess.run(["git", "bundle", "create", str(bundle), "HEAD"], check=True) + return {"version": version, "tag": f"v{version}", "commit": commit, "base": base} + + +def push_refs(branch, version, base, commit): + if branch_major(branch) != version_tuple(version)[0]: + raise ValueError("release version does not belong to this branch") + require_ancestor(base, commit) + if run("git", "rev-parse", "HEAD") != commit: + raise ValueError("checkout does not match the tested release commit") + if tomllib.loads(Path("Cargo.toml").read_text())["package"]["version"] != version: + raise ValueError("manifest does not match the release version") + if run("git", "status", "--porcelain"): + raise ValueError("publishing requires a clean working tree") + tag = f"v{version}" + remote_tag = run("git", "ls-remote", "--tags", "origin", f"refs/tags/{tag}") + if remote_tag: + subprocess.run(["git", "fetch", "origin", f"refs/tags/{tag}"], check=True) + if run("git", "rev-parse", "FETCH_HEAD^{commit}") != commit: + raise ValueError("the remote tag belongs to a different commit") + return + remote_branch = run("git", "ls-remote", "--heads", "origin", f"refs/heads/{branch}") + if not remote_branch or remote_branch.split()[0] != base: + raise ValueError("release branch has moved; start a new workflow run from its current head") + subprocess.run(["git", "tag", tag, commit], check=True) + subprocess.run([ + "git", "push", "--atomic", "origin", + f"{commit}:refs/heads/{branch}", f"refs/tags/{tag}:refs/tags/{tag}", + ], check=True) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + commands = parser.add_subparsers(dest="command", required=True) + prepare_parser = commands.add_parser("prepare") + prepare_parser.add_argument("--branch", required=True) + prepare_parser.add_argument("--impact", choices=("patch", "minor"), required=True) + prepare_parser.add_argument("--bundle", type=Path, required=True) + prepare_parser.add_argument("--output", type=Path, required=True) + push_parser = commands.add_parser("push") + for name in ("branch", "version", "base", "commit"): + push_parser.add_argument(f"--{name}", required=True) + args = parser.parse_args() + try: + if args.command == "prepare": + outputs = prepare(args.branch, args.impact, args.bundle) + with args.output.open("a") as output: + for name, value in outputs.items(): + print(f"{name}={value}", file=output) + else: + push_refs(args.branch, args.version, args.base, args.commit) + except (ValueError, subprocess.CalledProcessError) as error: + parser.exit(1, f"release: {error}\n") + + +if __name__ == "__main__": + main() diff --git a/scripts/test_release.py b/scripts/test_release.py new file mode 100644 index 0000000..1986ad5 --- /dev/null +++ b/scripts/test_release.py @@ -0,0 +1,163 @@ +import os +from pathlib import Path +import subprocess +import tempfile +import tomllib +import unittest + +import release + +ROOT = Path(__file__).resolve().parent.parent + + +class VersionTests(unittest.TestCase): + def test_initial_versions_and_impacts(self): + self.assertEqual(release.next_version("v0.x", "patch", []), "0.1.0") + self.assertEqual(release.next_version("v1.x", "minor", []), "1.0.0") + tags = ["v0.9.9", "v0.10.2", "v0.10.10", "v1.3.0", "v0.11.0-rc.1", "other"] + self.assertEqual(release.next_version("v0.x", "patch", tags), "0.10.11") + self.assertEqual(release.next_version("v0.x", "minor", tags), "0.11.0") + self.assertEqual(release.next_version("v1.x", "patch", tags), "1.3.1") + + def test_invalid_inputs(self): + for branch in ["master", "v01.x", "v1.2.x", "v1.x\n", "v1.x;echo bad"]: + with self.subTest(branch=branch), self.assertRaises(ValueError): + release.next_version(branch, "patch", []) + with self.assertRaises(ValueError): + release.next_version("v0.x", "major", []) + for version in ["01.2.3", "1.2", "1.2.3-rc.1", "1.2.3+build"]: + with self.subTest(version=version), self.assertRaises(ValueError): + release.version_tuple(version) + + +class RepositoryTests(unittest.TestCase): + def setUp(self): + directory = ROOT / "target" / "release-script-tests" + directory.mkdir(parents=True, exist_ok=True) + self.temporary = tempfile.TemporaryDirectory(dir=directory) + self.addCleanup(self.temporary.cleanup) + self.previous = Path.cwd() + self.addCleanup(os.chdir, self.previous) + self.root = Path(self.temporary.name) + self.repo = self.root / "repo" + self.repo.mkdir() + os.chdir(self.repo) + release.run("git", "init", "-b", "v0.x") + release.run("git", "config", "user.name", "Release tests") + release.run("git", "config", "user.email", "release-tests@example.invalid") + release.run("git", "config", "commit.gpgsign", "false") + Path(".gitignore").write_text("target/\n") + Path("Cargo.toml").write_text( + '[package]\nname = "aip_filter"\nversion = "0.1.0"\nedition = "2024"\n' + ) + Path("src").mkdir() + Path("src/lib.rs").write_text("pub fn example() {}\n") + release.run("cargo", "generate-lockfile", "--offline") + self.commit("Initial package") + self.remote = self.root / "origin.git" + release.run("git", "init", "--bare", "-b", "v0.x", str(self.remote)) + release.run("git", "remote", "add", "origin", str(self.remote)) + release.run("git", "push", "origin", "HEAD:refs/heads/v0.x") + + def commit(self, message): + release.run("git", "add", ".") + release.run("git", "commit", "-m", message) + return release.run("git", "rev-parse", "HEAD") + + def prepare(self, impact="patch"): + return release.prepare("v0.x", impact, Path("target/source.bundle")) + + def publish(self, result): + release.push_refs("v0.x", result["version"], result["base"], result["commit"]) + + def patch_source(self): + release.run("git", "tag", "v0.1.0") + release.run("git", "push", "origin", "v0.1.0") + Path("src/lib.rs").write_text("pub fn example() -> bool { true }\n") + self.commit("Change package") + release.run("git", "push", "origin", "HEAD:refs/heads/v0.x") + + def test_initial_prepare_has_no_remote_side_effects(self): + before = release.run("git", "ls-remote", "origin") + result = self.prepare() + self.assertEqual(result["version"], "0.1.0") + self.assertEqual(result["base"], result["commit"]) + self.assertEqual(release.run("git", "tag", "--list"), "") + self.assertEqual(release.run("git", "ls-remote", "origin"), before) + release.run("git", "bundle", "verify", "target/source.bundle") + self.assertEqual(release.run("git", "status", "--porcelain"), "") + + def test_patch_updates_manifest_lock_and_bundle_and_publishes_atomically(self): + self.patch_source() + before = release.run("git", "ls-remote", "origin") + result = self.prepare() + self.assertEqual(result["version"], "0.1.1") + self.assertNotEqual(result["base"], result["commit"]) + self.assertEqual(release.run("git", "ls-remote", "origin"), before) + self.assertEqual(tomllib.loads(Path("Cargo.toml").read_text())["package"]["version"], "0.1.1") + self.assertEqual(tomllib.loads(Path("Cargo.lock").read_text())["package"][0]["version"], "0.1.1") + release.run("cargo", "check", "--locked", "--offline") + clone = self.root / "from-bundle" + release.run("git", "clone", "target/source.bundle", str(clone)) + self.assertEqual(release.run("git", "-C", str(clone), "rev-parse", "HEAD"), result["commit"]) + self.publish(result) + refs = release.run("git", "ls-remote", "origin") + self.assertIn(result["commit"] + "\trefs/heads/v0.x", refs) + self.assertIn(result["commit"] + "\trefs/tags/v0.1.1", refs) + self.publish(result) + self.assertEqual(release.run("git", "ls-remote", "origin"), refs) + + def test_already_tagged_dirty_and_downgraded_versions_fail(self): + Path("untracked").write_text("not committed") + with self.assertRaises(ValueError): + self.prepare() + Path("untracked").unlink() + release.run("git", "tag", "v0.1.0") + with self.assertRaises(ValueError): + self.prepare() + release.run("git", "tag", "-d", "v0.1.0") + with self.assertRaises(ValueError): + release.set_version("0.0.9") + + def test_moved_branch_fails_without_a_tag(self): + result = self.prepare() + Path("new-file").write_text("new branch head") + advanced = self.commit("Advance branch") + release.run("git", "push", "origin", "HEAD:refs/heads/v0.x") + release.run("git", "checkout", "--detach", result["commit"]) + with self.assertRaises(ValueError): + self.publish(result) + self.assertEqual(release.run("git", "ls-remote", "--tags", "origin"), "") + self.assertIn(advanced, release.run("git", "ls-remote", "--heads", "origin")) + + def test_conflicting_remote_tag_fails(self): + self.patch_source() + result = self.prepare() + release.run("git", "tag", result["tag"], result["base"]) + release.run("git", "push", "origin", result["tag"]) + with self.assertRaises(ValueError): + self.publish(result) + + def test_unmerged_release_tags_fail(self): + base = release.run("git", "rev-parse", "HEAD") + Path("other-change").write_text("another release branch") + self.commit("Other branch") + release.run("git", "tag", "v0.2.0") + release.run("git", "checkout", "--detach", base) + with self.assertRaises(subprocess.CalledProcessError): + self.prepare() + + def test_atomic_push_does_not_advance_branch_when_tag_is_rejected(self): + self.patch_source() + result = self.prepare() + hook = self.remote / "hooks" / "update" + hook.write_text('#!/bin/sh\ncase "$1" in refs/tags/*) exit 1;; esac\n') + hook.chmod(0o755) + with self.assertRaises(subprocess.CalledProcessError): + self.publish(result) + self.assertIn(result["base"], release.run("git", "ls-remote", "--heads", "origin")) + self.assertEqual(release.run("git", "ls-remote", "--tags", "origin", result["tag"]), "") + + +if __name__ == "__main__": + unittest.main() |
