SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
CI: a push that only merges main into a passing change carries its result
jyvikob045d9deae96
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.ymlindex 1ccc3eed97..6084d20c7f 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -19,7 +19,9 @@# vendored crates under vendor/ select the packages that read them (scripts/ci/affected.py).# Heavy checks wait for review: a pull request without the `approved-for-ci` label runs only# Select checks, the format and repository checks and a quick compile. Adding the label (after-# review) runs everything above, and every later push to the PR does too. Pushes to main, merge+# review) runs everything above, and every later push to the PR does too, except a push that only+# merges main into a change that already passed (scripts/ci/main_merge.py): it carries that+# result and runs the repository checks. Pushes to main, merge# groups, the nightly run and Run workflow are not pull requests and always run the full suite.# GitHub cannot filter `labeled` events by label name, so any other label starts a run whose jobs# are all skipped; it gets its own concurrency group (below) so it never cancels the real run.@@ -112,6 +114,8 @@ jobs:packages: ${{ steps.paths.outputs.packages }}oracle: ${{ steps.paths.outputs.oracle }}doctests: ${{ steps.paths.outputs.doctests }}+ # The passing run a merge of main carries forward (its URL), when this push is only that.+ carried: ${{ steps.paths.outputs.carried }}# The fast self-hosted runners are kept for main and the merge queue (the pre-merge gate);# pull requests, same-repo ones included, take the GitHub-hosted or untrusted paths.local: ${{ runner.environment == 'self-hosted' && github.event_name != 'pull_request' }}@@ -235,6 +239,19 @@ jobs:oracle=falsegoldens=falsefi+ # A push that only merges main into the change (Merge branch 'main', Update branch) when+ # the change itself already passed: nothing new to test here, and main tests the merged+ # result after it lands. Over three days, 872 of 1,241 such merges brought in nothing that+ # touched the pull request's files, and each restarted the whole run.+ carried=+ if [ "$EVENT_NAME" = pull_request ] && [ "$native" = true ]; then+ carried=$(python3 -I scripts/ci/main_merge.py --base "$BASE_SHA" --head "$HEAD_SHA" --repo "$REPO" | sed -n 's/^carried=//p')+ if [ -n "$carried" ]; then+ echo "Only a merge of main into a change that passed in $carried: repository checks only."+ native=false+ goldens=false+ fi+ fi{echo "native=$native"echo "kernel=$kernel"@@ -242,6 +259,7 @@ jobs:echo "windows=$windows"echo "oracle=$oracle"echo "doctests=$doctests"+ echo "carried=$carried"echo "full=$full"echo "quick=$quick"echo "packages=$packages"@@ -285,6 +303,8 @@ jobs:run: cargo xtask web-offline-test- name: Affected-package selection self-testrun: python3 -I scripts/ci/test_affected.py+ - name: Merge-of-main detection self-test+ run: python3 -I scripts/ci/test_main_merge.py- name: Claim and triage bot testsrun: node --test scripts/claim/*.test.js scripts/triage/*.test.js@@ -779,6 +799,12 @@ jobs:test "$WINDOWS_FXC" = successtest "$WINDOWS_STARTUP" = successfi+ - name: Note a carried result+ if: needs.changes.outputs.carried != ''+ env:+ CARRIED: ${{ needs.changes.outputs.carried }}+ run: |+ echo "This push only merges main into a change that already passed; the heavy checks were not repeated. Passing run: $CARRIED" >> "$GITHUB_STEP_SUMMARY"wasm:name: Compile WebAssembly (manual)diff --git a/scripts/ci/main_merge.py b/scripts/ci/main_merge.pynew file mode 100644index 0000000000..35d0504be3--- /dev/null+++ b/scripts/ci/main_merge.py@@ -0,0 +1,92 @@+#!/usr/bin/env python3+"""Is this pull request push only a merge of main into a change that already passed CI?++ python3 -I scripts/ci/main_merge.py --base BASE_SHA --head HEAD_SHA --repo OWNER/NAME++Prints `carried=<url of the passing run>` when all of these hold, else `carried=`:+ - HEAD is a merge commit whose second parent is on main (an ancestor of BASE): "Merge branch+ 'main'", or GitHub's Update branch button;+ - the pull request's own change is the same before and after the merge (equal `git patch-id`),+ so the merge resolved no conflict and brought nothing into the change itself;+ - a ci.yml run of the first parent (the change before the merge) passed with the test shards.++Then the run needs only the repository checks: the change was tested, and main tests the merged+result after it lands. Any doubt (an error, an API failure, an unexpected shape) prints+`carried=` and the full checks run. Reads GH_TOKEN from the environment for the API.+"""+import argparse+import json+import os+import subprocess+import sys+import urllib.request++API = "https://api.github.com"+SHARD_PREFIX = "Native Linux tests"+++def git(*args):+ return subprocess.run(["git", *args], capture_output=True, text=True, check=True).stdout+++def patch_id(a, b):+ """The stable patch id of `git diff a b` ("" for an empty diff)."""+ diff = subprocess.run(["git", "diff", "--no-renames", a, b], capture_output=True, check=True).stdout+ if not diff.strip():+ return ""+ out = subprocess.run(["git", "patch-id", "--stable"], input=diff, capture_output=True, check=True).stdout+ return out.split()[0].decode() if out.split() else ""+++def merge_of_main(base, head):+ """The first parent of HEAD when HEAD only merges main into an unchanged change, else None."""+ parents = git("rev-list", "--parents", "-n", "1", head).split()[1:]+ if len(parents) != 2:+ return None+ change, merged = parents+ if subprocess.run(["git", "merge-base", "--is-ancestor", merged, base]).returncode != 0:+ return None+ fork_point = git("merge-base", change, merged).strip()+ before, after = patch_id(fork_point, change), patch_id(merged, head)+ return change if before and before == after else None+++def get(url, token):+ req = urllib.request.Request(url, headers={"Accept": "application/vnd.github+json", "Authorization": f"Bearer {token}"})+ with urllib.request.urlopen(req, timeout=20) as r:+ return json.load(r)+++def passing_run(repo, sha, token):+ """URL of a successful pull request ci.yml run of `sha` whose test shards all passed."""+ runs = get(f"{API}/repos/{repo}/actions/workflows/ci.yml/runs?head_sha={sha}&event=pull_request&status=success&per_page=10", token)+ for run in runs.get("workflow_runs", []):+ jobs = get(f"{API}/repos/{repo}/actions/runs/{run['id']}/jobs?per_page=100", token).get("jobs", [])+ shards = [j for j in jobs if j.get("name", "").startswith(SHARD_PREFIX)]+ if shards and all(j.get("conclusion") == "success" for j in shards):+ return run.get("html_url", "")+ return ""+++def main():+ ap = argparse.ArgumentParser()+ ap.add_argument("--base", required=True)+ ap.add_argument("--head", required=True)+ ap.add_argument("--repo", required=True)+ a = ap.parse_args()+ carried = ""+ try:+ change = merge_of_main(a.base, a.head)+ token = os.environ.get("GH_TOKEN", "")+ if change and token:+ carried = passing_run(a.repo, change, token)+ if carried:+ print(f"{a.head} merges main into {change}, which passed: {carried}", file=sys.stderr)+ except (subprocess.CalledProcessError, OSError, ValueError, KeyError) as e:+ print(f"not carried ({e})", file=sys.stderr)+ carried = ""+ print(f"carried={carried}")+++if __name__ == "__main__":+ main()diff --git a/scripts/ci/test_main_merge.py b/scripts/ci/test_main_merge.pynew file mode 100644index 0000000000..3e883e5b74--- /dev/null+++ b/scripts/ci/test_main_merge.py@@ -0,0 +1,110 @@+#!/usr/bin/env python3+"""Self-test for main_merge.py. Run: python3 -I scripts/ci/test_main_merge.py (from the repo root).++Builds small throwaway git repositories; needs only git.+"""+import os+import subprocess+import sys+import tempfile+import unittest++sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))+import main_merge # noqa: E402+++class Repo:+ def __init__(self, root):+ self.root = root+ self.git("init", "-q", "-b", "main")+ self.git("config", "user.email", "[email protected]")+ self.git("config", "user.name", "t")+ self.git("config", "commit.gpgsign", "false")++ def git(self, *args):+ return subprocess.run(["git", *args], cwd=self.root, capture_output=True, text=True, check=True).stdout.strip()++ def write(self, path, text):+ with open(os.path.join(self.root, path), "w") as f:+ f.write(text)++ def commit(self, msg, **files):+ for path, text in files.items():+ self.write(path, text)+ self.git("add", "-A")+ self.git("commit", "-q", "-m", msg)+ return self.git("rev-parse", "HEAD")+++LINES = "".join(f"line {i}\n" for i in range(40))+++class MergeOfMain(unittest.TestCase):+ def setUp(self):+ self.tmp = tempfile.TemporaryDirectory()+ self.r = Repo(self.tmp.name)+ self.r.commit("base", **{"a.txt": LINES, "b.txt": LINES})+ self.r.git("checkout", "-q", "-b", "pr")+ self.change = self.r.commit("pr change", **{"a.txt": LINES.replace("line 5\n", "line five\n")})+ self.cwd = os.getcwd()+ os.chdir(self.tmp.name)++ def tearDown(self):+ os.chdir(self.cwd)+ self.tmp.cleanup()++ def main_commit(self, **files):+ self.r.git("checkout", "-q", "main")+ sha = self.r.commit("main moves", **files)+ self.r.git("checkout", "-q", "pr")+ return sha++ def merge_main(self):+ self.r.git("merge", "-q", "--no-edit", "main")+ return self.r.git("rev-parse", "HEAD")++ def test_clean_merge_of_unrelated_main_change_is_carried(self):+ base = self.main_commit(**{"b.txt": LINES.replace("line 30\n", "line thirty\n")})+ head = self.merge_main()+ self.assertEqual(main_merge.merge_of_main(base, head), self.change)++ def test_conflict_resolution_is_not_carried(self):+ base = self.main_commit(**{"a.txt": LINES.replace("line 5\n", "line 5 on main\n")})+ subprocess.run(["git", "merge", "-q", "main"], cwd=self.tmp.name, capture_output=True)+ self.r.write("a.txt", LINES.replace("line 5\n", "line five on both\n"))+ self.r.git("add", "-A")+ self.r.git("commit", "-q", "--no-edit")+ head = self.r.git("rev-parse", "HEAD")+ self.assertIsNone(main_merge.merge_of_main(base, head))++ def test_main_change_next_to_the_change_is_not_carried(self):+ # Main edits a context line of the pull request's hunk: the change's patch differs.+ base = self.main_commit(**{"a.txt": LINES.replace("line 7\n", "line seven\n")})+ head = self.merge_main()+ self.assertIsNone(main_merge.merge_of_main(base, head))++ def test_ordinary_commit_is_not_carried(self):+ head = self.r.commit("more", **{"a.txt": LINES.replace("line 5\n", "line 5b\n")})+ base = self.r.git("rev-parse", "main")+ self.assertIsNone(main_merge.merge_of_main(base, head))++ def test_merge_of_another_branch_is_not_carried(self):+ base = self.r.git("rev-parse", "main")+ self.r.git("checkout", "-q", "-b", "other", "main")+ self.r.commit("other work", **{"c.txt": "x\n"})+ self.r.git("checkout", "-q", "pr")+ self.r.git("merge", "-q", "--no-edit", "other")+ head = self.r.git("rev-parse", "HEAD")+ self.assertIsNone(main_merge.merge_of_main(base, head))++ def test_change_with_empty_diff_is_not_carried(self):+ self.r.git("checkout", "-q", "-b", "empty", "main")+ base = self.main_commit(**{"b.txt": LINES.replace("line 30\n", "line thirty\n")})+ self.r.git("checkout", "-q", "empty")+ self.r.git("merge", "-q", "--no-ff", "--no-edit", "main")+ head = self.r.git("rev-parse", "HEAD")+ self.assertIsNone(main_merge.merge_of_main(base, head))+++if __name__ == "__main__":+ unittest.main()