From 42f72e24ff0a230610f181a7bc9156027da98b8b Mon Sep 17 00:00:00 2001 From: Josh Knapp Date: Thu, 19 Nov 2026 21:11:26 -0800 Subject: [PATCH] attach-arm64: address review (never roll back a newer publish, mandatory --expect-index, --follow-tag, trunk-only, pin checks to planned amd64 digest) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6 --- .gitea/workflows/arm64-attach.yaml | 14 ++++- scripts/attach-arm64-index.sh | 49 ++++++++++++--- scripts/tests/attach-arm64-index.test.sh | 79 ++++++++++++++++++++---- 3 files changed, 120 insertions(+), 22 deletions(-) diff --git a/.gitea/workflows/arm64-attach.yaml b/.gitea/workflows/arm64-attach.yaml index 1ef3d54..fad71ac 100644 --- a/.gitea/workflows/arm64-attach.yaml +++ b/.gitea/workflows/arm64-attach.yaml @@ -3,7 +3,7 @@ run-name: attach arm64 to ${{ github.event.inputs.image }}:php${{ github.event.i # Manual only (never on push): publishes an arm64 image for an EXISTING tag of cac or cac-fpm # and merges it with the tag's CURRENT amd64 manifest into a new index. The amd64 image is # NOT rebuilt and NOT touched: its manifest digest (and config, layers, attestation) stay -# byte-identical; only the tag's index digest changes. Use it to restore an arm64 entry that a +# byte-identical (with force=true the old arm64 is replaced and the amd64 attestation entry is not carried); only the tag's index digest changes. Use it to restore an arm64 entry that a # later amd64-only publish dropped (the arm64 leg of build-push.yaml is best effort). # # One leg per run (image + phpver), and runs are serialised (concurrency group below), because @@ -33,6 +33,8 @@ concurrency: jobs: Attach-arm64: + # Only from trunk: the arm64 is built from the dispatched ref's Dockerfile. + if: github.ref == 'refs/heads/trunk' runs-on: ubuntu-latest timeout-minutes: 90 steps: @@ -179,12 +181,14 @@ jobs: TAG: ${{ steps.v.outputs.tag }} BINS: ${{ steps.v.outputs.bins }} ARM64_DIGEST: ${{ steps.arm64.outputs.digest }} + AMD64: ${{ steps.plan.outputs.amd64 }} run: | set -euo pipefail + [[ "$AMD64" =~ ^sha256:[0-9a-f]{64}$ ]] || { echo "::error::no planned amd64 digest"; exit 1; } [[ "$ARM64_DIGEST" =~ ^sha256:[0-9a-f]{64}$ ]] || { echo "::error::no arm64 digest from the build"; exit 1; } bins=(); for b in $BINS; do bins+=(--bin "$b"); done python3 -I scripts/verify-image-arch.py --image "$REPO@$ARM64_DIGEST" --platform linux/arm64 "${bins[@]}" - python3 -I scripts/verify-image-arch.py --image "$REPO:$TAG" --platform linux/amd64 "${bins[@]}" + python3 -I scripts/verify-image-arch.py --image "$REPO@$AMD64" --platform linux/amd64 "${bins[@]}" # The new arm64 was built now, the amd64 entry earlier: refuse a PHP version skew between them. - name: PHP version parity (amd64 native, arm64 under QEMU) @@ -192,9 +196,10 @@ jobs: REPO: ${{ steps.v.outputs.repo }} TAG: ${{ steps.v.outputs.tag }} ARM64_DIGEST: ${{ steps.arm64.outputs.digest }} + AMD64: ${{ steps.plan.outputs.amd64 }} run: | set -euo pipefail - want=$(docker run --rm --platform linux/amd64 --entrypoint php "$REPO:$TAG" -r 'echo PHP_VERSION;') + want=$(docker run --rm --platform linux/amd64 --entrypoint php "$REPO@$AMD64" -r 'echo PHP_VERSION;') got=$(docker run --rm --platform linux/arm64 --entrypoint php "$REPO@$ARM64_DIGEST" -r 'echo PHP_VERSION;') echo "amd64 (existing tag) PHP ${want}; new arm64 PHP ${got}" [[ "$want" =~ ^[0-9]+\.[0-9]+\.[0-9]+ ]] || { echo "::error::cannot read the amd64 PHP version"; exit 1; } @@ -211,7 +216,10 @@ jobs: ARM64_DIGEST: ${{ steps.arm64.outputs.digest }} run: | set -euo pipefail + [[ "$BEFORE" =~ ^sha256:[0-9a-f]{64}$ ]] || { echo "::error::no plan digest"; exit 1; } f=(); [ "$FORCE" = true ] && f=(--force) + # :latest tracks php85 in the normal build; keep that alias equal if (and only if) it is one. + [ "$TAG" = php85 ] && f+=(--follow-tag latest) scripts/attach-arm64-index.sh --repo "$REPO" --tag "$TAG" \ --arm64 "$ARM64_DIGEST" --expect-index "$BEFORE" "${f[@]}" docker buildx imagetools inspect "$REPO:$TAG" diff --git a/scripts/attach-arm64-index.sh b/scripts/attach-arm64-index.sh index af482e3..03c85ed 100755 --- a/scripts/attach-arm64-index.sh +++ b/scripts/attach-arm64-index.sh @@ -7,7 +7,7 @@ # manifest) are carried over by digest, the new arm64 (pushed by digest, never tagged) is added. # # attach-arm64-index.sh --repo --tag --arm64 sha256: \ -# [--expect-index sha256:] [--force] [--builder ] +# [--expect-index sha256:] [--force] [--follow-tag ] [--builder ] # attach-arm64-index.sh --repo --tag --plan-only [--force] (no --arm64 needed) # # Rules (all enforced here so the workflow stays thin and these are testable): @@ -20,8 +20,14 @@ # index derived from an older one. # * The new arm64 digest must inspect as linux/arm64 and differ from the amd64 digest. # * After the create the tag is re-read: its linux/amd64 manifest digest MUST be identical to the -# one before and an arm64 entry MUST be present. Otherwise the previous index is re-created -# (best effort) and the script exits 1. +# one before and an arm64 entry MUST be present. Otherwise exit 1. The previous index is +# re-created ONLY if our create lost the amd64 entry; a tag that now has a different amd64 (a +# concurrent publish) is never rolled back. Residual window: registry has no conditional PUT, +# so a publish landing between the last read and the create is still overwritten: do not run +# this while build-push runs for the same family. +# * --follow-tag T (e.g. latest for php85): if :T currently has the very same index digest as +# had BEFORE the attach (i.e. it is an alias of it), it is re-pointed to the new index so +# the alias keeps equalling the tag. If it differs it is left alone (warning). Never created. # * --plan-only: run every check above, print the plan, create nothing (an already multi-arch # tag still exits 3, so a pre-check step fails before an expensive build). # @@ -31,7 +37,7 @@ set -euo pipefail IMAGETOOLS=${IMAGETOOLS:-docker buildx imagetools} -repo=""; tag=""; arm64=""; expect=""; force=0; plan_only=0; builder="" +repo=""; tag=""; arm64=""; expect=""; force=0; plan_only=0; builder=""; follow="" die() { echo "attach-arm64-index: $1" >&2; exit "${2:-1}"; } note() { echo "attach-arm64-index: $*"; } @@ -44,6 +50,7 @@ while [ $# -gt 0 ]; do --expect-index) expect=${2-}; shift 2 ;; --force) force=1; shift ;; --plan-only) plan_only=1; shift ;; + --follow-tag) follow=${2-}; shift 2 ;; --builder) builder=${2-}; shift 2 ;; *) die "unknown argument: $1" 2 ;; esac @@ -55,7 +62,12 @@ dre='^sha256:[0-9a-f]{64}$' if [ "$plan_only" = 1 ] && [ -z "$arm64" ]; then :; else [[ $arm64 =~ $dre ]] || die "--arm64 digest missing or malformed ('$arm64')" 2 fi +if [ -n "$follow" ]; then + [[ $follow =~ ^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$ ]] || die "bad --follow-tag '$follow'" 2 + [ "$follow" != "$tag" ] || die "--follow-tag equals --tag" 2 +fi if [ -n "$expect" ]; then [[ $expect =~ $dre ]] || die "bad --expect-index '$expect'" 2; fi +if [ "$plan_only" != 1 ] && [ -z "$expect" ]; then die "--expect-index is required (the digest the plan step read)" 2; fi bflag=(); [ -n "$builder" ] && bflag=(--builder "$builder") # shellcheck disable=SC2086 @@ -143,7 +155,7 @@ if [ "$plan_only" = 1 ]; then emit "platforms=plan-only"; exit 0; fi # unless the arm64 entry is being replaced (--force): then only the amd64 manifest is carried over. if [ "$kind" = index ] && [ -z "$had_arm64" ]; then src_old="$repo@$before_index"; else src_old="$repo@$amd64"; fi note "creating $ref from $src_old + $repo@$arm64" -it create -t "$ref" "$src_old" "$repo@$arm64" +it create -t "$ref" "$src_old" "$repo@$arm64" || { echo "::error::attach-arm64-index: create failed; tag state unverified (was $before_index)" >&2; exit 1; } read_tag "$ref" after_index=$g_digest @@ -152,11 +164,34 @@ ok=1 [ "$g_amd64" = "$amd64" ] || ok=0 [ "$(wc -w <<<"$g_arm64")" -eq 1 ] || ok=0 if [ "$ok" != 1 ]; then - echo "::error::attach-arm64-index: $ref after create: kind=$g_kind amd64='$g_amd64' arm64='$g_arm64' (want amd64 $amd64 unchanged + one arm64); restoring $before_index" >&2 - if [ "$kind" = index ]; then + echo "::error::attach-arm64-index: $ref after create: kind=$g_kind amd64='$g_amd64' arm64='$g_arm64' (want amd64 $amd64 unchanged + one arm64)" >&2 + # Restore ONLY when our create demonstrably lost the amd64 entry. If the tag now carries a + # different amd64 (a build-push published meanwhile) it is newer than anything we hold: never + # roll it back. + if [ "$kind" = index ] && [ -z "$g_amd64" ]; then + echo "::error::attach-arm64-index: amd64 entry lost; restoring $before_index" >&2 it create -t "$ref" "$repo@$before_index" || echo "::error::attach-arm64-index: RESTORE FAILED, $ref needs manual repair (previous index $before_index)" >&2 + if [ "$(tag_digest "$ref")" = "$before_index" ]; then echo "attach-arm64-index: restored $before_index" >&2 + else echo "::error::attach-arm64-index: after restore $ref is NOT $before_index; manual repair needed" >&2; fi + elif [ "$g_amd64" != "$amd64" ]; then + echo "::error::attach-arm64-index: $ref moved to a different amd64 ($g_amd64) while attaching; NOT restoring (it is newer). Re-check the tag and re-run." >&2 + else + echo "::error::attach-arm64-index: tag state unexpected; NOT restoring automatically. Previous index was $before_index." >&2 fi exit 1 fi note "$ref now index=$after_index (was $before_index); amd64 manifest unchanged $amd64; arm64=$g_arm64" emit "after_index=$after_index"; emit "platforms=linux/amd64,linux/arm64" + +# Alias tag (e.g. latest == php85): re-point only if it was an exact alias of the tag before. +if [ -n "$follow" ]; then + fdig=$(tag_digest "$repo:$follow") + if [ "$fdig" = "$before_index" ]; then + note "$repo:$follow was an alias of $tag ($before_index): re-pointing it to $after_index" + it create -t "$repo:$follow" "$repo@$after_index" + [ "$(tag_digest "$repo:$follow")" = "$after_index" ] || die "$repo:$follow does not equal $after_index after the re-point" + emit "followed_tag=$follow" + else + echo "::warning::attach-arm64-index: $repo:$follow is '${fdig:-missing}', not an alias of $tag ($before_index): left untouched" + fi +fi diff --git a/scripts/tests/attach-arm64-index.test.sh b/scripts/tests/attach-arm64-index.test.sh index 5de5707..5e94817 100755 --- a/scripts/tests/attach-arm64-index.test.sh +++ b/scripts/tests/attach-arm64-index.test.sh @@ -95,6 +95,7 @@ for t, c in list(tags.items()): json.dump(tags, open(S + '/tags.json', 'w')); json.dump(blobs, open(S + '/blobs.json', 'w')); json.dump(arch, open(S + '/arch.json', 'w')) PY } +EXP=sha256:$(printf '0%.0s' {1..64}) tagdig() { python3 -I -c ' import json,hashlib,sys t=json.load(open(sys.argv[1]))[sys.argv[2]] @@ -109,6 +110,7 @@ creates() { grep -c '^create' "$T/st/log" || true; } # ---- happy path: amd64-only tag + new arm64 -> index with amd64 UNCHANGED + arm64 mk amd64only; before=$(tagdig) chk "attach to amd64-only tag -> rc 0" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$before")" 0 + chk " amd64 manifest digest unchanged, arm64 added" "$(plats)" "amd64=$A arm64=$B" chk " amd64 attestation carried over" "$(python3 -I -c 'import json,sys;print(sum(1 for m in json.load(open(sys.argv[1]))[sys.argv[2]]["manifests"] if m["digest"]==sys.argv[3]))' "$T/st/tags.json" "$R:php82" "$AT")" 1 chk " exactly one create, from the old index + the arm64 digest" "$(grep -c "^create -t $R:php82 $R@$before $R@$B\$" "$T/st/log")" 1 @@ -117,11 +119,11 @@ chk " prints before/after/amd64" "$(grep -c "^before_index=$before\$\|^amd64=$A # ---- already multi-arch: refuse (3), nothing written mk both; before=$(tagdig) -chk "tag already has arm64 -> rc 3" "$(run --repo $R --tag php82 --arm64 "$B")" 3 +chk "tag already has arm64 -> rc 3" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$before")" 3 chk " no create" "$(creates)" 0 chk " tag untouched" "$(tagdig)" "$before" # ---- --force replaces the arm64 entry, amd64 manifest untouched -chk "--force on multi-arch -> rc 0" "$(run --repo $R --tag php82 --arm64 "$B" --force)" 0 +chk "--force on multi-arch -> rc 0" "$(run --repo $R --tag php82 --arm64 "$B" --force --expect-index "$(tagdig)")" 0 chk " arm64 replaced, amd64 same" "$(plats)" "amd64=$A arm64=$B" chk " create used the amd64 child only (old arm64 not a source)" "$(grep -c "^create -t $R:php82 $R@$A $R@$B\$" "$T/st/log")" 1 @@ -137,9 +139,9 @@ chk "--plan-only on multi-arch tag still refuses (3)" "$(run --repo $R --tag php # ---- bad inputs / bad tags mk amd64only -chk "arm64 digest that is not arm64 -> rc 1" "$(run --repo $R --tag php82 --arm64 "$C")" 1 -chk "arm64 digest == amd64 digest -> rc 1" "$(run --repo $R --tag php82 --arm64 "$A")" 1 -chk "arm64 digest unknown to registry -> rc 1" "$(run --repo $R --tag php82 --arm64 "$(d 7)")" 1 +chk "arm64 digest that is not arm64 -> rc 1" "$(run --repo $R --tag php82 --arm64 "$C" --expect-index "$EXP")" 1 +chk "arm64 digest == amd64 digest -> rc 1" "$(run --repo $R --tag php82 --arm64 "$A" --expect-index "$EXP")" 1 +chk "arm64 digest unknown to registry -> rc 1" "$(run --repo $R --tag php82 --arm64 "$(d 7)" --expect-index "$EXP")" 1 chk "malformed --arm64 -> rc 2" "$(run --repo $R --tag php82 --arm64 nope)" 2 chk "--arm64 missing without --plan-only -> rc 2" "$(run --repo $R --tag php82)" 2 chk "malformed --expect-index -> rc 2" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index x)" 2 @@ -147,29 +149,82 @@ chk "bad tag (injection) -> rc 2" "$(run --repo $R --tag 'a b;c' --arm64 "$B")" chk "unknown argument -> rc 2" "$(run --repo $R --tag php82 --arm64 "$B" --bogus)" 2 chk " none of those created anything" "$(creates)" 0 mk missing -chk "missing tag -> rc 1" "$(run --repo $R --tag php82 --arm64 "$B")" 1 +chk "missing tag -> rc 1" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$EXP")" 1 mk noamd -chk "tag without amd64 -> rc 1" "$(run --repo $R --tag php82 --arm64 "$B")" 1 +chk "tag without amd64 -> rc 1" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$EXP")" 1 mk twoamd -chk "tag with two amd64 entries -> rc 1" "$(run --repo $R --tag php82 --arm64 "$B")" 1 +chk "tag with two amd64 entries -> rc 1" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$EXP")" 1 chk " no create" "$(creates)" 0 # ---- plain single amd64 manifest tag mk single; before=$(tagdig) -chk "single amd64 manifest tag -> rc 0" "$(run --repo $R --tag php82 --arm64 "$B")" 0 +chk "single amd64 manifest tag -> rc 0" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$before")" 0 chk " create from the manifest digest + arm64" "$(grep -c "^create -t $R:php82 $R@$before $R@$B\$" "$T/st/log")" 1 # ---- post-create verification: a create that loses amd64 is detected and rolled back mk amd64only; before=$(tagdig) -rc=$(MANGLE=drop-amd64 run --repo $R --tag php82 --arm64 "$B"); chk "create dropped amd64 -> rc 1" "$rc" 1 +rc=$(MANGLE=drop-amd64 run --repo $R --tag php82 --arm64 "$B" --expect-index "$before"); chk "create dropped amd64 -> rc 1" "$rc" 1 chk " restored: tag is the previous index again" "$(plats)" "amd64=$A" chk " second create was the restore from the old index" "$(grep -c "^create -t $R:php82 $R@$before\$" "$T/st/log")" 1 mk amd64only -rc=$(MANGLE=fail run --repo $R --tag php82 --arm64 "$B"); chk "create failing -> rc != 0" "$([ "$rc" != 0 ] && echo yes)" yes +rc=$(MANGLE=fail run --repo $R --tag php82 --arm64 "$B" --expect-index "$(tagdig)"); chk "create failing -> rc != 0" "$([ "$rc" != 0 ] && echo yes)" yes chk " tag untouched" "$(plats)" "amd64=$A" +chk "missing --expect-index -> rc 2" "$(run --repo $R --tag php82 --arm64 "$B")" 2 +# concurrent publish during attach: tag ends with a different amd64 -> never rolled back +mk amd64only; before=$(tagdig) +cat >"$T/race.sh" <<'RS' +#!/usr/bin/env bash +python3 "$STUBPY" "$@"; rc=$? +if [ "$1" = create ] && [ ! -f "$STATE/raced" ]; then touch "$STATE/raced"; python3 - <<'PY' +import json, os +S = os.environ['STATE']; t = json.load(open(S + '/tags.json')) +k = [x for x in t if x.endswith(':php82')][0] +t[k] = {'manifests': [{'digest': 'sha256:' + 'd' * 64, 'platform': {'os': 'linux', 'architecture': 'amd64'}}]} +json.dump(t, open(S + '/tags.json', 'w')) +PY +fi +exit $rc +RS +chmod +x "$T/race.sh" +rc=$(STUBPY=$T/stub.py IMAGETOOLS="$T/race.sh" run --repo $R --tag php82 --arm64 "$B" --expect-index "$before"); chk "publish raced in during attach -> rc 1" "$rc" 1 +chk " newer amd64 NOT rolled back" "$(plats)" "amd64=sha256:$(printf 'd%.0s' {1..64})" +chk " no restore create" "$(grep -c "^create -t $R:php82 $R@$before\$" "$T/st/log" || true)" 0 + +# ---- --follow-tag: an alias (latest == php85) follows; a different latest is left alone +mk amd64only +python3 -I - "$T/st/tags.json" "$R" <<'PY' +import json, sys +t = json.load(open(sys.argv[1])); t[sys.argv[2] + ':latest'] = t[sys.argv[2] + ':php82']; json.dump(t, open(sys.argv[1], 'w')) +PY +chk "--follow-tag latest (alias) -> rc 0" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$(tagdig)" --follow-tag latest)" 0 +chk " latest now equals the new php82 index" "$(python3 -I -c ' +import json,sys +t=json.load(open(sys.argv[1])); print(t[sys.argv[2]+":latest"]==t[sys.argv[2]+":php82"])' "$T/st/tags.json" "$R")" True +chk " latest has amd64 unchanged + arm64" "$(python3 -I -c ' +import json,sys +t=json.load(open(sys.argv[1])); print(" ".join(m["platform"]["architecture"]+"="+m["digest"] for m in t[sys.argv[2]+":latest"]["manifests"] if "annotations" not in m))' "$T/st/tags.json" "$R")" "amd64=$A arm64=$B" +mk amd64only +python3 -I - "$T/st/tags.json" "$R" "$A" <<'PY' +import json, sys +t = json.load(open(sys.argv[1])); t[sys.argv[2] + ':latest'] = {'manifests': [{'digest': sys.argv[3], 'platform': {'os': 'linux', 'architecture': 'amd64'}}]}; json.dump(t, open(sys.argv[1], 'w')) +PY +lbefore=$(python3 -I -c ' +import json,hashlib,sys +t=json.load(open(sys.argv[1]))[sys.argv[2]+":latest"] +print("sha256:"+hashlib.sha256(json.dumps(t,sort_keys=True).encode()).hexdigest())' "$T/st/tags.json" "$R") +chk "--follow-tag latest (not an alias) -> rc 0, tag attached" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$(tagdig)" --follow-tag latest)" 0 +chk " latest untouched" "$(python3 -I -c ' +import json,hashlib,sys +t=json.load(open(sys.argv[1]))[sys.argv[2]+":latest"] +print("sha256:"+hashlib.sha256(json.dumps(t,sort_keys=True).encode()).hexdigest())' "$T/st/tags.json" "$R")" "$lbefore" +mk amd64only +chk "--follow-tag with missing latest -> rc 0, left alone" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$(tagdig)" --follow-tag latest)" 0 +chk "bad --follow-tag -> rc 2" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$(tagdig)" --follow-tag 'x y')" 2 +chk "--follow-tag == --tag -> rc 2" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$(tagdig)" --follow-tag php82)" 2 + # ---- GITHUB_OUTPUT -mk amd64only; GITHUB_OUTPUT=$T/gho "$HERE/attach-arm64-index.sh" --repo $R --tag php82 --arm64 "$B" >/dev/null 2>&1 +mk amd64only; GITHUB_OUTPUT=$T/gho "$HERE/attach-arm64-index.sh" --repo $R --tag php82 --arm64 "$B" --expect-index "$(tagdig)" >/dev/null 2>&1 chk "GITHUB_OUTPUT has after_index and platforms" "$(grep -c '^after_index=\|^platforms=linux/amd64,linux/arm64$' "$T/gho")" 2 [ "$fail" -eq 0 ] && echo "ALL PASS" || { echo FAILURES; exit 1; }