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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
This commit is contained in:
shadowdaoandClaude Sonnet 5.5 committed 2026-11-19 21:03:27 -08:00
1 parent 935b02eae4
commit 02de5c6568
7 files changed
+824

No files matched your search

+162
View File
@@ -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 <registry/path> --tag <tag> --arm64 sha256:<digest> \
# [--expect-index sha256:<digest>] [--force] [--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):
# * 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 <ref>: 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 <ref>: 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 <raw-json>: prints "kind=index|single", "amd64=<digests, space separated>", "arm64=<digests>".
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 <ref>: 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"
+175
View File
@@ -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 <tag-content-kind>: 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; }
+88
View File
@@ -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)
+65
View File
@@ -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', 0x3E) + b'\0' * 60
elif spec == 'be': head = b'\x7fELF\x02\x02\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('<H', int(spec, 16)) + b'\0' * 60
body = head + b'\0' * 200000 # bigger than the pipe buffer: reader must stop early
t = tarfile.open(fileobj=sys.stdout.buffer, mode='w|')
ti = tarfile.TarInfo(os.path.basename(path)); ti.size = len(body); t.addfile(ti, io.BytesIO(body)); t.close()
PY
cat >"$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; }
+107
View File
@@ -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:]))