ci: arm64-attach workflow - restore arm64 on an existing cac/cac-fpm tag without touching amd64 #48
No files matched your search
@@ -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"
|
||||
@@ -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 <registry/path> --tag <tag> --arm64 sha256:<digest> \
|
||||
# [--expect-index sha256:<digest>] [--force] [--builder <buildx builder>]
|
||||
# [--expect-index sha256:<digest>] [--force] [--follow-tag <tag>] [--builder <buildx builder>]
|
||||
# attach-arm64-index.sh --repo <registry/path> --tag <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 <repo>:T currently has the very same index digest as
|
||||
# <tag> 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
|
||||
@@ -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; }
|
||||
Reference in new issue
Block a user