From 02de5c65684b695377571a65adcc9dafc042db4f Mon Sep 17 00:00:00 2001 From: Josh Knapp Date: Thu, 19 Nov 2026 21:03:27 -0800 Subject: [PATCH 1/2] ci: arm64-attach workflow - restore an arm64 entry on an existing tag without touching amd64 New manual workflow arm64-attach.yaml (cac / cac-fpm, one php leg per run, serialised): builds ONLY arm64 (QEMU, push by digest, same Dockerfile and build-args), checks the ELF machine type of the arm64 entry (AArch64) and of the existing amd64 entry (x86-64), checks PHP version parity, then re-creates the tag index from the existing amd64 entries (carried over by digest) + the new arm64 via scripts/attach-arm64-index.sh. The amd64 manifest digest is verified identical afterwards (previous index restored if not). Refuses when the tag already has arm64 unless force=true, and when the tag moved since the plan. - scripts/attach-arm64-index.sh (+ stub-registry test) - scripts/verify-image-arch.py (+ test): ELF e_machine check via docker cp, nothing is executed; idea from haproxy-manager-base PR #22 - multiarch-workflow.test.py: static wiring checks for the new workflow - Shell-Checks: new scripts and tests added Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6 --- .gitea/workflows/arm64-attach.yaml | 217 +++++++++++++++++++++++ .gitea/workflows/build-push.yaml | 10 ++ scripts/attach-arm64-index.sh | 162 +++++++++++++++++ scripts/tests/attach-arm64-index.test.sh | 175 ++++++++++++++++++ scripts/tests/multiarch-workflow.test.py | 88 +++++++++ scripts/tests/verify-image-arch.test.sh | 65 +++++++ scripts/verify-image-arch.py | 107 +++++++++++ 7 files changed, 824 insertions(+) create mode 100644 .gitea/workflows/arm64-attach.yaml create mode 100755 scripts/attach-arm64-index.sh create mode 100755 scripts/tests/attach-arm64-index.test.sh create mode 100755 scripts/tests/verify-image-arch.test.sh create mode 100755 scripts/verify-image-arch.py diff --git a/.gitea/workflows/arm64-attach.yaml b/.gitea/workflows/arm64-attach.yaml new file mode 100644 index 0000000..1ef3d54 --- /dev/null +++ b/.gitea/workflows/arm64-attach.yaml @@ -0,0 +1,217 @@ +name: Attach arm64 to an existing tag +run-name: attach arm64 to ${{ github.event.inputs.image }}:php${{ github.event.inputs.phpver }} +# 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 +# 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 +# QEMU legs that ran together are what failed on their network steps in the first place. +# Refuses when the tag already has an arm64 entry unless force=true. Tags are never created: +# the tag must exist and already have an amd64 entry. Tag names are not inputs: php. +on: + workflow_dispatch: + inputs: + image: + description: 'cac or cac-fpm' + required: true + type: string + phpver: + description: 'PHP version without dots: 82, 83, 84, 85 or 86 (tag = php)' + required: true + type: string + force: + description: 'true = replace an arm64 entry the tag already has (default: refuse)' + required: false + default: 'false' + type: string + +concurrency: + group: arm64-attach + cancel-in-progress: false + +jobs: + Attach-arm64: + runs-on: ubuntu-latest + timeout-minutes: 90 + steps: + - name: Checkout + uses: actions/checkout@v4 + + # Inputs reach the shell via env only, and are regex-checked before use. + - name: Validate inputs + id: v + env: + IN_IMAGE: ${{ github.event.inputs.image }} + IN_PHPVER: ${{ github.event.inputs.phpver }} + IN_FORCE: ${{ github.event.inputs.force }} + run: | + set -euo pipefail + case "$IN_IMAGE" in + cac) dockerfile=Dockerfile; bins="/usr/sbin/httpd /usr/bin/php" ;; + cac-fpm) dockerfile=Dockerfile.fpm; bins="/usr/sbin/php-fpm /usr/bin/php" ;; + *) echo "::error::image must be cac or cac-fpm"; exit 1 ;; + esac + [[ "$IN_PHPVER" =~ ^8[2-6]$ ]] || { echo "::error::phpver must be one of 82 83 84 85 86"; exit 1; } + case "${IN_FORCE:-false}" in true|false) ;; *) echo "::error::force must be true or false"; exit 1 ;; esac + { + echo "repo=repo.anhonesthost.net/cloud-hosting-platform/${IN_IMAGE}" + echo "tag=php${IN_PHPVER}" + echo "image=${IN_IMAGE}" + echo "phpver=${IN_PHPVER}" + echo "dockerfile=${dockerfile}" + echo "bins=${bins}" + echo "force=${IN_FORCE:-false}" + } >> "$GITHUB_OUTPUT" + echo "attach arm64 to ${IN_IMAGE}:php${IN_PHPVER} (force=${IN_FORCE:-false})" + + - name: Login to Gitea + uses: docker/login-action@v3 + with: + registry: repo.anhonesthost.net + username: ${{ secrets.CI_USER }} + password: ${{ secrets.CI_TOKEN }} + + # Cheap pre-check BEFORE the 10-20 minute build: tag exists, has exactly one amd64 entry, + # and has no arm64 entry yet (exit 3 otherwise). Writes nothing. The index digest read here + # is handed to the final step, which refuses if the tag moved in between. + - name: Plan (read the tag, no writes) + id: plan + env: + REPO: ${{ steps.v.outputs.repo }} + TAG: ${{ steps.v.outputs.tag }} + FORCE: ${{ steps.v.outputs.force }} + run: | + set -euo pipefail + f=(); [ "$FORCE" = true ] && f=(--force) + scripts/attach-arm64-index.sh --repo "$REPO" --tag "$TAG" --plan-only "${f[@]}" + + - name: Resolve base image digest (Docker Hub, direct) + id: base + env: + BASE_TAG: almalinux/10-base:latest + run: | + set -uo pipefail + if ref=$(.gitea/scripts/resolve-base-image.sh "$BASE_TAG") && [[ "$ref" =~ ^[a-z0-9][a-z0-9._/-]*@sha256:[0-9a-f]{64}$ ]]; then + echo "base-image: ${BASE_TAG} -> ${ref}" + echo "image=${ref}" >> "$GITHUB_OUTPUT" + echo "pinned=true" >> "$GITHUB_OUTPUT" + else + echo "::warning::base image ${BASE_TAG}: Docker Hub digest lookup failed - pulling the tag directly" + echo "image=${BASE_TAG}" >> "$GITHUB_OUTPUT" + echo "pinned=false" >> "$GITHUB_OUTPUT" + fi + + - name: Probe package cache + id: pkgcache + env: + BASE_PINNED: ${{ steps.base.outputs.pinned }} + run: | + url=""; mirror="" + if curl -fsS --max-time 5 --cacert keys/pkg-cache/ca.crt -o /dev/null https://192.168.1.40/; then url="https://192.168.1.40"; fi + if [ "$BASE_PINNED" = true ] && curl -fsS --max-time 5 --cacert keys/pkg-cache/ca.crt -o /dev/null https://192.168.1.40:5000/v2/; then mirror="192.168.1.40:5000"; fi + echo "pkg-cache: repos=${url:-} registry-mirror=${mirror:-}" + echo "url=${url}" >> "$GITHUB_OUTPUT" + echo "mirror=${mirror}" >> "$GITHUB_OUTPUT" + + - name: Set up QEMU + uses: docker/setup-qemu-action@v3 + with: + platforms: arm64 + + - name: Set up Docker Buildx (Docker Hub via pkg-cache mirror) + if: steps.pkgcache.outputs.mirror != '' + uses: docker/setup-buildx-action@v3 + with: + buildkitd-config-inline: | + [registry."docker.io"] + mirrors = ["192.168.1.40:5000"] + [registry."192.168.1.40:5000"] + ca = ["${{ github.workspace }}/keys/pkg-cache/ca.crt"] + + - name: Set up Docker Buildx + if: steps.pkgcache.outputs.mirror == '' + uses: docker/setup-buildx-action@v3 + + - name: Cache-bust value + id: bust + env: + RUN_ID: ${{ gitea.run_id }} + run: echo "value=$(date -u +%Y%m%dT%H%M%SZ)-${RUN_ID}" >> "$GITHUB_OUTPUT" + + # Same php.net floor as the normal build: the Dockerfile fails on anything older. + - name: Resolve current PHP release from php.net + id: phpmin + env: + PHPVER: ${{ steps.v.outputs.tag }} + run: | + set -euo pipefail + v="${PHPVER#php}"; branch="${v:0:1}.${v:1}" + json=$(curl -fsS --retry 5 --max-time 60 "https://www.php.net/releases/index.php?json&max=1&version=${branch}") + min=$(printf '%s' "$json" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(next(iter(d)) if isinstance(d,dict) and d else "")') + [[ "$min" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || { echo "::error::no usable php.net release for ${branch}"; exit 1; } + echo "php.net current ${branch}: ${min}" + echo "min=${min}" >> "$GITHUB_OUTPUT" + + # arm64 only, pushed UNTAGGED by digest. Required here (this run exists only for it): a + # failure fails the run and the tag is not touched. + - name: Build arm64 (push by digest) + id: arm64 + timeout-minutes: 60 + uses: docker/build-push-action@v6 + with: + file: ./${{ steps.v.outputs.dockerfile }} + platforms: linux/arm64 + build-args: | + PHPVER=${{ steps.v.outputs.phpver }} + CACHE_BUST=${{ steps.bust.outputs.value }} + BASE_IMAGE=${{ steps.base.outputs.image }} + PKG_CACHE=${{ steps.pkgcache.outputs.url }} + EXPECT_PHP_MIN=${{ steps.phpmin.outputs.min }} + outputs: type=image,name=repo.anhonesthost.net/cloud-hosting-platform/${{ steps.v.outputs.image }},push-by-digest=true,name-canonical=true,push=true + + # The arm64 entry must contain AArch64 binaries and the existing amd64 entry x86-64 ones: + # the manifest platform label alone does not prove it (scripts/verify-image-arch.py). + - name: Verify ELF architecture of both platforms + env: + REPO: ${{ steps.v.outputs.repo }} + TAG: ${{ steps.v.outputs.tag }} + BINS: ${{ steps.v.outputs.bins }} + ARM64_DIGEST: ${{ steps.arm64.outputs.digest }} + run: | + set -euo pipefail + [[ "$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[@]}" + + # 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) + env: + REPO: ${{ steps.v.outputs.repo }} + TAG: ${{ steps.v.outputs.tag }} + ARM64_DIGEST: ${{ steps.arm64.outputs.digest }} + run: | + set -euo pipefail + want=$(docker run --rm --platform linux/amd64 --entrypoint php "$REPO:$TAG" -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; } + [ "$want" = "$got" ] || { echo "::error::PHP version differs between the existing amd64 (${want}) and the new arm64 (${got}); not attaching. The amd64 image needs a rebuild first."; exit 1; } + + # Re-creates the tag index: existing amd64 entries by digest + the new arm64. Aborts if the + # tag moved since the plan; verifies the amd64 manifest digest is unchanged afterwards. + - name: Attach (create the new index) + env: + REPO: ${{ steps.v.outputs.repo }} + TAG: ${{ steps.v.outputs.tag }} + FORCE: ${{ steps.v.outputs.force }} + BEFORE: ${{ steps.plan.outputs.before_index }} + ARM64_DIGEST: ${{ steps.arm64.outputs.digest }} + run: | + set -euo pipefail + f=(); [ "$FORCE" = true ] && f=(--force) + 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/.gitea/workflows/build-push.yaml b/.gitea/workflows/build-push.yaml index ddcfa4e..928f057 100644 --- a/.gitea/workflows/build-push.yaml +++ b/.gitea/workflows/build-push.yaml @@ -78,6 +78,9 @@ jobs: scripts/php-emergency-guard.sh \ scripts/index-platforms.sh \ scripts/assemble-multiarch-index.sh \ + scripts/attach-arm64-index.sh \ + scripts/tests/attach-arm64-index.test.sh \ + scripts/tests/verify-image-arch.test.sh \ scripts/tests/image-label-amd64.test.sh \ scripts/tests/index-platforms.test.sh \ scripts/tests/lsphp-abi-gate.test.sh \ @@ -96,6 +99,13 @@ jobs: ./scripts/tests/image-label-amd64.test.sh ./scripts/tests/index-platforms.test.sh + # arm64-attach.yaml: attach an arm64 entry to an existing tag without touching the amd64 + # manifest; and the ELF machine-type check (an image labelled arm64 must hold AArch64 binaries). + - name: arm64 attach + ELF architecture tests + run: | + ./scripts/tests/attach-arm64-index.test.sh + ./scripts/tests/verify-image-arch.test.sh + # Static wiring of the multi-arch publish jobs (cac, cac-fpm, shared-httpd): # by-digest pushes, non-fatal arm64 leg, timeouts, exact tag scheme. - name: multi-arch workflow wiring test diff --git a/scripts/attach-arm64-index.sh b/scripts/attach-arm64-index.sh new file mode 100755 index 0000000..af482e3 --- /dev/null +++ b/scripts/attach-arm64-index.sh @@ -0,0 +1,162 @@ +#!/usr/bin/env bash +# Attach an arm64 image to an EXISTING tag without touching its amd64 content. +# +# Why: a build whose arm64 leg failed publishes the tag amd64-only (assemble-multiarch-index.sh). +# Re-running the whole build to get arm64 back would also rebuild amd64 (new digest, new PHP +# layers). This only re-creates the tag's INDEX: the existing amd64 manifest (and its attestation +# 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 ] +# 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): +# * The tag must exist, be an image index (or a plain amd64 manifest) and contain exactly one +# linux/amd64 entry. Anything else: exit 1, nothing written. +# * If the tag already has a linux/arm64 entry: exit 3, nothing written, unless --force (then the +# old arm64 entry is replaced; the amd64 manifest is still carried over unchanged). +# * --expect-index: the digest of the tag's current index as read by an earlier step. If the tag +# moved since (a build published meanwhile) exit 1: we never overwrite a newer publish with an +# 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. +# * --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). +# +# Output (stdout, key=value, also appended to $GITHUB_OUTPUT when set): +# before_index= amd64= after_index= platforms= +# Env: IMAGETOOLS overrides the command (default: "docker buildx imagetools"); tests use a stub. +set -euo pipefail + +IMAGETOOLS=${IMAGETOOLS:-docker buildx imagetools} +repo=""; tag=""; arm64=""; expect=""; force=0; plan_only=0; builder="" + +die() { echo "attach-arm64-index: $1" >&2; exit "${2:-1}"; } +note() { echo "attach-arm64-index: $*"; } + +while [ $# -gt 0 ]; do + case "$1" in + --repo) repo=${2-}; shift 2 ;; + --tag) tag=${2-}; shift 2 ;; + --arm64) arm64=${2-}; shift 2 ;; + --expect-index) expect=${2-}; shift 2 ;; + --force) force=1; shift ;; + --plan-only) plan_only=1; shift ;; + --builder) builder=${2-}; shift 2 ;; + *) die "unknown argument: $1" 2 ;; + esac +done + +dre='^sha256:[0-9a-f]{64}$' +[[ $repo =~ ^[a-z0-9][a-z0-9._:/-]*$ ]] || die "bad --repo '$repo'" 2 +[[ $tag =~ ^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$ ]] || die "bad --tag '$tag'" 2 +if [ "$plan_only" = 1 ] && [ -z "$arm64" ]; then :; else + [[ $arm64 =~ $dre ]] || die "--arm64 digest missing or malformed ('$arm64')" 2 +fi +if [ -n "$expect" ]; then [[ $expect =~ $dre ]] || die "bad --expect-index '$expect'" 2; fi +bflag=(); [ -n "$builder" ] && bflag=(--builder "$builder") + +# shellcheck disable=SC2086 +it() { $IMAGETOOLS "$1" "${bflag[@]}" "${@:2}"; } + +# tag_digest : manifest (index) digest of a ref; empty on failure. +tag_digest() { + it inspect "$1" --format '{{.Manifest.Digest}}' 2>/dev/null | tail -n 1 | tr -d '[:space:]' || true +} +# arch_of : image config architecture; empty on failure. +arch_of() { + it inspect "$1" --format '{{json .Image}}' 2>/dev/null \ + | python3 -I -c 'import json,sys; print(json.load(sys.stdin).get("architecture",""))' 2>/dev/null || true +} +# parse : prints "kind=index|single", "amd64=", "arm64=". +parse_index() { + python3 -I -c ' +import json, sys +try: + d = json.loads(sys.argv[1]) +except Exception: + print("kind=bad"); sys.exit(0) +if isinstance(d, dict) and isinstance(d.get("manifests"), list): + a, r = [], [] + for m in d["manifests"]: + p = m.get("platform") if isinstance(m, dict) else None + if not isinstance(p, dict) or "vnd.docker.reference.type" in (m.get("annotations") or {}): + continue + if p.get("os") != "linux": + continue + if p.get("architecture") == "amd64": + a.append(m.get("digest", "")) + elif p.get("architecture") == "arm64": + r.append(m.get("digest", "")) + print("kind=index"); print("amd64=" + " ".join(a)); print("arm64=" + " ".join(r)) +elif isinstance(d, dict) and isinstance(d.get("config"), dict): + print("kind=single") +else: + print("kind=bad") +' "$1" +} +# read_tag : sets g_digest, g_kind, g_amd64, g_arm64 for the tag as currently published. +read_tag() { + local raw out + g_digest=$(tag_digest "$1") + [[ $g_digest =~ $dre ]] || die "cannot read the manifest digest of $1 (does the tag exist?)" + raw=$(it inspect --raw "$1" 2>/dev/null) || die "cannot read $1" + out=$(parse_index "$raw") + g_kind=$(sed -n 's/^kind=//p' <<<"$out"); g_amd64=$(sed -n 's/^amd64=//p' <<<"$out"); g_arm64=$(sed -n 's/^arm64=//p' <<<"$out") + [ "$(tag_digest "$1")" = "$g_digest" ] || die "$1 changed while it was being read; try again" +} + +ref="$repo:$tag" +read_tag "$ref" +before_index=$g_digest; kind=$g_kind; amd64=$g_amd64; had_arm64=$g_arm64 +case "$kind" in + index) ;; + single) + [ "$(arch_of "$repo@$before_index")" = amd64 ] || die "$ref is a single manifest that is not linux/amd64" + amd64=$before_index ;; + *) die "$ref is neither an index nor an image manifest" ;; +esac +[ "$(wc -w <<<"$amd64")" -eq 1 ] || die "$ref has '$(wc -w <<<"$amd64")' linux/amd64 entries, want exactly one" +[[ $amd64 =~ $dre ]] || die "$ref: malformed amd64 digest '$amd64'" +note "$ref index=$before_index amd64=$amd64 existing-arm64='${had_arm64:-none}'" + +if [ -n "$expect" ] && [ "$expect" != "$before_index" ]; then + die "$ref is now $before_index but the plan was made for $expect: the tag moved, refusing to overwrite it" +fi +if [ -n "$had_arm64" ] && [ "$force" != 1 ]; then + die "$ref already has a linux/arm64 entry ($had_arm64); use --force to replace it" 3 +fi +if [ -n "$arm64" ]; then + [ "$arm64" != "$amd64" ] || die "arm64 digest equals the amd64 digest" + [ "$(arch_of "$repo@$arm64")" = arm64 ] || die "$repo@$arm64 does not inspect as linux/arm64; refusing to publish" +fi + +emit() { # key=value to stdout and $GITHUB_OUTPUT + echo "$1"; if [ -n "${GITHUB_OUTPUT:-}" ]; then echo "$1" >>"$GITHUB_OUTPUT"; fi +} +emit "before_index=$before_index"; emit "amd64=$amd64" +if [ "$plan_only" = 1 ]; then emit "platforms=plan-only"; exit 0; fi + +# Sources: keep the whole current index (amd64 + its attestation, byte-identical descriptors), +# 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" + +read_tag "$ref" +after_index=$g_digest +ok=1 +[ "$g_kind" = index ] || ok=0 +[ "$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 + it create -t "$ref" "$repo@$before_index" || echo "::error::attach-arm64-index: RESTORE FAILED, $ref needs manual repair (previous index $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" diff --git a/scripts/tests/attach-arm64-index.test.sh b/scripts/tests/attach-arm64-index.test.sh new file mode 100755 index 0000000..5de5707 --- /dev/null +++ b/scripts/tests/attach-arm64-index.test.sh @@ -0,0 +1,175 @@ +#!/usr/bin/env bash +## attach-arm64-index.test.sh - scripts/attach-arm64-index.sh against a stateful stub IMAGETOOLS +## that models the registry (tags, digests, index flattening on `create`). +set -euo pipefail +HERE=$(cd "$(dirname "$0")/.." && pwd) +T=$(mktemp -d); trap 'rm -rf "$T"' EXIT +fail=0 +chk() { if [ "$2" = "$3" ]; then echo "ok $1"; else echo "FAIL $1: got '$2' want '$3'"; fail=1; fi; } +d() { local c=$1; printf 'sha256:'; printf "$c%.0s" {1..64}; } # d a -> sha256:aaaa... +A=$(d a); AT=$(d e); B=$(d b); BT=$(d f); C=$(d c); OLD=$(d 1) +R=reg/cac + +cat >"$T/stub.py" <<'PY' +import hashlib, json, os, sys +S = os.environ['STATE'] +def load(n): + p = os.path.join(S, n) + return json.load(open(p)) if os.path.exists(p) else {} +def save(n, d): + json.dump(d, open(os.path.join(S, n), 'w')) +def dig(c): + return 'sha256:' + hashlib.sha256(json.dumps(c, sort_keys=True).encode()).hexdigest() +tags, blobs, arch = load('tags.json'), load('blobs.json'), load('arch.json') +args = sys.argv[1:] +with open(os.path.join(S, 'log'), 'a') as f: + f.write(' '.join(args) + '\n') +cmd = args[0] +rest = [a for i, a in enumerate(args[1:]) if a != '--builder' and (i == 0 or args[i] != '--builder')] +def resolve(ref): + if '@' in ref: + d = ref.split('@', 1)[1] + if d not in blobs: sys.exit(1) + return d, blobs[d] + if ref not in tags: sys.stderr.write('ERROR: %s: not found\n' % ref); sys.exit(1) + c = tags[ref]; return dig(c), c +if cmd == 'inspect': + raw = '--raw' in rest + ref = [a for a in rest if not a.startswith('--') and not a.startswith('{{')][0] if not raw else rest[rest.index('--raw') + 1] + if raw: + print(json.dumps(resolve(ref)[1])) + elif '{{.Manifest.Digest}}' in rest: + print(resolve(ref)[0]) + elif '{{json .Image}}' in rest: + d, c = resolve(ref) + if d not in arch: sys.exit(1) + print(json.dumps({'architecture': arch[d]})) +elif cmd == 'create': + ts = []; srcs = []; i = 0 + while i < len(rest): + if rest[i] == '-t': ts.append(rest[i + 1]); i += 2 + else: srcs.append(rest[i]); i += 1 + ms = [] + for s in srcs: + d, c = resolve(s) + if 'manifests' in c: ms.extend(c['manifests']) + else: ms.append({'digest': d, 'platform': {'os': 'linux', 'architecture': arch[d]}}) + if os.environ.get('MANGLE') == 'drop-amd64' and len(srcs) == 2: + ms = [m for m in ms if m['platform'].get('architecture') != 'amd64'] + if os.environ.get('MANGLE') == 'fail' and len(srcs) == 2: + sys.exit(1) + idx = {'mediaType': 'application/vnd.oci.image.index.v1+json', 'manifests': ms} + for t in ts: + tags[t] = idx + blobs[dig(idx)] = idx + save('tags.json', tags); save('blobs.json', blobs) +PY +export IMAGETOOLS="python3 $T/stub.py" STATE=$T/st + +# mk_state : writes the registry fixture. Digests: A amd64 image, AT its attestation, +# B arm64 image (new build, pushed by digest, not in any tag), C a second amd64 child. +mk() { + rm -rf "$T/st"; mkdir -p "$T/st"; : >"$T/st/log" + python3 -I - "$1" "$A" "$AT" "$B" "$BT" "$C" "$OLD" "$R" "$T/st" <<'PY' +import json, sys, os +kind, A, AT, B, BT, C, OLD, R, S = sys.argv[1:] +att = lambda d, of: {'digest': d, 'platform': {'os': 'unknown', 'architecture': 'unknown'}, 'annotations': {'vnd.docker.reference.type': 'attestation-manifest', 'vnd.docker.reference.digest': of}} +pl = lambda d, a: {'digest': d, 'platform': {'os': 'linux', 'architecture': a}} +idx = lambda ms: {'mediaType': 'application/vnd.oci.image.index.v1+json', 'manifests': ms} +tags, blobs = {}, {} +arch = {A: 'amd64', B: 'arm64', C: 'amd64'} +newb = idx([pl(B, 'arm64'), att(BT, B)]) # the arm64 build output (index with attestation) +blobs[B] = newb; arch[B] = 'arm64' +blobs[A] = {'config': {'digest': 'sha256:' + '9' * 64}, 'layers': []} +if kind == 'amd64only': tags[R + ':php82'] = idx([pl(A, 'amd64'), att(AT, A)]) +elif kind == 'both': tags[R + ':php82'] = idx([pl(A, 'amd64'), att(AT, A), pl(OLD, 'arm64')]); arch[OLD] = 'arm64' +elif kind == 'noamd': tags[R + ':php82'] = idx([pl(OLD, 'arm64')]); arch[OLD] = 'arm64' +elif kind == 'twoamd': tags[R + ':php82'] = idx([pl(A, 'amd64'), pl(C, 'amd64')]) +elif kind == 'single': tags[R + ':php82'] = blobs[A] +elif kind == 'missing': pass +for t, c in list(tags.items()): + import hashlib + d = 'sha256:' + hashlib.sha256(json.dumps(c, sort_keys=True).encode()).hexdigest() + blobs[d] = c + if kind == 'single': arch[d] = 'amd64' +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 +} +tagdig() { python3 -I -c ' +import json,hashlib,sys +t=json.load(open(sys.argv[1]))[sys.argv[2]] +print("sha256:"+hashlib.sha256(json.dumps(t,sort_keys=True).encode()).hexdigest())' "$T/st/tags.json" "$R:php82"; } +plats() { python3 -I -c ' +import json,sys +t=json.load(open(sys.argv[1]))[sys.argv[2]] +print(" ".join("%s=%s" % (m["platform"]["architecture"], m["digest"]) for m in t["manifests"] if "annotations" not in m))' "$T/st/tags.json" "$R:php82"; } +run() { "$HERE/attach-arm64-index.sh" "$@" >"$T/out" 2>"$T/err"; echo $?; } +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 +chk " prints before/after/amd64" "$(grep -c "^before_index=$before\$\|^amd64=$A\$\|^after_index=sha256:" "$T/out")" 3 +[ "$(tagdig)" != "$before" ] && chk " new index digest differs" ok ok || chk " new index digest differs" same differs + +# ---- 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 " 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 " 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 + +# ---- tag moved since the plan +mk amd64only +chk "--expect-index mismatch -> rc 1" "$(run --repo $R --tag php82 --arm64 "$B" --expect-index "$C")" 1 +chk " no create" "$(creates)" 0 +# ---- --plan-only +chk "--plan-only -> rc 0" "$(run --repo $R --tag php82 --arm64 "$B" --plan-only)" 0 +chk " no create" "$(creates)" 0 +mk both +chk "--plan-only on multi-arch tag still refuses (3)" "$(run --repo $R --tag php82 --arm64 "$B" --plan-only)" 3 + +# ---- 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 "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 +chk "bad tag (injection) -> rc 2" "$(run --repo $R --tag 'a b;c' --arm64 "$B")" 2 +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 +mk noamd +chk "tag without amd64 -> rc 1" "$(run --repo $R --tag php82 --arm64 "$B")" 1 +mk twoamd +chk "tag with two amd64 entries -> rc 1" "$(run --repo $R --tag php82 --arm64 "$B")" 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 " 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 +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 +chk " tag untouched" "$(plats)" "amd64=$A" + +# ---- GITHUB_OUTPUT +mk amd64only; GITHUB_OUTPUT=$T/gho "$HERE/attach-arm64-index.sh" --repo $R --tag php82 --arm64 "$B" >/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; } diff --git a/scripts/tests/multiarch-workflow.test.py b/scripts/tests/multiarch-workflow.test.py index a53d15f..2289cfa 100755 --- a/scripts/tests/multiarch-workflow.test.py +++ b/scripts/tests/multiarch-workflow.test.py @@ -323,5 +323,93 @@ class SingleLegDispatch(unittest.TestCase): self.assertIn('plan-legs:', err, only) +# ---- arm64-attach.yaml: restore arm64 on an existing tag without touching amd64 -------------- +ATTACH_WF = os.path.join(ROOT, '.gitea', 'workflows', 'arm64-attach.yaml') + + +class AttachWorkflow(unittest.TestCase): + @classmethod + def setUpClass(cls): + with open(ATTACH_WF) as f: + cls.text = f.read() + cls.job = cls.text.split('\njobs:\n', 1)[1] + + def test_manual_only_never_on_push_or_pr(self): + head = self.text.split('\njobs:\n')[0] + self.assertRegex(head, r'(?m)^on:\n workflow_dispatch:\n inputs:') + self.assertNotRegex(head, r'(?m)^ (push|pull_request|schedule|workflow_run)\b') + + def test_inputs_are_strings_and_runs_are_serialised(self): + head = self.text.split('\njobs:\n')[0] + for name in ('image', 'phpver', 'force'): + self.assertRegex(head, r'(?m)^ %s:\n(?: .*\n)*? type: string' % name) + self.assertRegex(head, r'(?m)^concurrency:\n group: arm64-attach\n cancel-in-progress: false$') + + def test_inputs_never_interpolated_into_shell(self): + for blk in re.findall(r'(?ms)^ run: .*?(?=^ - |\Z)', self.job): + self.assertNotIn('${{', blk) # everything reaches the script through env: + self.assertNotIn('github.event.inputs', self.job.split('Validate inputs', 1)[1].split('Login to Gitea', 1)[1]) + + def test_only_images_cac_and_cac_fpm_and_php82_to_86(self): + v = step(self.job, 'Validate inputs') + self.assertRegex(v, r'cac\)\s+dockerfile=Dockerfile;') + self.assertRegex(v, r'cac-fpm\)\s+dockerfile=Dockerfile\.fpm;') + self.assertIn('^8[2-6]$', v) + self.assertEqual(re.findall(r'(?m)^ ([a-z-]+)\)', v), ['cac', 'cac-fpm']) + self.assertNotIn('litespeed', v) + self.assertNotIn('lsphp', v) + + def test_arm64_only_push_by_digest_no_tags(self): + self.assertEqual(len(re.findall(r'platforms: linux/', self.job)), 1) + st = step(self.job, 'Build arm64') + self.assertIn('platforms: linux/arm64\n', st) + self.assertIn('push-by-digest=true,name-canonical=true,push=true', st) + self.assertNotRegex(st, r'(?m)^\s+tags:') + self.assertNotRegex(st, r'(?m)^\s+push: true') + self.assertNotIn('continue-on-error', st) # the run exists only for this build + self.assertNotIn('linux/amd64', st) + self.assertNotIn('Build amd64', self.job) + + def test_nothing_but_the_script_writes_a_tag(self): + for bad in ('imagetools create', 'docker push', 'docker tag', '/cac:latest', '/cac-fpm:latest', 'ghcr.io', 'docker buildx build'): + self.assertNotIn(bad, self.job, bad) + self.assertEqual(self.job.count('scripts/attach-arm64-index.sh'), 2) # plan (read-only) + attach + self.assertIn('--plan-only', step(self.job, 'Plan')) + self.assertNotIn('--arm64', step(self.job, 'Plan')) + + def test_step_order(self): + names = [n for n, _ in steps(self.job)] + order = ['Validate inputs', 'Login to Gitea', 'Plan', 'Build arm64', 'Verify ELF', 'PHP version parity', 'Attach'] + idx = [next(i for i, n in enumerate(names) if n.startswith(o)) for o in order] + self.assertEqual(idx, sorted(idx)) + + def test_attach_step_guards(self): + st = step(self.job, 'Attach') + for need in ('--expect-index "$BEFORE"', '--arm64 "$ARM64_DIGEST"', '${{ steps.plan.outputs.before_index }}', + '${{ steps.arm64.outputs.digest }}'): + self.assertIn(need, st) + self.assertNotIn('continue-on-error', st) + + def test_both_platforms_elf_checked_before_attach(self): + st = step(self.job, 'Verify ELF') + self.assertIn('--platform linux/arm64', st) + self.assertIn('--platform linux/amd64', st) + self.assertIn('verify-image-arch.py', st) + self.assertIn('/usr/sbin/httpd /usr/bin/php', step(self.job, 'Validate inputs')) + self.assertIn('/usr/sbin/php-fpm /usr/bin/php', step(self.job, 'Validate inputs')) + + def test_secrets_only_in_login_action(self): + self.assertEqual(self.text.count('secrets.'), 2) + lg = step(self.job, 'Login to Gitea') + self.assertIn('secrets.CI_USER', lg) + self.assertIn('secrets.CI_TOKEN', lg) + self.assertNotIn('echo', lg) + + def test_job_timeout_covers_the_leg_timeout(self): + jt = int(re.search(r'(?m)^ timeout-minutes: (\d+)$', self.job).group(1)) + at = int(re.search(r'timeout-minutes: (\d+)', step(self.job, 'Build arm64')).group(1)) + self.assertGreater(jt, at + 20) + + if __name__ == '__main__': unittest.main(verbosity=2) diff --git a/scripts/tests/verify-image-arch.test.sh b/scripts/tests/verify-image-arch.test.sh new file mode 100755 index 0000000..a3b3d59 --- /dev/null +++ b/scripts/tests/verify-image-arch.test.sh @@ -0,0 +1,65 @@ +#!/usr/bin/env bash +## verify-image-arch.test.sh - scripts/verify-image-arch.py against a stub `docker` that serves +## fabricated ELF headers through `docker cp -L ctr:path -` (a tar stream), like the real one. +set -euo pipefail +HERE=$(cd "$(dirname "$0")/.." && pwd) +T=$(mktemp -d); trap 'rm -rf "$T"' EXIT +fail=0 +chk() { if [ "$2" = "$3" ]; then echo "ok $1"; else echo "FAIL $1: got '$2' want '$3'"; fail=1; fi; } + +cat >"$T/mktar.py" <<'PY' +import io, os, struct, sys, tarfile +path = sys.argv[1] +spec = dict(l.rstrip('\n').split('=', 1) for l in open(os.environ['FIX']) if '=' in l).get(path) +if spec is None or spec == 'missing': + sys.stderr.write('Error response from daemon: Could not find the file %s in container\n' % path); sys.exit(1) +if spec == 'notelf': head = b'#!/bin/sh\necho hi\n' + b'\0' * 64 +elif spec == 'elf32': head = b'\x7fELF\x01\x01\x01' + b'\0' * 11 + struct.pack('H', 0xB7) + b'\0' * 60 +elif spec == 'dir': + t = tarfile.open(fileobj=sys.stdout.buffer, mode='w|'); ti = tarfile.TarInfo('d'); ti.type = tarfile.DIRTYPE; t.addfile(ti); t.close(); sys.exit(0) +else: head = b'\x7fELF\x02\x01\x01' + b'\0' * 11 + struct.pack('"$T/dk" <<'STUB' +#!/usr/bin/env bash +echo "$*" >>"$LOG" +case "$1" in + pull) exit "${PULL_RC:-0}" ;; + create) [ "${CREATE_RC:-0}" = 0 ] || { echo "no such image" >&2; exit 1; }; echo cid1 ;; + rm) ;; + cp) python3 -I "$MKTAR" "${3#*:}" ;; +esac +STUB +chmod +x "$T/dk" +export DOCKER="$T/dk" FIX=$T/fix LOG=$T/log MKTAR=$T/mktar.py +V="python3 -I $HERE/verify-image-arch.py" +run() { : >"$LOG"; $V "$@" >"$T/out" 2>"$T/err"; echo $?; } + +printf '%s\n' /usr/bin/php=b7 /usr/sbin/httpd=b7 >"$T/fix" +chk "arm64 image with aarch64 binaries -> 0" "$(run --image r/x@sha256:1 --platform linux/arm64 --bin /usr/sbin/httpd --bin /usr/bin/php)" 0 +chk " pulled with the platform flag, container removed" "$(grep -c '^pull --quiet --platform linux/arm64 r/x@sha256:1$\|^rm -f cid1$' "$LOG")" 2 +chk " prints AArch64" "$(grep -c 'e_machine=0xB7 (AArch64)' "$T/out")" 2 +printf '%s\n' /usr/bin/php=3e >"$T/fix" +chk "arm64 image carrying an x86-64 binary -> 1" "$(run --image r/x@sha256:1 --platform linux/arm64 --bin /usr/bin/php)" 1 +chk " says x86-64 was found" "$(grep -c 'FAIL.*e_machine=0x3E (x86-64), want 0xB7 (AArch64)' "$T/out")" 1 +chk "amd64 image with x86-64 binary -> 0" "$(run --image r/x@sha256:1 --platform linux/amd64 --bin /usr/bin/php)" 0 +printf '%s\n' /usr/bin/php=b7 >"$T/fix" +chk "amd64 image carrying an aarch64 binary -> 1" "$(run --image r/x@sha256:1 --platform linux/amd64 --bin /usr/bin/php)" 1 +printf '%s\n' /usr/bin/php=b7 /usr/sbin/httpd=3e >"$T/fix" +chk "one good + one wrong binary -> 1 (all are checked)" "$(run --image r/x@sha256:1 --platform linux/arm64 --bin /usr/bin/php --bin /usr/sbin/httpd)" 1 +chk " the good one is still reported OK" "$(grep -c '^OK ' "$T/out")" 1 +printf '%s\n' /bin/a=notelf /bin/b=elf32 /bin/c=be /bin/d=dir /bin/e=missing >"$T/fix" +for b in a b c d e; do chk "bad binary /bin/$b -> 1" "$(run --image r/x@sha256:1 --platform linux/arm64 --bin /bin/$b)" 1; done +chk "binary absent from the fixture -> 1" "$(run --image r/x@sha256:1 --platform linux/arm64 --bin /usr/bin/nothere)" 1 +printf '%s\n' /usr/bin/php=b7 >"$T/fix" +chk "docker pull fails -> 1" "$(PULL_RC=1 run --image r/x@sha256:1 --platform linux/arm64 --bin /usr/bin/php)" 1 +chk "docker create fails -> 1" "$(CREATE_RC=1 run --image r/x@sha256:1 --platform linux/arm64 --bin /usr/bin/php)" 1 +chk "--no-pull skips the pull" "$(run --image r/x@sha256:1 --platform linux/arm64 --no-pull --bin /usr/bin/php; grep -c '^pull' "$LOG" || true)" "0 +0" +chk "usage: no --bin -> 2" "$(run --image r/x --platform linux/arm64)" 2 +chk "usage: bad platform -> 2" "$(run --image r/x --platform linux/s390x --bin /usr/bin/php)" 2 + +[ "$fail" -eq 0 ] && echo "ALL PASS" || { echo FAILURES; exit 1; } diff --git a/scripts/verify-image-arch.py b/scripts/verify-image-arch.py new file mode 100755 index 0000000..d8eb4ad --- /dev/null +++ b/scripts/verify-image-arch.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 +"""verify-image-arch.py - prove an image platform really contains binaries of that architecture. + +An image whose config says linux/arm64 can still carry x86-64 binaries (the "x86 in arm64" +exec-format-error loop seen with haproxy-manager-base). The registry manifest cannot tell; the ELF +header can. This pulls REF for one platform, copies the named key binaries out of a created (never +started, never executed) container and checks e_machine of each: aarch64 = 0xB7, x86-64 = 0x3E. +Same idea as haproxy-manager-base scripts/verify-image-arch.py (PR #22), adapted to docker cp so +no QEMU execution is needed. + + verify-image-arch.py --image REF --platform linux/arm64|linux/amd64 --bin /usr/bin/php [--bin ...] + +Exit 0 = every --bin is an ELF64 little-endian binary of the platform's machine type. +Exit 1 = a binary is missing, not an ELF, or of the wrong architecture (or docker failed). +Exit 2 = usage. +Env: DOCKER overrides the docker command (tests use a stub). Nothing in REF is ever run. +""" +import argparse +import os +import shlex +import subprocess +import sys +import tarfile + +MACHINES = {'linux/arm64': (0xB7, 'AArch64'), 'linux/amd64': (0x3E, 'x86-64')} +NAMES = {0x3E: 'x86-64', 0xB7: 'AArch64', 0x03: 'x86', 0x28: 'ARM', 0xF3: 'RISC-V', 0x15: 'PowerPC64', 0x16: 'S390'} +MAX_STREAM = 1 << 31 # refuse to read more than 2 GiB of one tar stream + + +def elf_machine(head): + """Return e_machine of an ELF64 little-endian header, or raise ValueError.""" + if len(head) < 20 or head[:4] != b'\x7fELF': + raise ValueError('not an ELF file') + if head[4] != 2: + raise ValueError('not ELF64 (EI_CLASS=%d)' % head[4]) + if head[5] != 1: + raise ValueError('not little-endian (EI_DATA=%d)' % head[5]) + return int.from_bytes(head[18:20], 'little') + + +def docker_cmd(): + return shlex.split(os.environ.get('DOCKER') or 'docker') + + +def run(args, **kw): + return subprocess.run(docker_cmd() + args, capture_output=True, **kw) + + +def first_bytes_of(cid, path): + """First 64 bytes of the regular file at path (symlinks followed) inside container cid.""" + p = subprocess.Popen(docker_cmd() + ['cp', '-L', '%s:%s' % (cid, path), '-'], + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + try: + tf = tarfile.open(fileobj=p.stdout, mode='r|') + m = tf.next() + if m is None or not m.isreg(): + raise ValueError('%s is not a regular file' % path) + return tf.extractfile(m).read(64) + except tarfile.TarError as e: + err = p.stderr.read(300).decode('utf-8', 'replace').strip() + raise ValueError('cannot read %s: %s %s' % (path, e, err)) + finally: + p.kill() + p.wait() + + +def main(argv): + ap = argparse.ArgumentParser(description=__doc__.split('\n')[0]) + ap.add_argument('--image', required=True) + ap.add_argument('--platform', required=True, choices=sorted(MACHINES)) + ap.add_argument('--bin', dest='bins', action='append', required=True) + ap.add_argument('--no-pull', action='store_true', help='image is already in the local store') + a = ap.parse_args(argv) + want, label = MACHINES[a.platform] + + if not a.no_pull: + r = run(['pull', '--quiet', '--platform', a.platform, a.image]) + if r.returncode != 0: + print('verify-image-arch: docker pull failed: %s' % r.stderr.decode('utf-8', 'replace')[:300].strip(), file=sys.stderr) + return 1 + r = run(['create', '--platform', a.platform, '--entrypoint', '/nonexistent', a.image]) + cid = r.stdout.decode().strip() + if r.returncode != 0 or not cid: + print('verify-image-arch: docker create failed: %s' % r.stderr.decode('utf-8', 'replace')[:300].strip(), file=sys.stderr) + return 1 + rc = 0 + try: + for path in a.bins: + try: + m = elf_machine(first_bytes_of(cid, path)) + except ValueError as e: + print('FAIL %s %s %s: %s' % (a.image, a.platform, path, e)) + rc = 1 + continue + if m != want: + print('FAIL %s %s %s: e_machine=0x%X (%s), want 0x%X (%s)' % ( + a.image, a.platform, path, m, NAMES.get(m, '?'), want, label)) + rc = 1 + else: + print('OK %s %s %s: e_machine=0x%X (%s)' % (a.image, a.platform, path, m, label)) + finally: + run(['rm', '-f', cid]) + return rc + + +if __name__ == '__main__': + sys.exit(main(sys.argv[1:])) -- 2.52.0 From 42f72e24ff0a230610f181a7bc9156027da98b8b Mon Sep 17 00:00:00 2001 From: Josh Knapp Date: Thu, 19 Nov 2026 21:11:26 -0800 Subject: [PATCH 2/2] 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; } -- 2.52.0