|
| 1 | +# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. |
| 2 | +# SPDX-License-Identifier: Apache-2.0 OR ISC |
| 3 | + |
| 4 | +""" |
| 5 | +The apply command: cherry-picks the fix onto one local branch per affected branch |
| 6 | +Nothing is pushed and no pull request is opened, the branches are yours to review |
| 7 | +""" |
| 8 | + |
| 9 | +from util.config import ( |
| 10 | + AFFECTED, |
| 11 | + BACKPORT_BRANCH_PREFIX, |
| 12 | + RUN_FILE, |
| 13 | + UNSURE, |
| 14 | + BackportError, |
| 15 | +) |
| 16 | +from util.git import ( |
| 17 | + WORKTREE_ROOT, |
| 18 | + abort_cherry_pick, |
| 19 | + add_worktree, |
| 20 | + branch_exists, |
| 21 | + branch_ref, |
| 22 | + cherry_pick, |
| 23 | + cherry_pick_was_empty, |
| 24 | + commit_exists, |
| 25 | + remove_worktree, |
| 26 | +) |
| 27 | +from util.render import ask_yn |
| 28 | + |
| 29 | +import json |
| 30 | +from typing import Dict, List, Optional, Tuple |
| 31 | + |
| 32 | +# How one branch turned out |
| 33 | +APPLIED = "applied" |
| 34 | +CONFLICT = "conflict" |
| 35 | +ALREADY_THERE = "already there" |
| 36 | +BRANCH_EXISTS = "branch exists" |
| 37 | + |
| 38 | + |
| 39 | +def load_run() -> dict: |
| 40 | + """ |
| 41 | + The run analyze saved, as {generated_at, fix, base, branches, verdicts} |
| 42 | + Written by save_run in util/config.py, where the fields are spelled out |
| 43 | +
|
| 44 | + Raises rather than returning a partial answer, in all three cases where acting on |
| 45 | + the run would mean guessing: there is no run, the file cannot be read, or the fix |
| 46 | + it names is no longer in this checkout |
| 47 | + """ |
| 48 | + try: |
| 49 | + run = json.loads(RUN_FILE.read_text(encoding="utf-8")) |
| 50 | + except FileNotFoundError: |
| 51 | + raise BackportError( |
| 52 | + "no saved analyze run to apply.\n Run 'backport analyze' first." |
| 53 | + ) |
| 54 | + except json.JSONDecodeError as exc: |
| 55 | + raise BackportError(f"{RUN_FILE} is not valid JSON: {exc}") |
| 56 | + |
| 57 | + # These two are the whole input: which commit to pick, and onto which branches |
| 58 | + for key in ("fix", "verdicts"): |
| 59 | + if key not in run: |
| 60 | + raise BackportError(f"{RUN_FILE} has no '{key}'. Re-run analyze.") |
| 61 | + |
| 62 | + # Analyzing a range squashes it into a commit nothing points at, so git can collect |
| 63 | + # it between analyze and apply |
| 64 | + if not commit_exists(run["fix"]): |
| 65 | + raise BackportError( |
| 66 | + f"the analyzed fix {run['fix'][:10]} is not in this checkout any more.\n" |
| 67 | + " Re-run analyze." |
| 68 | + ) |
| 69 | + return run |
| 70 | + |
| 71 | + |
| 72 | +def backport_branch_name(fix: str, release: str) -> str: |
| 73 | + """What the local branch holding a backport is called""" |
| 74 | + return f"{BACKPORT_BRANCH_PREFIX}{release}-{fix[:10]}" |
| 75 | + |
| 76 | + |
| 77 | +def branches_to_backport(verdicts: Dict[str, str], only: Optional[str]) -> List[str]: |
| 78 | + """ |
| 79 | + Which release branches to cherry-pick onto |
| 80 | + Returns the affected ones, or just the named branch. Unsure branches are left |
| 81 | + out: analyze could not settle them, so a cherry-pick would be a guess |
| 82 | + """ |
| 83 | + if only: |
| 84 | + if only not in verdicts: |
| 85 | + known = ", ".join(sorted(verdicts)) |
| 86 | + raise BackportError(f"'{only}' was not in the analyze run.\n Had: {known}") |
| 87 | + return [only] |
| 88 | + return [b for b, state in verdicts.items() if state == AFFECTED] |
| 89 | + |
| 90 | + |
| 91 | +def cherry_pick_onto(fix: str, release: str) -> Tuple[str, List[str]]: |
| 92 | + """ |
| 93 | + Cherry-picks the fix onto one release branch, in a worktree of its own |
| 94 | + Returns (outcome, conflicting files) where outcome is one of the four above |
| 95 | +
|
| 96 | + The worktree is what makes this safe to run while you are working: your own |
| 97 | + checkout never moves. It is removed once the pick is settled either way, and kept |
| 98 | + only when there is a conflict, because that is where you resolve it |
| 99 | +
|
| 100 | + The pick starts from the same remote-tracking ref analyze judged, not from origin. |
| 101 | + A fork is often behind on the release branches, and starting from a stale one would |
| 102 | + build the backport on the wrong base |
| 103 | + """ |
| 104 | + local_branch = backport_branch_name(fix, release) |
| 105 | + if branch_exists(local_branch): |
| 106 | + return BRANCH_EXISTS, [] |
| 107 | + |
| 108 | + worktree = WORKTREE_ROOT / local_branch |
| 109 | + add_worktree(worktree, local_branch, branch_ref(release)) |
| 110 | + picked, conflicts = cherry_pick(worktree, fix) |
| 111 | + |
| 112 | + if picked: |
| 113 | + remove_worktree(worktree) |
| 114 | + return APPLIED, [] |
| 115 | + if not conflicts and cherry_pick_was_empty(worktree): |
| 116 | + # The pick came out empty, so this branch already has the change |
| 117 | + abort_cherry_pick(worktree) |
| 118 | + remove_worktree(worktree) |
| 119 | + return ALREADY_THERE, [] |
| 120 | + return CONFLICT, conflicts |
| 121 | + |
| 122 | + |
| 123 | +def cmd_apply(args) -> int: |
| 124 | + """ |
| 125 | + Cherry-picks the analyzed fix onto every affected branch |
| 126 | + Returns 0 when every branch applied cleanly or was skipped, 1 when any conflicted |
| 127 | + """ |
| 128 | + run = load_run() |
| 129 | + fix, verdicts = run["fix"], run["verdicts"] |
| 130 | + releases = branches_to_backport(verdicts, args.branch) |
| 131 | + |
| 132 | + if not releases: |
| 133 | + print("No affected branches in the last analyze run, nothing to apply.") |
| 134 | + return 0 |
| 135 | + |
| 136 | + unsure = [b for b, state in verdicts.items() if state == UNSURE] |
| 137 | + print(f"Fix {fix[:10]}, analyzed {run.get('generated_at', 'at an unknown time')}") |
| 138 | + print(f"Backporting onto {len(releases)} branch(es): {', '.join(releases)}") |
| 139 | + if unsure: |
| 140 | + print( |
| 141 | + f"Leaving out {len(unsure)} branch(es) analyze could not settle: " |
| 142 | + f"{', '.join(unsure)}" |
| 143 | + ) |
| 144 | + if not args.yes and not ask_yn("Create these local branches?"): |
| 145 | + print("Aborted. Nothing was created.") |
| 146 | + return 0 |
| 147 | + |
| 148 | + outcomes = {} |
| 149 | + for release in releases: |
| 150 | + outcome, conflicts = cherry_pick_onto(fix, release) |
| 151 | + outcomes[release] = (outcome, conflicts) |
| 152 | + local_branch = backport_branch_name(fix, release) |
| 153 | + if outcome == APPLIED: |
| 154 | + print(f" {release}: applied, on {local_branch}") |
| 155 | + elif outcome == BRANCH_EXISTS: |
| 156 | + print(f" {release}: skipped, {local_branch} already exists") |
| 157 | + elif outcome == ALREADY_THERE: |
| 158 | + print(f" {release}: nothing to do, the change is already there") |
| 159 | + else: |
| 160 | + print(f" {release}: CONFLICT in {len(conflicts)} file(s)") |
| 161 | + for name in conflicts: |
| 162 | + print(f" {name}") |
| 163 | + print(f" resolve in {WORKTREE_ROOT / local_branch}") |
| 164 | + |
| 165 | + conflicted = [b for b, (o, _) in outcomes.items() if o == CONFLICT] |
| 166 | + print() |
| 167 | + print(f"{len(outcomes) - len(conflicted)} of {len(outcomes)} applied cleanly") |
| 168 | + if conflicted: |
| 169 | + print( |
| 170 | + "Resolve each conflict in the worktree named above, then " |
| 171 | + "'git cherry-pick --continue' there." |
| 172 | + ) |
| 173 | + print("Nothing was pushed. Review each branch before you open a pull request.") |
| 174 | + return 1 if conflicted else 0 |
0 commit comments