156 real-world compose files on Apple container: A/B measurement ledger (no-fix vs auto-fix)

ABOUT.md

156 real-world compose files on Apple container — A/B measurement ledger

Raw per-project results behind the article "実運用のdocker compose 156本をApple containerで一斉起動してみた".

• Corpus: Haxxnet/Compose-Examples @ 99b28cb, the 156 examples/*/docker-compose.yml entries without a build: section.
• Environment: macOS 26 / Apple silicon, Apple container 1.1.0, opossum v0.15.0 as the orchestration layer.
• Both arms run back-to-back per project on the same binary: A = opossum up (no auto-fix), B = opossum up --from-docker-compose (auto-fix). Secrets/passwords are left as placeholders. 120s hard timeout per up.

results-156-ab.csv columns

column	meaning
project	directory name in the corpus
without_autofix	arm A class (FULL-UP / PARTIAL / CRASH / STARTED-NONERUN / PREFLIGHT / TIMEOUT, with the diagnostic code where one fired)
with_autofix	arm B class, same scale
autofix_applied	which fixes arm B wrote (OPSM-101 = PGDATA subdirectory, OPSM-105 = bind-mounted DB datadir → named volume, none)
services_running_without / _with	running/total services at classification time
note	first notable diagnostic line from arm B output

harness.sh

The exact sweep script (classification rules included). Comments referencing internal ticket numbers were neutralized; logic is unchanged from the run.

harness.sh

#!/bin/bash
# Does auto-fix actually raise the success rate on real compose projects?
#
# Design. The earlier baseline sweep is 19 opossum commits and several days of host drift
# old, so a straight comparison against it would measure "auto-fix + everything
# else that changed", not auto-fix. Instead this is an A/B on ONE binary:
#   A: `opossum up`                        (auto-fix off)
#   B: `opossum up --from-docker-compose`  (auto-fix on)
# B−A is the auto-fix effect, isolated. The two arms are INTERLEAVED per item —
# A then B on the same project, back to back — so host state (free ports, image
# cache, runtime health) can't drift between the arms and masquerade as an effect.
# A is also reported against that baseline, as context for how much the rest
# of the work moved things.
#
# Corpus/parity: same 156 image-only items, same commit (99b28cb), same order,
# same volume storage, same `down -v` + wipe between runs, same classification.
# No `-f` (it disables overlay auto-merge; verified discovery picks the identical
# file for all 156). Timeout is a real fork/kill one at 120s — the baseline's
# `alarm N; exec` never fired, so it was unbounded; 120s is a hang guard that
# should not bind. TIMEOUTs are counted so that assumption is auditable.
EX=~/opossum-dogfood/Compose-Examples/examples
OP=/tmp/opossum-306
OUT=/tmp/df306-ab.tsv
LIST=${1:-/tmp/df296-imageonly.txt}
export DOCKER_VOLUME_STORAGE=~/opossum-dogfood/vols
export OPOSSUM_NO_AUTO_START=1
mkdir -p ~/opossum-dogfood/vols
TMO=120

run_timeout() { # exit 124 on timeout (fork/kill; `alarm; exec` does NOT work)
  perl -e '
    my $secs = shift;
    my $pid = fork();
    if ($pid == 0) { exec @ARGV or exit 127; }
    $SIG{ALRM} = sub { kill("KILL", $pid); };
    alarm $secs;
    waitpid($pid, 0);
    my $rc = $?;
    exit(($rc & 127) ? 124 : ($rc >> 8));
  ' "$@"
}

# classify OUT_TEXT RC -> class string (identical rules to the baseline sweep)
classify() {
  local out="$1" rc="$2" svc="$3" run="$4" code
  code=$(echo "$out" | grep -oE '\[OPSM-[0-9]+\]' | head -1)
  if [ "$rc" -eq 124 ]; then echo "TIMEOUT"
  elif echo "$out" | grep -qE 'OPSM-205|host port already|OPSM-20[0-9]'; then echo "PREFLIGHT${code}"
  elif [ "${svc:-0}" -gt 0 ] && [ "${run:-0}" = "$svc" ]; then echo "FULL-UP"
  elif [ "${run:-0}" -gt 0 ]; then echo "PARTIAL"
  elif echo "$out" | grep -qiE 'Operation not permitted|OPSM-401|OPSM-407|did not complete'; then echo "CRASH${code}"
  elif echo "$out" | grep -q 'Starting'; then echo "STARTED-NONERUN"
  else echo "OTHER"; fi
}

reset_item() { # wipe every trace so the next arm starts clean
  "$OP" down -v >/dev/null 2>&1
  rm -f compose.opossum.yaml compose.opossum.yml
  rm -rf ~/opossum-dogfood/vols/"$1" 2>/dev/null
}

n=0
while read -r d; do
  [ -z "$d" ] && continue
  n=$((n+1))
  cd "$EX/$d" 2>/dev/null || { printf '%s\tNODIR\tNODIR\t-\t-\n' "$d" >>"$OUT"; continue; }
  cf=""; for f in compose.yaml compose.yml docker-compose.yaml docker-compose.yml; do [ -f "$f" ] && cf="$f" && break; done
  [ -z "$cf" ] && { printf '%s\tNOCF\tNOCF\t-\t-\n' "$d" >>"$OUT"; continue; }

  # ---- Arm A: auto-fix OFF ----
  reset_item "$d"
  outA=$(run_timeout "$TMO" "$OP" up 2>&1); rcA=$?
  svcA=$("$OP" ps 2>/dev/null | tail -n +2 | grep -c .)
  runA=$("$OP" ps 2>/dev/null | grep -c 'running')
  clsA=$(classify "$outA" "$rcA" "$svcA" "$runA")

  # ---- Arm B: auto-fix ON ----
  reset_item "$d"
  outB=$(run_timeout "$TMO" "$OP" up --from-docker-compose 2>&1); rcB=$?
  svcB=$("$OP" ps 2>/dev/null | tail -n +2 | grep -c .)
  runB=$("$OP" ps 2>/dev/null | grep -c 'running')
  clsB=$(classify "$outB" "$rcB" "$svcB" "$runB")

  # Which fixes did B actually write?
  fixes="none"
  if [ -f compose.opossum.yaml ]; then
    fixes=$(echo "$outB" | grep -oE 'OPSM-10[15]' | sort -u | paste -sd, -)
    [ -z "$fixes" ] && fixes="written"
  fi
  note=$(echo "$outB" | grep -iE 'OPSM-|host port|not found|Operation not permitted|no space' | head -1 | cut -c1-80)

  printf '%s\t%s\t%s\t%s\trunA=%s/%s runB=%s/%s\t%s\n' \
    "$d" "$clsA" "$clsB" "$fixes" "${runA:-0}" "${svcA:-0}" "${runB:-0}" "${svcB:-0}" "$note" >>"$OUT"

  reset_item "$d"
  if [ $((n % 12)) -eq 0 ]; then
    container system status 2>/dev/null | grep -qi 'status.*running' || { container system stop >/dev/null 2>&1; container system start >/dev/null 2>&1; }
  fi
done < "$LIST"
echo "SWEEP DONE: $n items" >> "$OUT"

results-156-ab.csv