Compare commits

..
Author SHA1 Message Date
shadowdaoandClaude Sonnet 5.5 42f72e24ff 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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 21:11:26 -08:00
shadowdaoandClaude Sonnet 5.5 02de5c6568 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
2026-11-19 21:03:27 -08:00
jknapp 935b02eae4 Merge pull request 'tests: fix SC2034 + pipefail hazard in lsphp-src-upload-progress test' (#47) from fix/shellcheck-upload-progress-test into trunk
[skip ci] Fix shellcheck SC2034 and pipefail SIGPIPE pattern in lsphp upload-progress test
2026-11-19 20:13:37 +00:00
shadowdaoandClaude Sonnet 5.5 be8723c468 tests: fix SC2034 and early-exit pipeline in lsphp-src-upload-progress test
Shell-Checks failed on SC2034 (SRC only used inside eval), and the
lsphp-info-probe structural scan flagged the grep|grep|head pipeline
(pipefail SIGPIPE hazard) in the same new test. Replace with a read loop;
export SRC. No product script changes.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 12:01:11 -08:00
jknapp a43a755b9d Merge pull request #46 PHP 8.6 for cac/cac-fpm [skip ci]
[skip ci]
2026-11-19 19:38:17 +00:00
shadowdaoandClaude Sonnet 5.5 47fef38052 install-php86: keep geoip (Remi php-rlerdorf-geoip provides php-pecl-geoip on 8.6); fix grep pipe
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 11:37:57 -08:00
shadowdaoandClaude Sonnet 5.5 854042b1c3 feat: PHP 8.6 for cac and cac-fpm (Remi php:remi-8.6), per-family version lists in plan-legs
install-php86.sh = install-php85.sh minus php-pecl-geoip (no 8.6 build), fail-loud with
extension assertion. plan-legs.sh: per-family lists so cac/cac-fpm get 82-86 while
cac-litespeed/cac-lsphp stay 82-85 (no lsphp86). :latest stays on php85. ini files are
shared (single prod-php.ini), so 8.5 hardening incl. session.use_strict_mode=0 applies unchanged.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 11:32:25 -08:00
jknapp e6e3f1fd48 Merge pull request #45 re-pin LSAPI [skip ci]
[skip ci]
2026-11-19 17:54:45 +00:00
shadowdaoandClaude Sonnet 5.5 32af04b825 fix(lsphp-src): re-pin LiteSpeed LSAPI php-litespeed-8.4.tgz (republished 2026-11-19 17:39Z) [skip ci]
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 09:54:36 -08:00
jknapp 697926a5bb Merge pull request fix/lsphp-inconsistent-repo-pin (#44) [skip ci]
[skip ci]
2026-11-19 17:46:09 +00:00
shadowdaoandClaude Sonnet 5.5 fe9d9fe181 fix(lsphp): post-install check asserts exact resolved pins incl. -ldap [skip ci]
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 09:46:06 -08:00
shadowdaoandClaude Sonnet 5.5 40f62c2b64 fix(lsphp): per-package pins so an inconsistent LiteSpeed 8.4 set still builds [skip ci]
Stage 2 pinned lsphp84, -common and -ldap to one version; LiteSpeed's repo
offers lsphp84 8.4.27-2 but lsphp84-common only 8.4.27-3 (run 5691 job 18704:
E: Version '8.4.27-2+noble' for 'lsphp84-common' was not found). New
scripts/lsphp-pin-resolve.sh resolves -common/-ldap to the exact version when
offered (unchanged for 82/83/85), else a same-PHP-version, same-distro,
>= revision; never a different PHP release. lsphp84 itself stays exact and the
post-install check requires same upstream + >=. Fixture test added to CI.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 09:44:50 -08:00
jknappandClaude Sonnet 5.5 d792a6549b Merge pull request #43: re-pin LSAPI to 8.4 [skip ci]
[skip ci]

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 15:37:16 +00:00
shadowdaoandClaude Sonnet 5.5 ea219b4adf lsphp-src: re-pin LiteSpeed SAPI to php-litespeed-8.4.tgz (matches packaged -2 builds)
Run 5686 passed the ini gate but failed the LSAPI name-set gate: packaged lsphp82-85 carry LSAPI_ENABLE_ADMIN_OVERRIDE / 'LiteSpeed V8.4', absent from the 8.3 tgz. Gate kept. [skip ci]

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 07:37:13 -08:00
jknappandClaude Sonnet 5.5 95cced5144 Merge pull request #42: lsphp-src-build reproduce upload_progress default [skip ci]
[skip ci]

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0185ukXi4YX5FxJGqhi6qab6
2026-11-19 14:56:03 +00:00
16 changed files with 1140 additions and 25 deletions

No files matched your search

+15 -6
View File
@@ -7,8 +7,9 @@
## GITHUB_OUTPUT file the outputs are appended to (set by the runner).
##
## ONLY is a comma list of tokens (spaces ignored):
## cac:php85 cac-fpm:php84 cac-litespeed:php83 cac-lsphp:php82 one leg
## cac:php86 cac-fpm:php84 cac-litespeed:php83 cac-lsphp:php82 one leg
## cac | cac-fpm | cac-litespeed | cac-lsphp every PHP version of that image
## (php86 exists for cac and cac-fpm only; lsphp86 does not exist yet)
## shared-httpd | shared-ols that image
## Any other token is an error (exit 2, nothing is written): a typo must fail
## the plan job loudly, never silently build nothing.
@@ -20,7 +21,15 @@ set -euo pipefail
MATRIX_FAMILIES=(cac cac-fpm cac-litespeed cac-lsphp)
SINGLE_FAMILIES=(shared-httpd shared-ols)
ALL_PHPVER=(82 83 84 85)
# PHP versions per family. cac/cac-fpm (AlmaLinux + Remi) also ship 8.6; the
# LiteSpeed families have no lsphp86 package yet, so they stay on 82..85 (a
# shared list would make every trunk push build, and fail, litespeed/lsphp php86).
declare -A FAM_PHPVER=(
[cac]="82 83 84 85 86"
[cac-fpm]="82 83 84 85 86"
[cac-litespeed]="82 83 84 85"
[cac-lsphp]="82 83 84 85"
)
die() { echo "plan-legs: $*" >&2; exit 2; }
@@ -46,11 +55,11 @@ else
fi
if [[ " ${MATRIX_FAMILIES[*]} " == *" $fam "* ]]; then
if [ -z "$ver" ]; then
for v in "${ALL_PHPVER[@]}"; do want_ver["$fam:$v"]=1; done
elif [[ "$ver" =~ ^php(8[2-5])$ ]]; then
for v in ${FAM_PHPVER[$fam]}; do want_ver["$fam:$v"]=1; done
elif [[ "$ver" =~ ^php(8[2-6])$ ]] && [[ " ${FAM_PHPVER[$fam]} " == *" ${BASH_REMATCH[1]} "* ]]; then
want_ver["$fam:${BASH_REMATCH[1]}"]=1
else
die "unknown PHP version in '$t' (want ${fam}:php82 .. ${fam}:php85)"
die "unknown PHP version in '$t' (${fam} has: ${FAM_PHPVER[$fam]// /, })"
fi
elif [[ " ${SINGLE_FAMILIES[*]} " == *" $fam "* ]]; then
[ "$fam" = "$t" ] || die "'$t': $fam has a single leg, use plain '$fam'"
@@ -64,7 +73,7 @@ fi
matrix_json() { # family
local fam=$1 v out=""
for v in "${ALL_PHPVER[@]}"; do
for v in ${FAM_PHPVER[$fam]}; do
if $want_all || [ -n "${want_ver["$fam:$v"]-}" ]; then out+="${out:+,}$v"; fi
done
printf '[%s]' "$out"
+225
View File
@@ -0,0 +1,225 @@
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 (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
# 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<phpver>.
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<phpver>)'
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:
# 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:
- 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:-<unreachable: upstream>} registry-mirror=${mirror:-<not used>}"
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 }}
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@$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)
env:
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@$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; }
[ "$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
[[ "$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"
+18 -3
View File
@@ -2,7 +2,7 @@ name: Cloud Apache Container
run-name: ${{ gitea.actor }} pushed a change to trunk
# Manual run. `only` (optional) rebuilds just the named legs instead of every
# image: Gitea cannot re-run a single job and a full run takes ~1h.
# Syntax: comma list of cac:php85, cac-fpm:php84, cac-litespeed:php83,
# Syntax: comma list of cac:php86, cac-fpm:php84, cac-litespeed:php83,
# cac-lsphp:php82, shared-httpd, shared-ols; a bare family name (cac) = all its
# PHP versions. Empty = everything (same as a push). Unknown values fail the
# plan job. See .gitea/scripts/plan-legs.sh.
@@ -64,6 +64,8 @@ jobs:
scripts/create-vhost-litespeed.sh \
scripts/install-lscache-wp.sh \
scripts/lsphp-apt-upgrade.sh \
scripts/lsphp-pin-resolve.sh \
scripts/tests/lsphp-pin-resolve.test.sh \
scripts/lsphp-src-build.sh \
scripts/lsphp-src-overlay.sh \
scripts/lsphp-abi-gate.sh \
@@ -76,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 \
@@ -83,6 +88,9 @@ jobs:
.gitea/scripts/resolve-base-image.sh \
.gitea/scripts/plan-legs.sh
- name: lsphp pin-resolve fixture test
run: ./scripts/tests/lsphp-pin-resolve.test.sh
- name: lsphp repo-version lookup test
run: ./scripts/tests/lsphp-repo-version.test.sh
@@ -91,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
@@ -297,7 +312,7 @@ jobs:
run: |
set -euo pipefail
tags=(--tag "php${PHPVER}")
# :latest tracks php85 (unchanged tag scheme).
# :latest tracks php85 (unchanged tag scheme; php86 is a new tag, NOT latest).
[ "$PHPVER" = 85 ] && tags+=(--tag latest)
scripts/assemble-multiarch-index.sh \
--amd64 "$AMD64_DIGEST" \
@@ -466,7 +481,7 @@ jobs:
run: |
set -euo pipefail
tags=(--tag "php${PHPVER}")
# :latest tracks php85 (unchanged tag scheme).
# :latest tracks php85 (unchanged tag scheme; php86 is a new tag, NOT latest).
[ "$PHPVER" = 85 ] && tags+=(--tag latest)
scripts/assemble-multiarch-index.sh \
--amd64 "$AMD64_DIGEST" \
+12 -2
View File
@@ -220,12 +220,21 @@ COPY ./scripts/pkg-cache-repos.sh /usr/local/sbin/pkg-cache-repos.sh
COPY ./keys/pkg-cache/ /usr/local/share/pkg-cache/
COPY --from=ext-build /build-out/lsphp.version /etc/cac-lsphp-build.version
COPY ./scripts/lsphp-apt-upgrade.sh /usr/local/sbin/lsphp-apt-upgrade.sh
COPY --chmod=0755 ./scripts/lsphp-pin-resolve.sh /usr/local/sbin/lsphp-pin-resolve.sh
## Per-package pins: lsphpNN is pinned to $V exactly; -common/-ldap to $V when the
## repo offers it, else to a same-PHP-version packaging revision >= $V (LiteSpeed
## published lsphp84 -2 with lsphp84-common -3 on 2026-11-19). See the script.
RUN set -e; \
PR=/usr/local/sbin/lsphp-pin-resolve.sh; \
V=$(cat /etc/cac-lsphp-build.version); \
/usr/local/sbin/pkg-cache-repos.sh apt; \
apt-get update --error-on=any; \
VC=$($PR resolve lsphp${PHPVER}-common "$V"); \
VL=$($PR resolve lsphp${PHPVER}-ldap "$V"); \
echo "lsphp pins: lsphp${PHPVER}=$V -common=$VC -ldap=$VL"; \
if ! /usr/local/sbin/lsphp-apt-upgrade.sh "${PHPVER}" \
ca-certificates \
lsphp${PHPVER}="$V" lsphp${PHPVER}-common="$V" lsphp${PHPVER}-ldap="$V"; then \
lsphp${PHPVER}="$V" lsphp${PHPVER}-common="$VC" lsphp${PHPVER}-ldap="$VL"; then \
echo "FATAL: lsphp-apt-upgrade.sh failed (reason above). If apt said" >&2; \
echo " \"Version '$V' ... was not found\" or refused a downgrade: $V is what" >&2; \
echo " cac_path_parity was compiled against, but the LiteSpeed repo (which" >&2; \
@@ -239,7 +248,8 @@ RUN set -e; \
rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*; \
RTV=$(dpkg-query -W -f='${Version}' lsphp${PHPVER}); \
CMV=$(dpkg-query -W -f='${Version}' lsphp${PHPVER}-common); \
if [ "$RTV" != "$V" ] || [ "$CMV" != "$V" ]; then \
LDV=$(dpkg-query -W -f='${Version}' lsphp${PHPVER}-ldap); \
if [ "$RTV" != "$V" ] || [ "$CMV" != "$VC" ] || [ "$LDV" != "$VL" ] || ! $PR ok "$CMV" "$V"; then \
echo "FATAL: cac_path_parity.so was compiled against lsphp${PHPVER} $V but this" >&2; \
echo " image would ship lsphp${PHPVER}=$RTV / -common=$CMV." >&2; \
echo " Rebuild with --no-cache so both stages resolve the same release." >&2; \
+3 -3
View File
@@ -1,6 +1,6 @@
# Cloud Apache Container
This is a base container for running PHP-based applications, supporting multiple PHP versions (7.4, 8.0, 8.1, 8.2, 8.3, 8.4). The default is PHP 8.3. The container is based on AlmaLinux 9 and uses Apache with mod_ssl. It is designed for both development and production use.
This is a base container for running PHP-based applications, supporting multiple PHP versions (7.4, 8.0, 8.1, 8.2, 8.3, 8.4, 8.5, 8.6; 8.6 is cac and cac-fpm only, no LiteSpeed lsphp86 yet). The default is PHP 8.3. The container is based on AlmaLinux 9 and uses Apache with mod_ssl. It is designed for both development and production use.
**You must have Docker or compatible containerization software running.**
@@ -29,7 +29,7 @@ The easiest way to start a local development environment is with the provided `l
- `-p` HTTP port (default: 80)
- `-s` HTTPS port (default: 443)
- `-r` Root path for files and database (default: current directory)
- `-a` PHP version (default: 8.3; options: 74, 80, 81, 82, 83, 84)
- `-a` PHP version (default: 8.3; options: 74, 80, 81, 82, 83, 84, 85, 86)
- `-v` Enable verbose mode
- `-h` Show help
@@ -86,7 +86,7 @@ Then visit https://localhost (accept the SSL warning) to complete setup.
## Features
- **Multiple PHP Versions:** 7.4, 8.0, 8.1, 8.2, 8.3, 8.4 (set with `PHPVER` or `-a` flag)
- **Multiple PHP Versions:** 7.4, 8.0, 8.1, 8.2, 8.3, 8.4, 8.5, 8.6 (8.6: cac and cac-fpm only) (set with `PHPVER` or `-a` flag)
- **Pre-built Images:** Pull the image for your desired PHP version directly from the registry. No need to build locally unless customizing.
- **Optimized Build:** Smaller, faster, and more secure images thanks to the improved Dockerfile and `.dockerignore`.
- **Automatic Database Setup:** MariaDB is started in DEV mode, credentials are auto-generated and stored in `/home/$user/mysql_creds`.
+1 -1
View File
@@ -96,7 +96,7 @@ Each of the following fails the build:
| OpenPGP signature | `gpgv` rejects the `.asc` against `keys/php-src/php-keyring.asc`, or the signer's primary fingerprint is not listed for that branch in `keys/php-src/release-managers.txt`. |
| Version sanity | The version is not X.Y.Z, is not in the PHPVER branch, or is not newer than the packaged version. |
| Configure | Replaying the packaged lsphp's own `Configure Command` fails. The usual cause is a `-dev` package missing from `DEVPKGS`. |
| LSAPI SAPI | `php-litespeed-8.3.tgz` does not match its pinned sha256, or the built lsphp's set of `LSAPI_*` names differs from the packaged binary's. |
| LSAPI SAPI | `php-litespeed-8.4.tgz` (pinned 2026-11-19; was 8.3) does not match its pinned sha256, or the built lsphp's set of `LSAPI_*` names differs from the packaged binary's. |
| Compiled-in ini defaults | Any `php -n` ini default differs from the packaged binary. Directives that are new in the release are allowed and printed. |
| ABI gate | A struct member's offset or size changed, or a non-`*_globals` struct changed size. See `scripts/lsphp-abi-gate.sh`. |
| File replacement | A php-src ELF file owned by a package at the core version has no php.net counterpart. |
+15 -1
View File
@@ -9,5 +9,19 @@
# binary has the same LSAPI_* feature/env-name set as the packaged lsphp, so a
# LiteSpeed SAPI upgrade we have not pinned yet fails the build instead of
# shipping an older SAPI.
#
# RE-PINNED 2026-11-19 (emergency run 5686): LiteSpeed's lsphp 8.2-8.5 `-2+noble`
# packages (e.g. lsphp85 8.5.12-2) now carry LSAPI_ENABLE_ADMIN_OVERRIDE and the
# string "LiteSpeed V8.4" (the 8.3 tgz above this line had neither; the name-set gate
# caught it). php-litespeed-8.4.tgz (Last-Modified Tue, 17 Nov 2026 17:12:52 GMT)
# is the SAPI with that knob (hardening: admin overrides off by default, 64-bit safe
# writes). Measured against the packaged binaries before re-pinning. The previous
# pin was php-litespeed-8.3.tgz cd616b82cc853e5e3187fccd060228b9cd1a2009ce72d8da5950eef950ac29b1.
#
# RE-PINNED AGAIN 2026-11-19 (run 5692, lsphp/84): LiteSpeed republished the SAME URL
# at Thu, 19 Nov 2026 17:39:07 GMT (60487 bytes; only lsapi_main.c changed, 09:37 PST
# per the tar timestamps; it still has LSAPI_ENABLE_ADMIN_OVERRIDE and "LiteSpeed V8.4").
# Previous pin d88e90ef010e06e368da6919b700a589a9a4f478ebb7b2dc41f8d87b4e3f9b8f. The
# LSAPI name-set gate against the packaged lsphp still runs on every build.
# <url> <sha256>
https://www.litespeedtech.com/packages/lsapi/php-litespeed-8.3.tgz cd616b82cc853e5e3187fccd060228b9cd1a2009ce72d8da5950eef950ac29b1
https://www.litespeedtech.com/packages/lsapi/php-litespeed-8.4.tgz 10c1e7f7b19c6be195083ba8684316f167581e2d3b7a4fc39eab4c46190ede5c
+197
View File
@@ -0,0 +1,197 @@
#!/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] [--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):
# * 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 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).
#
# 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=""; follow=""
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 ;;
--follow-tag) follow=${2-}; shift 2 ;;
--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 "$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
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" || { echo "::error::attach-arm64-index: create failed; tag state unverified (was $before_index)" >&2; exit 1; }
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)" >&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
+15
View File
@@ -0,0 +1,15 @@
#!/usr/bin/env bash
# PHP 8.6 (Remi EL10 modular php:remi-8.6). Same package set as install-php85.sh.
# php-pecl-geoip is provided on 8.6 by Remi's maintained fork php-rlerdorf-geoip.
# Fails loudly (set -e) instead of the older scripts' "exit 0".
set -euo pipefail
dnf module enable php:remi-8.6 -y
dnf install -y php php-fpm php-mysqlnd php-xml php-pecl-zip php-sodium php-soap php-pecl-xmlrpc \
php-pecl-redis5 php-pecl-memcached php-pecl-memcache php-pecl-ip2location php-pecl-imagick php-pecl-geoip \
php-mysqlnd php-mbstring php-intl php-gd php-pgsql libzip php-cli
# A silently missing extension must fail the build, not ship.
loaded=$(php -m)
for ext in mysqlnd gd intl soap sodium zip mbstring xml pgsql redis memcached memcache imagick ip2location xmlrpc geoip; do
grep -qix "$ext" <<<"$loaded" || { echo "FATAL: PHP 8.6 extension '$ext' not loaded" >&2; exit 1; }
done
exit 0
+59
View File
@@ -0,0 +1,59 @@
#!/bin/bash
## lsphp-pin-resolve.sh — BUILD-TIME ONLY. Run (Dockerfile RUN is dash, so this is
## a bash executable) or source it:
## lsphp-pin-resolve.sh resolve PKG WANT # prints the version to pin PKG at
## lsphp-pin-resolve.sh ok INSTALLED WANT # exit 0 if INSTALLED is an acceptable pin
##
## Why: stage 2 of Dockerfile.lsphp pins lsphpNN, lsphpNN-common and
## lsphpNN-ldap to the ONE version ext-build compiled against. LiteSpeed's repo
## is occasionally published inconsistently (2026-11-19: lsphp84 8.4.27-2+noble
## but lsphp84-common 8.4.27-3+noble only), so a single shared pin makes apt say
## "Version '8.4.27-2+noble' for 'lsphp84-common' was not found".
##
## Rule (fail closed, nothing weakened):
## 1. WANT itself is offered for PKG -> WANT (the normal case; 82/83/85).
## 2. else the highest version that has the SAME upstream PHP version (the
## text before the first '-') and the same distro suffix (after '+') as
## WANT and is >= WANT (a packaging-revision bump; every lsphp package
## Depends on -common only as ">= WANT", so >= is always satisfiable).
## 3. else exit 1 — a different PHP release is never silently substituted.
## The caller still asserts lsphpNN (the binary the extension was built for)
## equals WANT exactly and -common has the same upstream version and is >= WANT.
##
## LSPHP_MADISON_CMD (default "apt-cache madison") is overridable for tests.
lsphp_resolve_pin() {
local pkg="$1" want="$2" cmd="${LSPHP_MADISON_CMD:-apt-cache madison}"
local out v best="" up="${want%%-*}" suf=""
[[ "$want" == *+* ]] && suf="+${want#*+}"
out=$($cmd "$pkg") || { echo "lsphp-pin-resolve: '$cmd $pkg' failed" >&2; return 1; }
while read -r v; do
[ -n "$v" ] || continue
if [ "$v" = "$want" ]; then printf '%s\n' "$want"; return 0; fi
[ "${v%%-*}" = "$up" ] || continue
[ "$suf" = "" ] || [[ "$v" == *"$suf" ]] || continue
dpkg --compare-versions "$v" ge "$want" || continue
if [ -z "$best" ] || dpkg --compare-versions "$v" gt "$best"; then best="$v"; fi
done < <(awk -F'|' '{gsub(/ /,"",$2); print $2}' <<<"$out")
if [ -z "$best" ]; then
echo "lsphp-pin-resolve: $pkg offers no version of PHP $up compatible with $want" >&2
return 1
fi
printf '%s\n' "$best"
}
## lsphp_pin_ok INSTALLED WANT — post-install assertion for the -common/-ldap
## packages: same upstream PHP version as WANT and not older than it.
lsphp_pin_ok() {
local inst="$1" want="$2"
[ "${inst%%-*}" = "${want%%-*}" ] && dpkg --compare-versions "$inst" ge "$want"
}
if [ "${BASH_SOURCE[0]}" = "$0" ]; then
set -u
case "${1:-}" in
resolve) lsphp_resolve_pin "${2:?pkg}" "${3:?want}" ;;
ok) lsphp_pin_ok "${2:?installed}" "${3:?want}" ;;
*) echo "usage: $0 resolve PKG WANT | ok INSTALLED WANT" >&2; exit 2 ;;
esac
fi
+230
View File
@@ -0,0 +1,230 @@
#!/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
}
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]]
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" --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 --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
# ---- 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" --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
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" --expect-index "$EXP")" 1
mk noamd
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" --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" --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" --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" --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" --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; }
+57
View File
@@ -0,0 +1,57 @@
#!/usr/bin/env bash
## lsphp-pin-resolve.test.sh — fixture test for scripts/lsphp-pin-resolve.sh.
## Fake `apt-cache madison` outputs model (a) a consistent repo (82/83/85: the
## pin must stay EXACTLY the lsphp version), (b) the 2026-11-19 lsphp84 set
## (lsphp84 -2, -common -3 only), (c) cases that must FAIL closed.
set -euo pipefail
HERE=$(cd "$(dirname "$0")/.." && pwd)
R="$HERE/lsphp-pin-resolve.sh"
T=$(mktemp -d); trap 'rm -rf "$T"' EXIT
fail=0
ok() { echo "ok - $1"; }
bad() { echo "FAIL - $1"; fail=1; }
mk() { # file, then lines "pkg|version"
local f="$1"; shift
: >"$f"
for l in "$@"; do printf '%s | %s | http://rpms.litespeedtech.com/debian noble/main amd64 Packages\n' "${l%%|*}" "${l#*|}" >>"$f"; done
}
cat >"$T/apt-cache" <<'EOS'
#!/bin/sh
[ "$1" = madison ] || exit 2
grep -E "^ *$2 \|" "$FIX" || true
EOS
chmod +x "$T/apt-cache"
export LSPHP_MADISON_CMD="$T/apt-cache madison"
res() { FIX="$1" "$R" resolve "$2" "$3" 2>/dev/null; }
expect() { # name want fixture pkg ver
local got; got=$(res "$3" "$4" "$5") || got=FAIL
[ "$got" = "$2" ] && ok "$1" || bad "$1 (got '$got', want '$2')"
}
mk "$T/consistent" "lsphp85-common|8.5.12-2+noble" "lsphp85-ldap|8.5.12-2+noble"
expect "consistent repo: -common stays exact" "8.5.12-2+noble" "$T/consistent" lsphp85-common 8.5.12-2+noble
expect "consistent repo: -ldap stays exact" "8.5.12-2+noble" "$T/consistent" lsphp85-ldap 8.5.12-2+noble
mk "$T/incons" "lsphp84-common|8.4.27-3+noble" "lsphp84-ldap|8.4.27-2+noble"
expect "inconsistent: -common resolves to -3" "8.4.27-3+noble" "$T/incons" lsphp84-common 8.4.27-2+noble
expect "inconsistent: -ldap stays -2" "8.4.27-2+noble" "$T/incons" lsphp84-ldap 8.4.27-2+noble
mk "$T/two" "lsphp84-common|8.4.27-3+noble" "lsphp84-common|8.4.27-2+noble"
expect "exact version preferred over newer revision" "8.4.27-2+noble" "$T/two" lsphp84-common 8.4.27-2+noble
mk "$T/otherphp" "lsphp84-common|8.4.28-1+noble"
expect "different PHP version is never substituted" FAIL "$T/otherphp" lsphp84-common 8.4.27-2+noble
mk "$T/older" "lsphp84-common|8.4.27-1+noble"
expect "older revision is never substituted" FAIL "$T/older" lsphp84-common 8.4.27-2+noble
mk "$T/otherdist" "lsphp84-common|8.4.27-3+jammy"
expect "different distro suffix is never substituted" FAIL "$T/otherdist" lsphp84-common 8.4.27-2+noble
: >"$T/empty"
expect "package absent fails" FAIL "$T/empty" lsphp84-common 8.4.27-2+noble
okc() { "$R" ok "$1" "$2" 2>/dev/null; }
okc 8.4.27-3+noble 8.4.27-2+noble && ok "post-check accepts -3 for want -2" || bad "post-check accepts -3"
okc 8.4.27-2+noble 8.4.27-2+noble && ok "post-check accepts equal" || bad "post-check equal"
okc 8.4.28-1+noble 8.4.27-2+noble && bad "post-check must reject other PHP version" || ok "post-check rejects other PHP version"
okc 8.4.27-1+noble 8.4.27-2+noble && bad "post-check must reject older" || ok "post-check rejects older"
exit $fail
@@ -15,9 +15,16 @@ cat >"$T/session.c" <<'EOT'
"0", ZEND_INI_PERDIR, OnUpdateBool, rfc1867_cleanup, php_ps_globals, ps_globals)
EOT
## Run the exact sed expression from the script.
SEDLINE=$(grep -F "session\\.upload_progress\\.enabled" "$S" | grep '^ *sed -i' | head -n1)
## Plain loop, not a grep|grep|head pipeline: an early-exit reader under pipefail
## can SIGPIPE its writer (see lsphp-info-probe.test.sh structural scan).
SEDLINE=""
while IFS= read -r line; do
case "$line" in *'session\.upload_progress\.enabled'*) ;; *) continue ;; esac
case "$line" in ' '*'sed -i'*|'sed -i'*) SEDLINE="$line"; break ;; esac
done <"$S"
[ -n "$SEDLINE" ] || { echo "FAIL: sed line not found in script"; exit 1; }
SRC="$T"; sed() { command sed "$@"; }
export SRC="$T" # referenced by the eval'd sed line
sed() { command sed "$@"; }
eval "${SEDLINE//\$SRC\/ext\/session\/session.c/$T/session.c}"
chk "enabled flipped to 1" "$(grep -A1 'upload_progress.enabled' "$T/session.c" | grep -c '"1"')" 1
chk "cleanup untouched" "$(grep -A1 'upload_progress.cleanup' "$T/session.c" | grep -c '"0"')" 1
+112 -7
View File
@@ -136,7 +136,7 @@ class Wiring(unittest.TestCase):
st = step(self.jobs[j], 'Assemble')
script = re.search(r'run: \|\n((?: .*\n?)+)', st).group(1)
script = '\n'.join(l[10:] for l in script.split('\n'))
for ver in (['82', '83', '84', '85'] if matrix else ['']):
for ver in (['82', '83', '84', '85', '86'] if matrix else ['']):
with tempfile.TemporaryDirectory() as d:
os.makedirs(os.path.join(d, 'scripts'))
stub = os.path.join(d, 'scripts', 'assemble-multiarch-index.sh')
@@ -171,7 +171,8 @@ class Wiring(unittest.TestCase):
# ---- single-leg dispatch (workflow_dispatch input `only`, plan job) ----------------------
PLAN = os.path.join(ROOT, '.gitea', 'scripts', 'plan-legs.sh')
FULL = '[82,83,84,85]'
FULL = '[82,83,84,85]' # LiteSpeed families
FULL86 = '[82,83,84,85,86]' # cac / cac-fpm (Remi) also ship 8.6
# image job -> (plan output, matrix?)
LEGS = {
'Build-and-Push': ('cac', True),
@@ -183,7 +184,7 @@ LEGS = {
}
EMPTY = {'cac': '[]', 'cac_fpm': '[]', 'cac_litespeed': '[]', 'cac_lsphp': '[]',
'shared_httpd': 'false', 'shared_ols': 'false'}
EVERYTHING = {'cac': FULL, 'cac_fpm': FULL, 'cac_litespeed': FULL, 'cac_lsphp': FULL,
EVERYTHING = {'cac': FULL86, 'cac_fpm': FULL86, 'cac_litespeed': FULL, 'cac_lsphp': FULL,
'shared_httpd': 'true', 'shared_ols': 'true'}
@@ -262,9 +263,11 @@ class SingleLegDispatch(unittest.TestCase):
self.assertEqual((rc, kv), (0, EVERYTHING), (only, err))
def test_full_matrix_equals_the_old_literal(self):
# the pre-change matrix was `phpver: [82, 83, 84, 85]`
# the pre-86 matrix was `phpver: [82, 83, 84, 85]`; the LiteSpeed families keep it
rc, kv, _ = plan(None)
self.assertEqual([int(x) for x in kv['cac'].strip('[]').split(',')], [82, 83, 84, 85])
self.assertEqual([int(x) for x in kv['cac'].strip('[]').split(',')], [82, 83, 84, 85, 86])
for fam in ('cac_litespeed', 'cac_lsphp'):
self.assertEqual([int(x) for x in kv[fam].strip('[]').split(',')], [82, 83, 84, 85], fam)
def test_single_leg(self):
rc, kv, _ = plan('cac:php85')
@@ -287,7 +290,21 @@ class SingleLegDispatch(unittest.TestCase):
def test_family_name_means_every_version(self):
rc, kv, _ = plan('cac-fpm')
self.assertEqual((rc, kv), (0, dict(EMPTY, cac_fpm=FULL)))
self.assertEqual((rc, kv), (0, dict(EMPTY, cac_fpm=FULL86)))
rc, kv, _ = plan('cac-lsphp')
self.assertEqual((rc, kv), (0, dict(EMPTY, cac_lsphp=FULL)))
rc, kv, _ = plan('cac-litespeed')
self.assertEqual((rc, kv), (0, dict(EMPTY, cac_litespeed=FULL)))
def test_php86_only_for_remi_families(self):
rc, kv, _ = plan('cac:php86')
self.assertEqual((rc, kv), (0, dict(EMPTY, cac='[86]')))
rc, kv, _ = plan('cac-fpm:php86')
self.assertEqual((rc, kv), (0, dict(EMPTY, cac_fpm='[86]')))
for fam in ('cac-litespeed', 'cac-lsphp'):
rc, kv, err = plan(fam + ':php86')
self.assertEqual((rc, kv), (2, {}), fam)
self.assertIn('plan-legs:', err)
def test_comma_list_spaces_duplicates_and_ordering(self):
rc, kv, _ = plan(' cac:php85 , cac:php82,cac:php85, shared-httpd ,')
@@ -296,7 +313,7 @@ class SingleLegDispatch(unittest.TestCase):
self.assertEqual((rc, kv), (0, dict(EMPTY, cac='[85]', cac_fpm='[84]')))
def test_unknown_values_fail_loudly_and_emit_nothing(self):
bad = ['foo', 'cac:php99', 'cac:85', 'cac:php8', 'CAC:php85', 'cac:', 'cac:php85:x', 'php85',
bad = ['foo', 'cac:php99', 'cac:php87', 'cac-lsphp:php86', 'cac-litespeed:php86', 'cac:85', 'cac:php8', 'CAC:php85', 'cac:', 'cac:php85:x', 'php85',
'shared-httpd:php85', 'shared-ols:latest', ',', ' , ', 'cac:php85,nope',
'cac:php85;rm -rf x', '$(id)', 'all', 'latest']
for only in bad:
@@ -306,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:]))