claude
fb7a788c90
CI / shellcheck + selftests (pull_request) Failing after 1m19s
A cache key names a REF. What a target directory holds is the product of a ref
and a build configuration, and emowheel builds the same ref twice on every
push — once for the host, once for wasm32, in two jobs that start together.
Keyed on the ref alone, `cargo-cache@v1` handed both the same
CARGO_TARGET_DIR, and Cargo's target-directory lock is exclusive: the second
job sat on "Blocking waiting for file lock on build directory" for the length
of the first while holding a runner capacity slot, so a third repo's queued
job waited behind a job doing nothing.
`cache-lineage` is that second dimension. It names ONE directory level under
the cache root:
<cache-root>/target-<key> no lineage (unchanged)
<cache-root>/<lineage>/target-<key> a lineage
Nesting, not a suffix on the key, and that is the whole design decision.
`prune-cache.sh`'s liveness pass classifies a directory by recomputing
`target-<cache_key(branch)>` for every branch on origin and evicting whatever
does not match — a `target-<key>-wasm32` matches nothing, so it would be
classified dead and evicted unconditionally on every run. daniel/gitdan's
host-level arbiter reads the same shape (BRANCH_DIR_RE); a suffixed name falls
out of that too, so those caches would never be reclaim candidates and a whole
lineage would go missing from the shared disk budget. Nesting leaves both
matchers reading exactly the names they already read, one level down — which
is a layout that arbiter already walks (CI_CACHE_MAX_DEPTH is 2, and its own
suite pins the depth-2 case).
Every interacting part, checked rather than assumed:
- SEED: `seed-target-dir.sh` takes the root as an argument, so a PR branch in
a lineage layers over THAT lineage's base snapshot. Asserted.
- PUBLISH: `publish-snapshot.sh` derives both ends of the swap from the root.
The publish action now takes the root from the `CARGO_CACHE_ROOT` the
consume step exported, and CHECKS its own inputs against it — a publish step
left at the default while its consume step nested would otherwise republish
a different lineage's live target dir over that lineage's snapshot, on every
push, silently. `mode: release-lock` is exempt: it releases a lock on
`$CARGO_TARGET_DIR` and never touches a root.
- WATERMARK: per target dir, so it follows the lineage. Unchanged.
- PRUNE and LIVENESS: scoped to the root they are given, so a pass in one
lineage neither evicts nor sees a sibling's caches, or the flat layout's.
Liveness keeps resolving real branch names, which is what a key suffix would
have broken.
- ci_cache_reclaim: verified by dry-run against a fixture in this layout —
all six nested and flat dirs collected as candidates, protection resolved
correctly on the nested ones, and a `.stage-` stranded inside the lineage
found by the leftover sweep.
Refused lineage names are refused at resolve time, each rejection naming the
reader that imposes it: a path separator (the arbiter's depth budget), a
Cargo profile name (its no-descend list), a `target-`/`snapshot-` prefix (this
repo's own prune globs), a hex suffix (its per-branch-dir shape), a dot prefix
(the leftover-naming contract). None of these fails visibly on its own — each
produces a working directory that some pass silently stops seeing.
Setting no lineage resolves to the cache root byte for byte, so lublub, zemyna
and emowheel's `ci` job keep the exact directories they have on the volume.
New suite `cache-root-selftest.sh` (19 assertions), red-proven against three
deliberate breakages: a `cache_root_for` that ignores the lineage, a disabled
validator, and a `verify` that never rejects a mismatch.
195 lines
9.6 KiB
Bash
Executable File
195 lines
9.6 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# Regression test for cache-root.sh and the lineage rules in cache-lib.sh —
|
|
# the fix for daniel/gitdan#60, where two jobs building the same ref for
|
|
# different targets resolved to one CARGO_TARGET_DIR and serialised on Cargo's
|
|
# exclusive build-directory lock.
|
|
#
|
|
# 1. NO LINEAGE CHANGES NOTHING — the effective root is the cache root byte
|
|
# for byte, so every consumer that does not set a lineage keeps the exact
|
|
# directories it already has on the volume. This is the whole of the
|
|
# migration story for lublub, zemyna and emowheel's `ci` job, so it is
|
|
# asserted rather than assumed.
|
|
# 2. TWO LINEAGES, ONE REF, TWO TARGET DIRS — the bug itself. The two jobs
|
|
# keep one cache key (they are the same ref) and still get directories
|
|
# that are neither equal nor nested one inside the other, which is what
|
|
# Cargo's per-directory lock needs in order not to serialise them.
|
|
# 3. THE WHOLE PIPELINE MOVES TOGETHER — seed, publish and prune all operate
|
|
# inside the lineage root. A pass run in one lineage must not evict, or
|
|
# even see, a sibling lineage's caches or the flat layout's.
|
|
# 4. BASE SEEDING IS PER LINEAGE — a PR branch layers over ITS OWN lineage's
|
|
# base snapshot, not over whatever the flat root happens to hold. This is
|
|
# the property that keeps a warm start for both jobs rather than one.
|
|
# 5. A NAME NO READER CAN HANDLE IS REFUSED AT RESOLVE TIME — one assertion
|
|
# per constraint, each named for the reader that imposes it. None of these
|
|
# is a filesystem limit: every one of them produces a working directory
|
|
# that some pass silently stops seeing, which is the failure mode this
|
|
# whole scheme exists to avoid rather than to relocate.
|
|
# 6. A PUBLISH THAT DISAGREES WITH ITS CONSUME STEP FAILS LOUDLY — the
|
|
# footgun the lineage input introduces. cargo-cache-publish derives both
|
|
# ends of the snapshot swap from its own `cache-root`, so a publish step
|
|
# left at the default while its consume step nested would republish the
|
|
# OTHER lineage's live target dir over that lineage's snapshot, silently.
|
|
set -euo pipefail
|
|
script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
|
|
. "$script_dir/cache-lib.sh"
|
|
|
|
scratch=$(mktemp -d)
|
|
trap 'rm -rf "$scratch"' EXIT
|
|
root="$scratch/cache"; mkdir -p "$root"
|
|
pass_count=0
|
|
fail() { echo "ASSERTION FAILED: $*" >&2; exit 1; }
|
|
ok() { pass_count=$((pass_count + 1)); echo "PASS: $*"; }
|
|
|
|
resolve() { bash "$script_dir/cache-root.sh" resolve "$@"; }
|
|
|
|
# A tree that looks enough like a Cargo target dir for the pipeline scripts,
|
|
# with a marker naming which lineage produced it — scenario 4 turns on reading
|
|
# that marker back out of a seeded directory.
|
|
make_tree() {
|
|
local d="$1" marker="$2"
|
|
mkdir -p "$d/debug/deps" "$d/debug/.fingerprint/x"
|
|
echo "$marker" > "$d/debug/deps/libx.rlib"
|
|
echo "$marker" > "$d/lineage-marker"
|
|
echo "$marker" > "$d/debug/.fingerprint/x/dep-lib-x"
|
|
}
|
|
|
|
echo "=== 1. no lineage changes nothing ==="
|
|
|
|
[ "$(resolve /cache)" = /cache ] || fail "an omitted lineage changed the root"
|
|
[ "$(resolve /cache '')" = /cache ] || fail "an empty lineage changed the root"
|
|
ok "no lineage resolves to the cache root unchanged"
|
|
|
|
KEY=$(cache_key dev)
|
|
[ "$(target_dir_for "$(resolve /cache '')" "$KEY")" = "/cache/target-$KEY" ] \
|
|
|| fail "the flat target-dir name moved"
|
|
[ "$(snapshot_dir_for "$(resolve /cache '')" "$KEY")" = "/cache/snapshot-$KEY" ] \
|
|
|| fail "the flat snapshot name moved"
|
|
ok "the flat layout's directory names are untouched"
|
|
|
|
echo
|
|
echo "=== 2. two lineages, one ref, two target dirs ==="
|
|
|
|
HOST_ROOT=$(resolve /cache)
|
|
WASM_ROOT=$(resolve /cache wasm32)
|
|
[ "$WASM_ROOT" = /cache/wasm32 ] || fail "lineage root resolved to '$WASM_ROOT'"
|
|
HOST_DIR=$(target_dir_for "$HOST_ROOT" "$KEY")
|
|
WASM_DIR=$(target_dir_for "$WASM_ROOT" "$KEY")
|
|
[ "$HOST_DIR" != "$WASM_DIR" ] || fail "both lineages resolved to $HOST_DIR"
|
|
case "$WASM_DIR" in "$HOST_DIR"/*) fail "the wasm target dir sits inside the host one" ;; esac
|
|
case "$HOST_DIR" in "$WASM_DIR"/*) fail "the host target dir sits inside the wasm one" ;; esac
|
|
ok "one cache key ($KEY), two disjoint target dirs: $HOST_DIR and $WASM_DIR"
|
|
|
|
echo
|
|
echo "=== 3. the whole pipeline moves together ==="
|
|
|
|
DEAD=$(cache_key feat/dead)
|
|
lin="$root/wasm32"
|
|
mkdir -p "$lin"
|
|
make_tree "$root/target-$DEAD" flat
|
|
make_tree "$root/native/target-$DEAD" native
|
|
make_tree "$lin/target-$DEAD" wasm32
|
|
bash "$script_dir/seed-target-dir.sh" "$KEY" "" "$lin" tag-3 > "$scratch/seed3.log" 2>&1 \
|
|
|| { cat "$scratch/seed3.log"; fail "seed inside a lineage root failed"; }
|
|
[ -d "$lin/target-$KEY" ] || fail "seed did not create $lin/target-$KEY"
|
|
[ -d "$root/target-$KEY" ] && fail "seed created a directory at the flat root as well"
|
|
ok "seed creates its directory under the lineage root and nowhere else"
|
|
|
|
make_tree "$lin/target-$KEY" wasm32
|
|
bash "$script_dir/publish-snapshot.sh" "$KEY" "$lin" tag-3 > "$scratch/pub3.log" 2>&1 \
|
|
|| { cat "$scratch/pub3.log"; fail "publish inside a lineage root failed"; }
|
|
[ -d "$lin/snapshot-$KEY" ] || fail "publish did not create $lin/snapshot-$KEY"
|
|
[ -d "$root/snapshot-$KEY" ] && fail "publish created a snapshot at the flat root as well"
|
|
ok "publish writes its snapshot under the lineage root and nowhere else"
|
|
|
|
# Free space far below the threshold, so pass 2 evicts every eligible
|
|
# directory it can see. What it can see is the point of the scenario.
|
|
CACHE_LIVENESS=false CACHE_DF_OVERRIDE="1000000 1000" \
|
|
bash "$script_dir/prune-cache.sh" "$lin" "$lin/target-$KEY" 'dev main' 10 \
|
|
> "$scratch/prune3.log" 2>&1 || { cat "$scratch/prune3.log"; fail "prune inside a lineage root failed"; }
|
|
[ -d "$lin/target-$DEAD" ] && { cat "$scratch/prune3.log"; fail "prune left its own lineage's evictable cache in place"; }
|
|
[ -d "$root/target-$DEAD" ] || fail "prune reached out of its lineage and evicted the flat root's cache"
|
|
[ -d "$root/native/target-$DEAD" ] || fail "prune reached into a sibling lineage and evicted its cache"
|
|
ok "prune under disk pressure evicts inside its own lineage only"
|
|
|
|
echo
|
|
echo "=== 4. base seeding is per lineage ==="
|
|
|
|
BASE=$(cache_key dev)
|
|
PR=$(cache_key feat/pr)
|
|
rm -rf "$lin" "$root/snapshot-$BASE"
|
|
mkdir -p "$lin"
|
|
make_tree "$root/snapshot-$BASE" flat-base
|
|
make_tree "$lin/snapshot-$BASE" wasm32-base
|
|
bash "$script_dir/seed-target-dir.sh" "$PR" "$BASE" "$lin" tag-4 > "$scratch/seed4.log" 2>&1 \
|
|
|| { cat "$scratch/seed4.log"; fail "seeding a PR branch inside a lineage failed"; }
|
|
[ -d "$lin/target-$PR" ] || fail "the PR branch's lineage target dir was not created"
|
|
got=$(cat "$lin/target-$PR/lineage-marker")
|
|
[ "$got" = wasm32-base ] || fail "the PR branch layered over '$got', not its own lineage's base snapshot"
|
|
grep -q 'base snapshot' "$scratch/seed4.log" || { cat "$scratch/seed4.log"; fail "seed did not report a base-snapshot clone"; }
|
|
ok "a PR branch layers over its own lineage's base snapshot ($got)"
|
|
|
|
echo
|
|
echo "=== 5. a name no reader can handle is refused ==="
|
|
|
|
reject() {
|
|
local lineage="$1" want="$2" desc="$3" out
|
|
if out=$(resolve /cache "$lineage" 2>&1); then
|
|
fail "lineage '$lineage' was accepted (resolved to '$out') — $desc"
|
|
fi
|
|
case "$out" in
|
|
*"$want"*) ;;
|
|
*) fail "lineage '$lineage' was rejected without naming '$want': $out" ;;
|
|
esac
|
|
ok "rejected '$lineage' — $desc"
|
|
}
|
|
|
|
reject 'a/b' 'single path component' "the arbiter walks a volume to depth 2"
|
|
reject '.hidden' 'dot' "every dot-prefixed name under a cache root is leftover-contract territory"
|
|
reject 'target-x' 'prune-cache.sh' "prune-cache.sh globs target-* at the cache root"
|
|
reject 'snapshot-x' 'prune-cache.sh' "prune-cache.sh globs snapshot-* at the cache root"
|
|
reject 'wasm 32' 'A-Za-z0-9._-' "a cache key is sanitised to that charset and a lineage sits beside one"
|
|
reject 'release' 'CI_CACHE_NODESCEND_NAMES' "the arbiter never descends into a Cargo profile name"
|
|
reject 'doc' 'CI_CACHE_NODESCEND_NAMES' "same, for the docs profile directory"
|
|
reject 'lineage-deadbeef' 'per-branch cache directory' "the arbiter reads a hex-suffixed name as one cache dir"
|
|
|
|
for good in wasm32 web android host wasm32.release lineage_2; do
|
|
out=$(resolve /cache "$good") || fail "lineage '$good' was rejected: $out"
|
|
[ "$out" = "/cache/$good" ] || fail "lineage '$good' resolved to '$out'"
|
|
done
|
|
ok "ordinary lineage names still resolve"
|
|
|
|
echo
|
|
echo "=== 6. a publish that disagrees with its consume step fails loudly ==="
|
|
|
|
verify() { bash "$script_dir/cache-root.sh" verify "$@"; }
|
|
|
|
verify /cache wasm32 /cache/wasm32 > /dev/null 2>&1 \
|
|
|| fail "verify rejected a publish step that agrees with its consume step"
|
|
verify /cache '' /cache > /dev/null 2>&1 \
|
|
|| fail "verify rejected an unmigrated consumer's matching default pair"
|
|
ok "verify accepts a publish step whose inputs match what the consume step exported"
|
|
|
|
# The exact shape of the mistake: the consume step nested, the publish step
|
|
# kept the default. Left unchecked this republishes the host lineage's live
|
|
# target dir over the host lineage's snapshot, from the wasm job.
|
|
if out=$(verify /cache '' /cache/wasm32 2>&1); then
|
|
fail "verify accepted a publish step that resolved to /cache while the job exported /cache/wasm32"
|
|
fi
|
|
case "$out" in
|
|
*'/cache/wasm32'*) ;;
|
|
*) fail "the mismatch error does not quote what the consume step exported: $out" ;;
|
|
esac
|
|
case "$out" in
|
|
*'SAME cache-root and cache-lineage'*) ;;
|
|
*) fail "the mismatch error does not say what to do about it: $out" ;;
|
|
esac
|
|
ok "verify rejects a publish step that forgot the lineage, and says so"
|
|
|
|
if verify /cache 'a/b' /cache/a/b > /dev/null 2>&1; then
|
|
fail "verify accepted an invalid lineage as long as both sides agreed on it"
|
|
fi
|
|
ok "verify validates the lineage as well as comparing it"
|
|
|
|
echo
|
|
echo "cache-root-selftest: ${pass_count} assertions passed"
|