diff options
Diffstat (limited to 'docs/plans/2026-07-13-docker-test-build.md')
| -rw-r--r-- | docs/plans/2026-07-13-docker-test-build.md | 1579 |
1 files changed, 1579 insertions, 0 deletions
diff --git a/docs/plans/2026-07-13-docker-test-build.md b/docs/plans/2026-07-13-docker-test-build.md new file mode 100644 index 0000000..6195de9 --- /dev/null +++ b/docs/plans/2026-07-13-docker-test-build.md @@ -0,0 +1,1579 @@ +# Docker test-build Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** A single bash script `.extras/test-build` that verifies an already-published SBo package still builds cleanly on `-current` or `15.0` inside a throwaway docker container, resolving and building its SBo deps from the local tree, caching built deps per image digest, and reporting per-package status + lint. + +**Architecture:** Host resolves the dep tree from the local SBo tree (logic ported from `sbo-batch-test`), applies current-vs-stable override rules, prints the build order and confirms, then runs one `docker run --rm` that builds deps (or installs them from a host cache) and the target, lints the target, and streams results back. The container is the disposable environment (no overlayfs). Images are built by a separate job and consumed by tag. + +**Tech Stack:** Bash, docker, Slackware `installpkg`/`makepkg`, `sbo-maintainer-tools` (`sbopkglint`). Self-check is plain bash (`test-logic.sh`), no framework. + +--- + +## Reference source + +Port from `/home/danix/Programming/GIT/sbo-batch-tester/sbo-batch-test`. These +functions are lifted with minimal change (they are pure or host-side): + +- `find_slackbuild_dir`, `category_of`, `pkg_key`, `read_requires`, + `version_of`, `installed_in_base` +- resolver: `_resolve_visit`, `resolve_target`, globals `RESOLVED_ORDER`, + `UNMET`, `CYCLES`, `HAS_README`, `_vstate` +- cache: `_cache_ver_of`, `cache_decision`, `cache_path`, `cache_store`, + `cache_label` +- `depends_on_failed`, `print_summary`, `lint_pkg`, `init_color` +- self-check patterns from + `/home/danix/Programming/GIT/sbo-batch-tester/test-logic.sh` + +What is NEW or CHANGED in this repo: + +- overlay lifecycle (`setup_overlay`/`teardown_overlay`/`cleanup_trap`) is + REMOVED. The container replaces it. +- `build_one` is rewritten to run its build steps via `docker run` instead of + `chroot`. +- image + tree selection by version (`--stable`). +- override engine (drop / rename / fetch) applied to the resolved order. +- cache namespaced by image digest. +- config keys differ (see Task 2). + +## File Structure + +- Create: `/home/danix/Programming/GIT/sbo-slackbuilds/.extras/test-build` + (the script, executable) +- Create: + `/home/danix/Programming/GIT/sbo-slackbuilds/.extras/test-build-config.example` + (config template) +- Create: + `/home/danix/Programming/GIT/sbo-slackbuilds/.extras/overrides.example` + (override-rules template) +- Create: + `/home/danix/Programming/GIT/sbo-slackbuilds/.extras/test-logic.sh` + (self-check) + +All work happens in `.extras/`. Run every command from the repo root +`/home/danix/Programming/GIT/sbo-slackbuilds`. + +Note on committing: this repo has a pre-commit hook that runs `sbolint` on +staged packages. `.extras/` files are not packages, but to be safe every +commit in this plan uses `SBOLINT=no git commit ...`. Commits are GPG-signed +automatically; do not disable signing. + +--- + +## Task 1: Scaffold the script + smoke self-check + +**Files:** +- Create: `.extras/test-build` +- Create: `.extras/test-logic.sh` + +- [ ] **Step 1: Write the failing self-check** + +Create `.extras/test-logic.sh`: + +```bash +#!/bin/bash +# +# Logic self-check for .extras/test-build. Covers the pure, host-side parts: +# dependency resolution, override application, unknown-dep -> UNMET, cache +# decisions, and BLOCKED-BY-DEP propagation. No docker. +# +# Run: bash .extras/test-logic.sh +# +set -uo pipefail + +SCRIPT="$(dirname "$0")/test-build" +T=$(mktemp -d) +BASE_DB=$(mktemp -d); mkdir -p "$BASE_DB" + +cleanup() { rm -rf "$T" "$BASE_DB"; } +trap cleanup EXIT + +# Source the script without running main(). Sourcing re-runs the CONFIG block, +# so set test vars AFTER the source. +LIB=$(mktemp) +sed '/^main "\$@"$/d' "$SCRIPT" > "$LIB" +# shellcheck disable=SC1090 +source "$LIB" 2>/dev/null +rm -f "$LIB" + +pass=0; fail=0 +ok() { echo " ok: $1"; ((pass++)); return 0; } +bad() { echo " FAIL: $1"; ((fail++)); return 0; } + +# Placeholder assertion so this file runs before any logic exists. +ok "script sources without executing main" + +echo +echo "$pass passed, $fail failed" +[[ $fail -eq 0 ]] || exit 1 +echo "ALL LOGIC CHECKS PASS" +``` + +- [ ] **Step 2: Run it to verify it fails** + +Run: `bash .extras/test-logic.sh` +Expected: FAIL. `$SCRIPT` does not exist yet, `sed`/`source` on a missing file +errors, no "ALL LOGIC CHECKS PASS". + +- [ ] **Step 3: Write the minimal script skeleton** + +Create `.extras/test-build`: + +```bash +#!/bin/bash +# +# test-build - verify an already-published SBo package still builds on a target +# Slackware version inside a throwaway docker container. Resolves + builds its +# SBo deps from the local tree, caches built deps per image digest, reports +# per-package status and lints the target. +# +# Dependency-resolution, cache, and summary logic are adapted from sbo-batch-test +# (github: danixland). The overlay chroot is replaced by a docker container: the +# container IS the disposable environment, so no overlayfs. +# +# No em dashes in prose by author convention. + +# ============================================================================= +# CONFIG (do not edit here; real values live in the external config file) +# ============================================================================= +SBO_TREE_CURRENT="" +SBO_TREE_STABLE="" +IMAGE_CURRENT="" +IMAGE_STABLE="" +LOG_ROOT="/var/log/sbo-test-build" +PKG_CACHE="" + +TB_CONFIG="${TB_CONFIG:-$HOME/.config/sbo-testbuild/config}" +if [[ -f "$TB_CONFIG" ]]; then + # shellcheck disable=SC1090 + source "$TB_CONFIG" +fi + +TB_OVERRIDES="${TB_OVERRIDES:-$HOME/.config/sbo-testbuild/overrides}" + +# ============================================================================= +set -uo pipefail +# Not -e: a package build failing is a handled outcome, not a script crash. + +main() { + : +} + +main "$@" +``` + +- [ ] **Step 4: Run the self-check to verify it passes** + +Run: `bash .extras/test-logic.sh` +Expected: PASS, ending `ALL LOGIC CHECKS PASS`. + +- [ ] **Step 5: Commit** + +```bash +chmod +x .extras/test-build +git add .extras/test-build .extras/test-logic.sh +SBOLINT=no git commit -m 'test-build: scaffold script + self-check' +``` + +--- + +## Task 2: Config, arg parsing, version selection + +**Files:** +- Modify: `.extras/test-build` +- Create: `.extras/test-build-config.example` +- Test: `.extras/test-logic.sh` + +- [ ] **Step 1: Write the failing test** + +Append to `.extras/test-logic.sh` before the `--- result ---` block (the +`echo; "$pass passed..."` lines at the end): + +```bash +# --- version selection ------------------------------------------------------ +SBO_TREE_CURRENT="/trees/current" +SBO_TREE_STABLE="/trees/stable" +IMAGE_CURRENT="sbo-testbuild:current" +IMAGE_STABLE="sbo-testbuild:15.0" + +VERSION_ID="current"; select_version_paths +[[ "$ACTIVE_TREE" == "/trees/current" ]] && ok "current -> current tree" || bad "current tree wrong: [$ACTIVE_TREE]" +[[ "$ACTIVE_IMAGE" == "sbo-testbuild:current" ]] && ok "current -> current image" || bad "current image wrong: [$ACTIVE_IMAGE]" + +VERSION_ID="15.0"; select_version_paths +[[ "$ACTIVE_TREE" == "/trees/stable" ]] && ok "15.0 -> stable tree" || bad "stable tree wrong: [$ACTIVE_TREE]" +[[ "$ACTIVE_IMAGE" == "sbo-testbuild:15.0" ]] && ok "15.0 -> stable image" || bad "stable image wrong: [$ACTIVE_IMAGE]" +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `bash .extras/test-logic.sh` +Expected: FAIL, `select_version_paths: command not found`. + +- [ ] **Step 3: Implement config globals, flags, parse_args, select_version_paths** + +In `.extras/test-build`, replace the `main() { : }` line and everything up to +`main "$@"` with the flags/globals and functions below (keep the CONFIG block +above untouched): + +```bash +# ---- flags / globals -------------------------------------------------------- +USE_COLOR=1 # --no-color or non-TTY disables +DRY_RUN=0 # --dry-run: resolve + print order, do not build +ASSUME_YES=0 # --yes: skip the confirm prompt (still prints the order) +USE_CACHE=1 # --no-cache disables the dep cache for one run +VERSION_ID="current" # "current" | "15.0"; set by --stable +TARGET_ARG="" + +ACTIVE_TREE="" # selected SBo tree (by version) +ACTIVE_IMAGE="" # selected image tag (by version) +RUN_DIR="" # timestamped log dir for this run + +# Status tracking. Keyed by "category/prog". Parallel assoc arrays. +declare -A ST_STATUS=() +declare -A ST_REASON=() +declare -A ST_TIME=() +declare -A ST_README=() + +usage() { + cat <<'EOF' +test-build - verify an SBo package builds on a target Slackware in docker + +USAGE: + test-build [OPTIONS] <program-name> + +OPTIONS: + -h, --help This text. + --stable Target Slackware 15.0 (image + tree). Default is -current. + --dry-run Resolve, apply overrides, print the build order, do not build. + --yes Skip the confirm prompt (the order is still printed first). + --no-cache Rebuild all deps this run, ignore/refresh the cache. + --no-color Disable ANSI color (auto-disabled when stdout is not a TTY). +EOF +} + +parse_args() { + while [[ $# -gt 0 ]]; do + case "$1" in + -h|--help) usage; exit 0 ;; + --stable|15.0) VERSION_ID="15.0"; shift ;; + --dry-run) DRY_RUN=1; shift ;; + --yes) ASSUME_YES=1; shift ;; + --no-cache) USE_CACHE=0; shift ;; + --no-color) USE_COLOR=0; shift ;; + -*) echo "Unknown option: $1" >&2; usage >&2; exit 2 ;; + *) + if [[ -n "$TARGET_ARG" ]]; then + echo "Only one target accepted (got '$TARGET_ARG' and '$1')." >&2 + exit 2 + fi + TARGET_ARG="$1"; shift ;; + esac + done + if [[ -z "$TARGET_ARG" ]]; then + echo "No target given." >&2; usage >&2; exit 2 + fi +} + +init_color() { + if [[ $USE_COLOR -eq 1 && -t 1 ]]; then + C_RED=$'\e[31m'; C_GRN=$'\e[32m'; C_YEL=$'\e[33m'; C_RST=$'\e[0m' + else + C_RED=""; C_GRN=""; C_YEL=""; C_RST="" + fi +} + +# Map VERSION_ID to the active tree + image. No I/O, unit-testable. +select_version_paths() { + if [[ "$VERSION_ID" == "15.0" ]]; then + ACTIVE_TREE="$SBO_TREE_STABLE"; ACTIVE_IMAGE="$IMAGE_STABLE" + else + ACTIVE_TREE="$SBO_TREE_CURRENT"; ACTIVE_IMAGE="$IMAGE_CURRENT" + fi +} + +# require_config: the external config must exist and set the version's paths. +require_config() { + if [[ ! -f "$TB_CONFIG" ]]; then + cat >&2 <<EOF +No config file: $TB_CONFIG +Copy the example and edit it: + + mkdir -p "\$(dirname "$TB_CONFIG")" + cp .extras/test-build-config.example "$TB_CONFIG" + \${EDITOR:-vi} "$TB_CONFIG" +EOF + exit 1 + fi + select_version_paths + if [[ -z "$ACTIVE_TREE" || -z "$ACTIVE_IMAGE" ]]; then + echo "Config $TB_CONFIG is missing the tree/image for version '$VERSION_ID'." >&2 + exit 1 + fi + if [[ ! -d "$ACTIVE_TREE" ]]; then + echo "SBo tree for '$VERSION_ID' does not exist: $ACTIVE_TREE" >&2 + exit 1 + fi +} + +main() { + parse_args "$@" + init_color + require_config +} + +main "$@" +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `bash .extras/test-logic.sh` +Expected: PASS (the new version-selection checks included). + +- [ ] **Step 5: Write the config example** + +Create `.extras/test-build-config.example`: + +```bash +# test-build config. Copy to ~/.config/sbo-testbuild/config and edit. +# Override the path with the TB_CONFIG environment variable. + +# Local SBo trees, one per target Slackware version. +SBO_TREE_CURRENT="/home/danix/SBo/current" +SBO_TREE_STABLE="/home/danix/SBo/15.0" + +# Ready image tags (built by a separate job, consumed here by tag). +IMAGE_CURRENT="sbo-testbuild:current" +IMAGE_STABLE="sbo-testbuild:15.0" + +# Where per-run logs land. +LOG_ROOT="/home/danix/.cache/sbo-test-build" + +# Dependency package cache (host dir). Empty disables caching. +# Namespaced internally by image digest, so it self-invalidates on image update +# and keeps current vs 15.0 separate. +PKG_CACHE="/home/danix/.cache/sbo-test-build/pkgcache" +``` + +- [ ] **Step 6: Commit** + +```bash +git add .extras/test-build .extras/test-build-config.example .extras/test-logic.sh +SBOLINT=no git commit -m 'test-build: config, arg parsing, version selection' +``` + +--- + +## Task 3: Port the SBo-tree lookup + resolver + self-check + +**Files:** +- Modify: `.extras/test-build` +- Test: `.extras/test-logic.sh` + +- [ ] **Step 1: Write the failing test** + +Append to `.extras/test-logic.sh` before the result block: + +```bash +# --- resolution ------------------------------------------------------------- +# Fake SBo tree under one category. mk <prog> "<REQUIRES>". +mk() { mkdir -p "$T/cat/$1"; echo "REQUIRES=\"$2\"" > "$T/cat/$1/$1.info"; } +mk c "" +mk b "c" +mk a "b %README%" +mk d "nonexistentpkg" +mk e "f" +mk f "e" +mk g "b" + +SBO_TREE_ROOTS=("$T") # resolver reads this global (set by select in real runs) + +resolve_target "$T/cat/a" +order=""; for x in "${RESOLVED_ORDER[@]}"; do order+="$(basename "$x") "; done +order="${order% }" +[[ "$order" == "c b a" ]] && ok "topo order c b a" || bad "topo order, got: [$order]" +[[ "${HAS_README[$T/cat/a]:-}" == "1" ]] && ok "%README% recorded" || bad "%README% not recorded" +[[ ${#UNMET[@]} -eq 0 ]] && ok "no false unmet" || bad "unexpected unmet" + +resolve_target "$T/cat/d" +[[ ${#UNMET[@]} -eq 1 ]] && ok "unmet-dep caught" || bad "unmet-dep missed" + +resolve_target "$T/cat/e" +[[ ${#CYCLES[@]} -ge 1 ]] && ok "cycle caught" || bad "cycle missed" +``` + +Note: the base-installed check (`installed_in_base`) is exercised in real runs +against the container, not here. In the self-check `BASE_DB` is empty, so a dep +that is neither in the tree nor a known override reads as UNMET (which is the +behavior we test with `d`). + +- [ ] **Step 2: Run test to verify it fails** + +Run: `bash .extras/test-logic.sh` +Expected: FAIL, `resolve_target: command not found`. + +- [ ] **Step 3: Implement lookup + resolver (ported)** + +Add to `.extras/test-build` above `main()`: + +```bash +# ============================================================================= +# SBo tree lookup +# ============================================================================= +# In this tool there is one active tree per run, but the resolver reads an array +# named SBO_TREE_ROOTS so the ported logic and its self-check match sbo-batch-test. +# main() sets SBO_TREE_ROOTS=("$ACTIVE_TREE") after require_config. +declare -a SBO_TREE_ROOTS=() + +find_slackbuild_dir() { + local prog="$1" root d + for root in "${SBO_TREE_ROOTS[@]}"; do + [[ -d "$root" ]] || continue + for d in "$root"/*/"$prog"; do + if [[ -d "$d" && -f "$d/$prog.info" ]]; then + echo "$d"; return 0 + fi + done + done + return 1 +} + +category_of() { basename "$(dirname "$1")"; } +pkg_key() { echo "$(category_of "$1")/$(basename "$1")"; } + +read_requires() { + local info="$1" + # shellcheck disable=SC1090 + ( set +u; source "$info"; echo "${REQUIRES:-}" ) +} + +version_of() { + local dir="$1" + local info="$dir/$(basename "$dir").info" + [[ -f "$info" ]] || return + local v; v="$(grep -m1 '^VERSION=' "$info" | cut -d'"' -f2)" + echo "$v" +} + +# ============================================================================= +# DEPENDENCY RESOLUTION (topo sort + cycle detection, LOCAL tree only) +# ============================================================================= +declare -a RESOLVED_ORDER=() +declare -A UNMET=() +declare -a CYCLES=() +declare -A HAS_README=() +declare -A _vstate=() + +# Is a prog already present in the container base? Overridden at build time to +# consult the image; in resolution we treat "in base" as a callback so the pure +# topo logic stays testable. Default: not in base (self-check has no base db). +installed_in_base() { return 1; } + +_resolve_visit() { + local dir="$1" parent="$2" + local key; key="$(basename "$dir")" + + if [[ "${_vstate[$dir]:-}" == "1" ]]; then return 0; fi + if [[ "${_vstate[$dir]:-}" == "0" ]]; then + CYCLES+=("cycle involving $key (pulled in via $parent)") + return 1 + fi + _vstate["$dir"]=0 + + local info="$dir/$(basename "$dir").info" + local req tok depdir rc=0 + req="$(read_requires "$info")" + for tok in $req; do + if [[ "$tok" == "%README%" ]]; then + HAS_README["$dir"]=1 + continue + fi + if depdir="$(find_slackbuild_dir "$tok")"; then + _resolve_visit "$depdir" "$key" || rc=1 + elif installed_in_base "$tok"; then + : + else + UNMET["$tok"]="needed by $key" + rc=1 + fi + done + + _vstate["$dir"]=1 + RESOLVED_ORDER+=("$dir") + return $rc +} + +resolve_target() { + local dir="$1" + RESOLVED_ORDER=() + CYCLES=() + UNMET=() + _vstate=() + _resolve_visit "$dir" "(top)" +} +``` + +Update `main()` to set the resolver's tree array after `require_config`: + +```bash +main() { + parse_args "$@" + init_color + require_config + SBO_TREE_ROOTS=("$ACTIVE_TREE") +} +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `bash .extras/test-logic.sh` +Expected: PASS (topo order, %README%, unmet, cycle checks green). + +- [ ] **Step 5: Commit** + +```bash +git add .extras/test-build .extras/test-logic.sh +SBOLINT=no git commit -m 'test-build: port SBo lookup + dependency resolver' +``` + +--- + +## Task 4: Override engine (drop / rename / fetch) + UNMET stop + +**Files:** +- Modify: `.extras/test-build` +- Create: `.extras/overrides.example` +- Test: `.extras/test-logic.sh` + +The override file encodes current-vs-stable deltas. It is applied ONLY when +`VERSION_ID == current` (15.0 is the SBo baseline). Rules: + +- `drop: <prog>` remove from the build order (already in -current base) +- `rename: <old> -> <new>` rewrite the dep name before it is looked up +- `fetch: <prog>` mark this dep to come from sbopkg in-container, not the local tree + +- [ ] **Step 1: Write the failing test** + +Append to `.extras/test-logic.sh` before the result block: + +```bash +# --- overrides -------------------------------------------------------------- +OV=$(mktemp) +cat > "$OV" <<'EOF' +# comment ignored +drop: dropme +rename: oldname -> newname +fetch: fetchme +EOF +TB_OVERRIDES="$OV" +load_overrides + +[[ "${OV_DROP[dropme]:-}" == "1" ]] && ok "override drop parsed" || bad "drop not parsed" +[[ "${OV_RENAME[oldname]:-}" == "newname" ]] && ok "override rename parsed" || bad "rename not parsed" +[[ "${OV_FETCH[fetchme]:-}" == "1" ]] && ok "override fetch parsed" || bad "fetch not parsed" + +# rename maps a token +[[ "$(apply_rename oldname)" == "newname" ]] && ok "apply_rename maps" || bad "apply_rename wrong: [$(apply_rename oldname)]" +[[ "$(apply_rename untouched)" == "untouched" ]] && ok "apply_rename passthrough" || bad "apply_rename mangled untouched" + +# drop filters the order (build a fake order of dirs; dropme is removed) +mk dropme "" +mk keepme "" +RESOLVED_ORDER=("$T/cat/dropme" "$T/cat/keepme") +apply_overrides_to_order +kept=""; for x in "${RESOLVED_ORDER[@]}"; do kept+="$(basename "$x") "; done +kept="${kept% }" +[[ "$kept" == "keepme" ]] && ok "drop removes from order" || bad "drop failed, order=[$kept]" +rm -f "$OV" + +# overrides only apply on current; on 15.0 they are a no-op +VERSION_ID="15.0" +TB_OVERRIDES="$OV" # file gone; must not error, must clear maps +load_overrides +[[ ${#OV_DROP[@]} -eq 0 ]] && ok "overrides inert on 15.0" || bad "overrides applied on 15.0" +VERSION_ID="current" +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `bash .extras/test-logic.sh` +Expected: FAIL, `load_overrides: command not found`. + +- [ ] **Step 3: Implement the override engine** + +Add to `.extras/test-build` above `main()`: + +```bash +# ============================================================================= +# current-vs-stable overrides. Parsed from $TB_OVERRIDES. Applied only when +# targeting -current (15.0 is the SBo baseline, no deltas). +# ============================================================================= +declare -A OV_DROP=() # prog -> 1 +declare -A OV_RENAME=() # old -> new +declare -A OV_FETCH=() # prog -> 1 + +load_overrides() { + OV_DROP=(); OV_RENAME=(); OV_FETCH=() + # 15.0 is the baseline: no overrides. + [[ "$VERSION_ID" == "15.0" ]] && return + [[ -f "$TB_OVERRIDES" ]] || return + local line kind rest + while IFS= read -r line; do + line="${line%%#*}" # strip comments + line="${line#"${line%%[![:space:]]*}"}" # ltrim + [[ -z "$line" ]] && continue + kind="${line%%:*}"; rest="${line#*:}" + kind="${kind//[[:space:]]/}" + rest="${rest#"${rest%%[![:space:]]*}"}" # ltrim value + case "$kind" in + drop) OV_DROP["${rest//[[:space:]]/}"]=1 ;; + fetch) OV_FETCH["${rest//[[:space:]]/}"]=1 ;; + rename) + # rest is "old -> new" + local old new + old="${rest%%->*}"; new="${rest##*->}" + old="${old//[[:space:]]/}"; new="${new//[[:space:]]/}" + [[ -n "$old" && -n "$new" ]] && OV_RENAME["$old"]="$new" ;; + *) echo "WARN: unknown override rule: $line" >&2 ;; + esac + done < "$TB_OVERRIDES" +} + +# Map a dep token through rename rules (identity if no rule). +apply_rename() { + local tok="$1" + echo "${OV_RENAME[$tok]:-$tok}" +} + +# Remove dropped packages from RESOLVED_ORDER in place. +apply_overrides_to_order() { + local d prog keep=() + for d in "${RESOLVED_ORDER[@]}"; do + prog="$(basename "$d")" + [[ "${OV_DROP[$prog]:-}" == "1" ]] && continue + keep+=("$d") + done + RESOLVED_ORDER=("${keep[@]:-}") +} +``` + +Wire `apply_rename` into the resolver so renamed deps look up under the new +name. In `_resolve_visit`, change the dep-lookup line: + +```bash + for tok in $req; do + if [[ "$tok" == "%README%" ]]; then + HAS_README["$dir"]=1 + continue + fi + tok="$(apply_rename "$tok")" # <-- add this line + if [[ "${OV_FETCH[$tok]:-}" == "1" ]]; then + FETCH_DEPS["$tok"]=1 # satisfied via sbopkg at build time + continue + fi + if depdir="$(find_slackbuild_dir "$tok")"; then + _resolve_visit "$depdir" "$key" || rc=1 + elif installed_in_base "$tok"; then + : + else + UNMET["$tok"]="needed by $key" + rc=1 + fi + done +``` + +Add the `FETCH_DEPS` global with the other resolver globals: + +```bash +declare -A FETCH_DEPS=() # prog -> 1: resolve via sbopkg in-container +``` + +And reset it in `resolve_target`: + +```bash +resolve_target() { + local dir="$1" + RESOLVED_ORDER=() + CYCLES=() + UNMET=() + FETCH_DEPS=() + _vstate=() + _resolve_visit "$dir" "(top)" +} +``` + +Load overrides in `main()` (before any resolve happens, after tree setup): + +```bash +main() { + parse_args "$@" + init_color + require_config + SBO_TREE_ROOTS=("$ACTIVE_TREE") + load_overrides +} +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `bash .extras/test-logic.sh` +Expected: PASS (all override checks green). + +- [ ] **Step 5: Write the overrides example** + +Create `.extras/overrides.example`: + +``` +# current-vs-stable dep overrides for test-build. +# Copy to ~/.config/sbo-testbuild/overrides and edit. Applied only when +# targeting -current (15.0 is the SBo baseline). One rule per line. +# +# drop: <prog> dep is in 15.0 but already in the -current base +# rename: <old> -> <new> dep was renamed on -current +# fetch: <prog> dep was removed from the -current tree; pull via sbopkg +# +# Start light: add rules only when a real package needs them. + +# drop: rust +# rename: python3-foo -> foo +# fetch: somelib +``` + +- [ ] **Step 6: Commit** + +```bash +git add .extras/test-build .extras/overrides.example .extras/test-logic.sh +SBOLINT=no git commit -m 'test-build: current-vs-stable override engine' +``` + +--- + +## Task 5: Port the dep cache, namespaced by image digest + +**Files:** +- Modify: `.extras/test-build` +- Test: `.extras/test-logic.sh` + +The cache is the ported sbo-batch-test cache with one change: the cache root +seen by `cache_*` is `$PKG_CACHE/<image-digest>`, computed once per run. A new +digest gives a fresh namespace (old deps ignored), which is the invalidation. + +- [ ] **Step 1: Write the failing test** + +Append to `.extras/test-logic.sh` before the result block: + +```bash +# --- cache ------------------------------------------------------------------ +PKG_CACHE=$(mktemp -d) +CACHE_ROOT="$PKG_CACHE/sha256-deadbeef" # simulate a resolved digest namespace +mkc() { mkdir -p "$CACHE_ROOT/$1/$2"; : > "$CACHE_ROOT/$1/$2/$3"; } + +mkc net libfoo "libfoo-1.1-x86_64-1_danix.txz" +[[ "$(cache_decision net libfoo 1.1)" == "cached" ]] && ok "cache hit on version match" || bad "cache_decision got [$(cache_decision net libfoo 1.1)]" +[[ "$(cache_decision net libfoo 1.2)" == "bump:1.1:1.2" ]] && ok "cache bump reported" || bad "cache bump got [$(cache_decision net libfoo 1.2)]" +[[ "$(cache_decision net libbar 1.0)" == "new" ]] && ok "cache new for absent" || bad "cache new got [$(cache_decision net libbar 1.0)]" + +hit="$(cache_path net libfoo 1.1)" +[[ "$hit" == "$CACHE_ROOT/net/libfoo/libfoo-1.1-x86_64-1_danix.txz" ]] && ok "cache_path returns hit" || bad "cache_path got [$hit]" +[[ -z "$(cache_path net libfoo 9.9)" ]] && ok "cache_path empty on miss" || bad "cache_path not empty on miss" + +srctmp=$(mktemp -d); : > "$srctmp/libfoo-1.2-x86_64-1_danix.txz" +cache_store net libfoo "$srctmp/libfoo-1.2-x86_64-1_danix.txz" +count=$(find "$CACHE_ROOT/net/libfoo" -name '*.t?z' | wc -l) +[[ "$count" -eq 1 ]] && ok "cache_store evicts to one file" || bad "cache_store left $count files" +[[ -e "$CACHE_ROOT/net/libfoo/libfoo-1.2-x86_64-1_danix.txz" ]] && ok "cache_store stored new file" || bad "cache_store did not store" +rm -rf "$srctmp" + +# disabled cache -> new +CACHE_ROOT_SAVE="$CACHE_ROOT"; USE_CACHE=0 +[[ "$(cache_decision net libfoo 1.2)" == "new" ]] && ok "--no-cache disables (new)" || bad "disabled cache got [$(cache_decision net libfoo 1.2)]" +USE_CACHE=1; CACHE_ROOT="$CACHE_ROOT_SAVE" +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `bash .extras/test-logic.sh` +Expected: FAIL, `cache_decision: command not found`. + +- [ ] **Step 3: Implement the cache (ported, keyed on CACHE_ROOT + USE_CACHE)** + +Add to `.extras/test-build` above `main()`: + +```bash +# ============================================================================= +# Dependency cache. Layout: $CACHE_ROOT/<cat>/<prog>/<prog>-<ver>-...txz where +# CACHE_ROOT = $PKG_CACHE/<image-digest> (set per run by resolve_cache_root). +# Key is prog+version. --no-cache (USE_CACHE=0) or empty PKG_CACHE disables. +# ============================================================================= +CACHE_ROOT="" # set by resolve_cache_root once the image digest is known + +# True when the cache is usable this run. +_cache_on() { [[ $USE_CACHE -eq 1 && -n "$PKG_CACHE" && -n "$CACHE_ROOT" ]]; } + +_cache_ver_of() { + local prog="$1" base="$2" + base="${base#"$prog"-}" + echo "${base%%-*}" +} + +# cache_decision <cat> <prog> <version> -> cached | bump:OLD:NEW | new +cache_decision() { + local cat="$1" prog="$2" version="$3" + _cache_on || { echo new; return; } + local dir="$CACHE_ROOT/$cat/$prog" + local f newest="" + for f in "$dir/$prog"-*.t?z; do + [[ -e "$f" ]] || continue + [[ -z "$newest" || "$f" -nt "$newest" ]] && newest="$f" + done + [[ -z "$newest" ]] && { echo new; return; } + local have; have="$(_cache_ver_of "$prog" "$(basename "$newest")")" + if [[ "$have" == "$version" ]]; then echo cached; else echo "bump:$have:$version"; fi +} + +cache_path() { + local cat="$1" prog="$2" version="$3" + _cache_on || return + local dir="$CACHE_ROOT/$cat/$prog" + local f newest="" + for f in "$dir/$prog"-*.t?z; do + [[ -e "$f" ]] || continue + [[ -z "$newest" || "$f" -nt "$newest" ]] && newest="$f" + done + [[ -z "$newest" ]] && return + [[ "$(_cache_ver_of "$prog" "$(basename "$newest")")" == "$version" ]] && echo "$newest" +} + +cache_store() { + local cat="$1" prog="$2" src="$3" + _cache_on || return + local dir="$CACHE_ROOT/$cat/$prog" + mkdir -p "$dir" + rm -f "$dir"/*.t?z + cp -a "$src" "$dir/" +} + +cache_label() { + local dir="$1" is_target="$2" + local cat prog ver dec + cat="$(category_of "$dir")"; prog="$(basename "$dir")"; ver="$(version_of "$dir")" + dec="$(cache_decision "$cat" "$prog" "$ver")" + local label + case "$dec" in + cached) label="cached ($ver)" ;; + bump:*) label="rebuild: ${dec#bump:}"; label="${label/:/ -> }" ;; + *) label="build (new)" ;; + esac + if [[ "$is_target" == "1" ]]; then + case "$dec" in + cached) label="build (cached $ver, rebuilt as target)" ;; + esac + echo "target, $label" + else + echo "$label" + fi +} + +# Compute CACHE_ROOT from the image's digest. Falls back to the tag if the +# digest cannot be read (still isolates per image reference). +resolve_cache_root() { + [[ -z "$PKG_CACHE" ]] && { CACHE_ROOT=""; return; } + local digest + digest="$(docker image inspect --format '{{index .Id}}' "$ACTIVE_IMAGE" 2>/dev/null)" + [[ -z "$digest" ]] && digest="tag-${ACTIVE_IMAGE//[^a-zA-Z0-9._-]/_}" + digest="${digest//[^a-zA-Z0-9._-]/_}" + CACHE_ROOT="$PKG_CACHE/$digest" + mkdir -p "$CACHE_ROOT" +} +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `bash .extras/test-logic.sh` +Expected: PASS (all cache checks green). + +- [ ] **Step 5: Commit** + +```bash +git add .extras/test-build .extras/test-logic.sh +SBOLINT=no git commit -m 'test-build: port dep cache, namespaced by image digest' +``` + +--- + +## Task 6: BLOCKED-BY-DEP propagation (ported) + +**Files:** +- Modify: `.extras/test-build` +- Test: `.extras/test-logic.sh` + +- [ ] **Step 1: Write the failing test** + +Append to `.extras/test-logic.sh` before the result block: + +```bash +# --- BLOCKED-BY-DEP (depends_on_failed) ------------------------------------- +dead=(b) +if depends_on_failed "$T/cat/g" dead; then ok "g blocked when b dead"; else bad "g should block on b"; fi +if depends_on_failed "$T/cat/a" dead; then ok "a blocked when b dead (direct)"; else bad "a should block on b"; fi + +dead=(c) +if depends_on_failed "$T/cat/a" dead; then bad "a wrongly blocked on c"; else ok "a not directly blocked by c"; fi +if depends_on_failed "$T/cat/b" dead; then ok "b blocked when c dead"; else bad "b should block on c"; fi + +dead=() +if depends_on_failed "$T/cat/a" dead; then bad "a blocked with empty dead"; else ok "no block when nothing dead"; fi + +dead=("%README%") +if depends_on_failed "$T/cat/a" dead; then bad "%README% treated as dep"; else ok "%README% not treated as dep"; fi +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `bash .extras/test-logic.sh` +Expected: FAIL, `depends_on_failed: command not found`. + +- [ ] **Step 3: Implement depends_on_failed (ported)** + +Add to `.extras/test-build` above `main()`: + +```bash +# Does SlackBuild dir $1 directly require any prog in the dead list (nameref $2)? +# Direct-requires check only; transitive blocking works because run_target +# iterates in topo order, propagating a failure one hop per package. +depends_on_failed() { + local dir="$1"; local -n failed="$2" + local info="$dir/$(basename "$dir").info" + local req tok f + req="$(read_requires "$info")" + for tok in $req; do + [[ "$tok" == "%README%" ]] && continue + for f in "${failed[@]:-}"; do + [[ "$tok" == "$f" ]] && return 0 + done + done + return 1 +} +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `bash .extras/test-logic.sh` +Expected: PASS. + +- [ ] **Step 5: Commit** + +```bash +git add .extras/test-build .extras/test-logic.sh +SBOLINT=no git commit -m 'test-build: port BLOCKED-BY-DEP propagation' +``` + +--- + +## Task 7: The container build step (build_one via docker) + +**Files:** +- Modify: `.extras/test-build` + +No self-check here (docker/build is out of the pure-logic reach, same boundary +as sbo-batch-test). Verified by a real run in Task 10. + +- [ ] **Step 1: Implement build_one + lint_pkg** + +Add to `.extras/test-build` above `main()`. + +`lint_pkg` is ported verbatim: + +```bash +# lint_pkg <txz> <logf> -> run sbopkglint on a built package. Host-side, target +# only, fail-soft (skip if absent, never change SUCCESS). +lint_pkg() { + local txz="$1" logf="$2" + if ! command -v sbopkglint >/dev/null 2>&1; then + echo " sbopkglint not installed on host, skipping lint" + return 0 + fi + echo " sbopkglint $(basename "$txz") ..." + echo "===== sbopkglint: $(basename "$txz") =====" >> "$logf" + local out rc + out="$(sbopkglint "$txz" 2>&1)"; rc=$? + printf '%s\n' "$out" >> "$logf" + if [[ $rc -eq 0 ]]; then + echo " lint: ${C_GRN}clean${C_RST}" + else + echo " lint: ${C_RED}findings${C_RST} (see $(basename "$logf")):" + printf '%s\n' "$out" | sed 's/^/ /' + fi +} +``` + +`build_one` runs the same download/md5/build/installpkg steps as sbo-batch-test, +but inside a container via `docker run` instead of `chroot`. The container gets: +the SlackBuild dir mounted read-only, a work dir for output, and (for deps) the +cached .txz mounted in. `sbopkglint` runs host-side on the copied-out package. + +```bash +# build_one <slackbuild-dir> <is_target 0|1> [container-name] +# Runs the build in a throwaway container. Sets ST_STATUS/ST_REASON/ST_TIME. +# Successful builds copy their package to a host workdir; deps are cached and +# the target is linted. Returns 0 on SUCCESS/CACHED, 1 otherwise. +build_one() { + local dir="$1" is_target="${2:-0}" + local prog cat key + prog="$(basename "$dir")"; cat="$(category_of "$dir")"; key="$cat/$prog" + local logf="$RUN_DIR/${cat}_${prog}.log" + local start; start=$(date +%s) + local version; version="$(version_of "$dir")" + + [[ "${HAS_README[$dir]:-}" == "1" ]] && ST_README["$key"]=1 + + # Dep with a version-matching cached package: installpkg it into the shared + # dep-package dir; no build. The target never takes this path. + if [[ "$is_target" != "1" ]]; then + local cached; cached="$(cache_path "$cat" "$prog" "$version")" + if [[ -n "$cached" ]]; then + cp -a "$cached" "$DEPS_DIR/" + { + echo "===== test-build: $prog (from cache) =====" + echo "cached package: $(basename "$cached")" + } >> "$logf" + ST_TIME["$key"]=$(( $(date +%s) - start )) + ST_STATUS["$key"]="CACHED" + return 0 + fi + fi + + # Build in a container. Mounts: + # $dir -> /sbo/pkg (ro, the SlackBuild) + # $DEPS_DIR -> /sbo/deps (rw, already-built dep .txz to installpkg first) + # $BUILD_OUT -> /sbo/out (rw, where the built package is copied out) + # The in-container script installs any deps present, then builds the target, + # writes a status token to /sbo/out/$prog.status, and copies the package out. + local statf="$BUILD_OUT/$prog.status" + rm -f "$statf" + + # fetch deps (removed from -current tree): let the container's sbopkg build + # them first. FETCH_DEPS is the set collected during resolution. + local fetch_list="" + local fp + for fp in "${!FETCH_DEPS[@]}"; do fetch_list+="$fp "; done + + docker run --rm \ + -v "$dir":/sbo/pkg:ro \ + -v "$DEPS_DIR":/sbo/deps \ + -v "$BUILD_OUT":/sbo/out \ + -e PROG="$prog" \ + -e FETCH_LIST="$fetch_list" \ + "$ACTIVE_IMAGE" /bin/bash -s >>"$logf" 2>&1 <<'CONTAINER_EOF' +set -uo pipefail +prog="$PROG" +statf="/sbo/out/$prog.status" + +# 0. install already-built dependency packages (order guaranteed by the host). +for d in /sbo/deps/*.t?z; do + [[ -e "$d" ]] || continue + installpkg --terse "$d" || { echo "INSTALL-FAILED (dep $d)"; echo INSTALL-FAILED > "$statf"; exit 1; } +done + +# 0b. fetch-from-SBo deps via sbopkg (removed from the -current tree). +for f in $FETCH_LIST; do + echo "sbopkg-building fetch dep: $f" + sbopkg -B -i "$f" || { echo "BUILD-FAILED (fetch dep $f)"; echo BUILD-FAILED > "$statf"; exit 1; } +done + +# copy the SlackBuild out of the read-only mount so it can write there. +cp -a /sbo/pkg /sbo/build +cd /sbo/build || { echo BUILD-FAILED > "$statf"; exit 1; } +. ./"$prog".info + +export OUTPUT=/sbo/out +mkdir -p "$OUTPUT" + +echo "===== test-build: $prog =====" +echo "PRGNAM=${PRGNAM:-$prog} VERSION=${VERSION:-?} BUILD=${BUILD:-?} TAG=${TAG:-?}" +echo "uname -m: $(uname -m) OUTPUT=$OUTPUT" +echo "REQUIRES=${REQUIRES:-}" +echo "=================================" + +if [ "$(uname -m)" = "x86_64" ] && [ -n "${DOWNLOAD_x86_64:-}" ] && [ "${DOWNLOAD_x86_64}" != "UNSUPPORTED" ] && [ "${DOWNLOAD_x86_64}" != "UNTESTED" ]; then + DL="$DOWNLOAD_x86_64"; MD="$MD5SUM_x86_64" +else + DL="$DOWNLOAD"; MD="$MD5SUM" +fi + +for u in $DL; do + wget -c --tries=3 "$u" || { echo DOWNLOAD-FAILED > "$statf"; exit 1; } +done + +set -- $MD +for u in $DL; do + f="$(basename "$u")" + want="$1"; shift + got="$(md5sum "$f" | cut -d' ' -f1)" + if [ "$got" != "$want" ]; then + echo "MD5 mismatch on $f: want $want got $got" + echo MD5-MISMATCH > "$statf"; exit 1 + fi +done + +chmod +x ./"$prog".SlackBuild +if ! ./"$prog".SlackBuild; then + echo BUILD-FAILED > "$statf"; exit 1 +fi + +pkg="$(ls -t "$OUTPUT"/"$prog"-*.t?z 2>/dev/null | head -n1)" +if [ -z "$pkg" ]; then + echo "No package produced in $OUTPUT" + echo BUILD-FAILED > "$statf"; exit 1 +fi +if ! installpkg --terse "$pkg"; then + echo INSTALL-FAILED > "$statf"; exit 1 +fi +echo "===== installed files: $(basename "$pkg") =====" +pkgname="$(basename "$pkg")"; pkgname="${pkgname%.t?z}" +cat "/var/log/packages/$pkgname" 2>/dev/null || echo "(package db entry not found)" +echo "=================================" +echo SUCCESS > "$statf" +CONTAINER_EOF + + local status="BUILD-FAILED" + [[ -f "$statf" ]] && status="$(cat "$statf")" + ST_TIME["$key"]=$(( $(date +%s) - start )) + ST_STATUS["$key"]="$status" + + if [[ "$status" == "SUCCESS" ]]; then + # locate the built package copied to the host workdir + local built newest="" + for built in "$BUILD_OUT/${prog}"-*.t?z; do + [[ -e "$built" ]] || continue + [[ -z "$newest" || "$built" -nt "$newest" ]] && newest="$built" + done + if [[ -n "$newest" ]]; then + if [[ "$is_target" != "1" ]]; then + cache_store "$cat" "$prog" "$newest" + # make the dep available to later builds in this run + cp -a "$newest" "$DEPS_DIR/" + else + lint_pkg "$newest" "$logf" + fi + fi + return 0 + fi + ST_REASON["$key"]="see $(basename "$logf")" + return 1 +} +``` + +- [ ] **Step 2: Sanity-check bash syntax** + +Run: `bash -n .extras/test-build` +Expected: no output (syntax OK). + +- [ ] **Step 3: Run the self-check still passes (no regression)** + +Run: `bash .extras/test-logic.sh` +Expected: PASS (build_one is not exercised, but sourcing must not break). + +- [ ] **Step 4: Commit** + +```bash +git add .extras/test-build +SBOLINT=no git commit -m 'test-build: container build step (build_one via docker)' +``` + +--- + +## Task 8: run_target orchestration + summary + +**Files:** +- Modify: `.extras/test-build` + +- [ ] **Step 1: Implement run_target + print_summary + confirm** + +Add to `.extras/test-build` above `main()`. `print_summary` is ported verbatim +(status set is the same). `run_target` replaces the overlay lifecycle with the +per-run docker workdirs and adds the printed-order + Y/n confirm. + +```bash +# confirm_order: print the resolved order (overrides marked) and ask to proceed. +# --yes skips the prompt but the order is still printed. --dry-run never reaches +# here. Returns 0 to proceed, 1 to abort. +confirm_order() { + local target_dir="$1" + echo " build order (${VERSION_ID}):" + local d + for d in "${RESOLVED_ORDER[@]}"; do + local it=0; [[ "$d" == "$target_dir" ]] && it=1 + local rdm=""; [[ "${HAS_README[$d]:-}" == 1 ]] && rdm=" [%README%]" + printf " %-30s %s%s\n" "$(pkg_key "$d")" "$(cache_label "$d" "$it")" "$rdm" + echo "$(pkg_key "$d")" >> "$RUN_DIR/build-order.txt" + done + # note fetch deps (built via sbopkg in-container, not in the order list) + local fp + for fp in "${!FETCH_DEPS[@]}"; do + printf " %-30s %s\n" "$fp" "fetch (sbopkg in container)" + done + [[ $ASSUME_YES -eq 1 ]] && return 0 + local reply + read -rp " Proceed? [Y/n] " reply + [[ -z "$reply" || "$reply" =~ ^[Yy]$ ]] +} + +# run_target <target-slackbuild-dir> +run_target() { + local target_dir="$1" + local tkey; tkey="$(pkg_key "$target_dir")" + + echo + echo "=== Target: $tkey (${VERSION_ID}) ===" + resolve_target "$target_dir" + apply_overrides_to_order + + # Hard resolution failures: report and stop, do not build. + if [[ ${#CYCLES[@]} -gt 0 || ${#UNMET[@]} -gt 0 ]]; then + local why="" + if [[ ${#UNMET[@]} -gt 0 ]]; then + local u + for u in "${!UNMET[@]}"; do why+="unmet:$u(${UNMET[$u]}) "; done + fi + [[ ${#CYCLES[@]} -gt 0 ]] && why+="${CYCLES[*]}" + ST_STATUS["$tkey"]="UNMET-DEP" + ST_REASON["$tkey"]="$why" + echo " resolution failed: $why" + echo " add an override rule ($TB_OVERRIDES) and rerun, or fix the tree." >&2 + return + fi + + if [[ $DRY_RUN -eq 1 ]]; then + echo " build order (dry-run):" + local d + for d in "${RESOLVED_ORDER[@]}"; do + local it=0; [[ "$d" == "$target_dir" ]] && it=1 + local rdm=""; [[ "${HAS_README[$d]:-}" == 1 ]] && rdm=" [%README%]" + printf " %-30s %s%s\n" "$(pkg_key "$d")" "$(cache_label "$d" "$it")" "$rdm" + echo "$(pkg_key "$d")" >> "$RUN_DIR/build-order.txt" + done + local fp + for fp in "${!FETCH_DEPS[@]}"; do + printf " %-30s %s\n" "$fp" "fetch (sbopkg in container)" + done + return + fi + + if ! confirm_order "$target_dir"; then + echo " aborted." + ST_STATUS["$tkey"]="ABORTED" + return + fi + + # Per-run docker workdirs (host side, discarded after the run). + DEPS_DIR="$RUN_DIR/deps"; BUILD_OUT="$RUN_DIR/out" + mkdir -p "$DEPS_DIR" "$BUILD_OUT" + + local d failed_progs=() + for d in "${RESOLVED_ORDER[@]}"; do + local key; key="$(pkg_key "$d")" + local prog; prog="$(basename "$d")" + + if depends_on_failed "$d" failed_progs; then + ST_STATUS["$key"]="BLOCKED-BY-DEP" + ST_REASON["$key"]="blocked by failed dep" + [[ "${HAS_README[$d]:-}" == "1" ]] && ST_README["$key"]=1 + echo " $key: BLOCKED-BY-DEP" + failed_progs+=("$prog") + continue + fi + + local it=0; [[ "$d" == "$target_dir" ]] && it=1 + echo " building $key ..." + if build_one "$d" "$it"; then + echo " $key: ${ST_STATUS[$key]} (${ST_TIME[$key]}s)" + else + echo " $key: ${ST_STATUS[$key]} (${ST_TIME[$key]}s)" + failed_progs+=("$prog") + fi + done +} + +# ============================================================================= +# SUMMARY (ported) +# ============================================================================= +print_summary() { + local total=$SECONDS + local succ=0 fail=0 blocked=0 cached=0 + local summary="$RUN_DIR/summary.log" + + { + echo "test-build run summary" + echo "target: $TARGET_ARG version: $VERSION_ID" + echo + } > "$summary" + + echo + echo "================ SUMMARY ================" + local key + for key in "${!ST_STATUS[@]}"; do + local st="${ST_STATUS[$key]}" rsn="${ST_REASON[$key]:-}" t="${ST_TIME[$key]:-0}" + local rd=""; [[ "${ST_README[$key]:-}" == "1" ]] && rd=" [%README%]" + local col="$C_YEL" + case "$st" in + SUCCESS) col="$C_GRN"; ((succ++)) ;; + CACHED) col="$C_GRN"; ((cached++)) ;; + BLOCKED-BY-DEP|UNMET-DEP|ABORTED) col="$C_YEL"; ((blocked++)) ;; + *) col="$C_RED"; ((fail++)) ;; + esac + printf "%s%-30s %-16s%s %s%s (%ss)\n" "$col" "$key" "$st" "$C_RST" "$rsn" "$rd" "$t" + printf "%-30s %-16s %s%s (%ss)\n" "$key" "$st" "$rsn" "$rd" "$t" >> "$summary" + done + echo "----------------------------------------" + printf "%s%d succeeded%s, %s%d failed%s, %s%d blocked%s, %s%d cached%s, total %ss\n" \ + "$C_GRN" "$succ" "$C_RST" "$C_RED" "$fail" "$C_RST" "$C_YEL" "$blocked" "$C_RST" \ + "$C_GRN" "$cached" "$C_RST" "$total" + echo "logs: $RUN_DIR" + if [[ $fail -eq 0 && $blocked -eq 0 ]]; then + echo "${C_GRN}All green.${C_RST} Safe to build the SBo submission tarball on the host." + fi + { + echo + echo "$succ succeeded, $fail failed, $blocked blocked, $cached cached, total ${total}s" + echo "logs: $RUN_DIR" + } >> "$summary" +} +``` + +Add the two workdir globals near the other globals (top of the flags block): + +```bash +DEPS_DIR="" # per-run host dir of built dep .txz, mounted into the container +BUILD_OUT="" # per-run host dir where built packages are copied out +``` + +- [ ] **Step 2: Sanity-check syntax** + +Run: `bash -n .extras/test-build` +Expected: no output. + +- [ ] **Step 3: Self-check no regression** + +Run: `bash .extras/test-logic.sh` +Expected: PASS. + +- [ ] **Step 4: Commit** + +```bash +git add .extras/test-build +SBOLINT=no git commit -m 'test-build: run_target orchestration + summary + confirm' +``` + +--- + +## Task 9: Wire main(), image presence check, target lookup + +**Files:** +- Modify: `.extras/test-build` + +- [ ] **Step 1: Implement the full main()** + +Replace the current `main()` in `.extras/test-build` with: + +```bash +# Verify the selected image exists locally. It is built by a separate job; this +# script only consumes it. (Later: a local-registry docker pull slots in here.) +require_image() { + if ! docker image inspect "$ACTIVE_IMAGE" >/dev/null 2>&1; then + cat >&2 <<EOF +Image not found locally: $ACTIVE_IMAGE +It is produced by the separate image-builder job (full Slackware $VERSION_ID + +sbo-maintainer-tools + sbopkg), stored on the NAS / local registry. Load or +pull it, then rerun. This script does not build images. +EOF + exit 1 + fi +} + +main() { + parse_args "$@" + init_color + require_config + SBO_TREE_ROOTS=("$ACTIVE_TREE") + load_overrides + + # image + cache namespace (skip the image check on a pure dry-run so the order + # can be inspected without the image present). + if [[ $DRY_RUN -eq 0 ]]; then + command -v docker >/dev/null 2>&1 || { echo "docker not found in PATH." >&2; exit 1; } + require_image + fi + resolve_cache_root + + RUN_DIR="$LOG_ROOT/$(date +%Y-%m-%d_%H-%M-%S)" + mkdir -p "$RUN_DIR" + : > "$RUN_DIR/build-order.txt" + + # Single-package mode: resolve the name in the active tree. + local tdir + if ! tdir="$(find_slackbuild_dir "$TARGET_ARG")"; then + echo "Program not found in the SBo tree ($ACTIVE_TREE): $TARGET_ARG" >&2 + exit 1 + fi + + run_target "$tdir" + print_summary +} +``` + +- [ ] **Step 2: Sanity-check syntax** + +Run: `bash -n .extras/test-build` +Expected: no output. + +- [ ] **Step 3: Dry-run smoke test against the real tree (no docker needed)** + +This needs a real config. If `~/.config/sbo-testbuild/config` is not set up, +create a throwaway one pointing at an existing local SBo tree, then: + +Run: `.extras/test-build --dry-run <some-pkg-in-that-tree>` +Expected: prints `=== Target: ... ===`, a build order, exits 0, no docker call. + +- [ ] **Step 4: Self-check no regression** + +Run: `bash .extras/test-logic.sh` +Expected: PASS. + +- [ ] **Step 5: Commit** + +```bash +git add .extras/test-build +SBOLINT=no git commit -m 'test-build: wire main, image-presence check, target lookup' +``` + +--- + +## Task 10: Real end-to-end build (user-run) + README + +**Files:** +- Modify: `.extras/test-build` (only if the real run surfaces a bug) +- Create: `.extras/README.test-build` (short usage note) + +This task needs a real image and the buildsystem. Per repo rules the throwaway +docker build is Claude-OK, but the IMAGE must exist first (separate job, not yet +built). So this task is: document usage, and record the end-to-end run as a +manual verification step the user performs once an image is available. + +- [ ] **Step 1: Write the usage README** + +Create `.extras/README.test-build`: + +```markdown +# test-build + +Verify an already-published SBo package still builds on a target Slackware +version inside a throwaway docker container. + +## Setup + + mkdir -p ~/.config/sbo-testbuild + cp .extras/test-build-config.example ~/.config/sbo-testbuild/config + cp .extras/overrides.example ~/.config/sbo-testbuild/overrides + $EDITOR ~/.config/sbo-testbuild/config + +Set the two SBo tree paths, the two image tags, LOG_ROOT, and PKG_CACHE. + +The images (`sbo-testbuild:current` / `:15.0`) are FULL Slackware installs plus +`sbo-maintainer-tools` and `sbopkg`, built by a separate job (not this script). +The script errors if the tagged image is not present locally. + +## Usage + + .extras/test-build <pkg> # build on -current (default) + .extras/test-build --stable <pkg> # build on 15.0 + .extras/test-build --dry-run <pkg> # show the build order, no build + .extras/test-build --yes <pkg> # skip the confirm (order still shown) + .extras/test-build --no-cache <pkg> # rebuild all deps this run + +A green run means it is safe to build the SBo submission tarball on the host. + +## current-vs-stable overrides + +`~/.config/sbo-testbuild/overrides` (see `overrides.example`) encodes deltas +that only apply when building on -current: + + drop: <prog> already in the -current base + rename: <old> -> <new> renamed on -current + fetch: <prog> removed from the -current tree; built via sbopkg + +Start light; add rules only when a real package needs them. + +## Self-check + + bash .extras/test-logic.sh +``` + +- [ ] **Step 2: Commit the docs** + +```bash +git add .extras/README.test-build +SBOLINT=no git commit -m 'test-build: usage README' +``` + +- [ ] **Step 3: Manual end-to-end verification (user, once an image exists)** + +Documented for the user to run when a `sbo-testbuild:*` image is available: + +```bash +# pick a small already-published package with a dep, e.g. one already in the repo +.extras/test-build --yes <pkg> +``` + +Expected: build order printed, deps built (or CACHED on a second run), target +built, `sbopkglint` result shown, summary green, `All green.` line printed. +A second run of the same package should show its deps as `CACHED`. + +Record the outcome. If a real bug surfaces (mount path, sbopkg invocation, +package glob), fix it in `.extras/test-build` and re-run; add a self-check case +if the bug was in pure logic. + +--- + +## Self-Review + +Run this checklist against the spec after the plan is written: + +**1. Spec coverage:** +- purpose / one-target-per-run: Task 2 (`parse_args`), Task 9 (`main`) - covered +- two versions, current default: Task 2 (`--stable`, `select_version_paths`) - covered +- resolve local tree + topo: Task 3 - covered +- overrides drop/rename/fetch + UNMET stop: Task 4, stop in Task 8 `run_target` - covered +- external config + overrides file: Task 2, Task 4 - covered +- external image, presence check, no bake: Task 9 `require_image` - covered +- container build (download/md5/build/installpkg): Task 7 - covered +- fetch via sbopkg: Task 7 (`FETCH_LIST` loop) - covered +- dep cache, digest-namespaced, --no-cache, target always fresh: Task 5, wired Task 7/8 - covered +- target lint: Task 7 `lint_pkg`, called in Task 7 build_one - covered +- confirm order + --yes still prints: Task 8 `confirm_order` - covered +- --dry-run: Task 8 `run_target`, Task 9 skips image check - covered +- report + logs (per-pkg, summary, build-order): Task 8 `print_summary`, Task 7 logs - covered +- status values incl CACHED: Task 8 `print_summary` - covered +- self-check parity: Tasks 1-6 - covered + +**2. Placeholder scan:** no TBD/TODO in code steps; every code step shows full +code. The one deferred item (real end-to-end run) is explicit and gated on an +external image, not a placeholder. + +**3. Type consistency:** function + global names match across tasks: +`RESOLVED_ORDER`, `FETCH_DEPS`, `OV_DROP/OV_RENAME/OV_FETCH`, `CACHE_ROOT`, +`ACTIVE_TREE/ACTIVE_IMAGE`, `DEPS_DIR/BUILD_OUT`, `cache_decision/cache_path/ +cache_store/cache_label`, `select_version_paths`, `apply_overrides_to_order`, +`apply_rename`, `load_overrides`, `resolve_cache_root`, `require_image`, +`build_one(dir,is_target)`, `run_target`, `confirm_order`, `print_summary`. +Consistent. + +## Notes on deliberate simplifications + +- Single-package mode only (no category-folder / all / queue modes). This repo + bumps one package at a time. Extension point is `main`'s target lookup. +- `-j` parallelism dropped entirely (was a no-op stub upstream). Builds serial. +- fetch deps are not topo-ordered among themselves; sbopkg resolves their own + deps. Start light per the spec; revisit if a fetch dep needs another fetch dep. +``` + |