harness v0.9: java report collection (surefire/gradle XML + gradle HTML), du-based container disk guard, rust du watchdog

scripts/verify.py

@@ -1,4 +1,4 @@
-"""PatchBench row verification + context expansion harness (v0.8).
+"""PatchBench row verification + context expansion harness (v0.9).
 
 For each candidate row:
   1. clone the repo at base_commit
@@ -18,8 +18,9 @@ they are not evaluable natively, not regressions.
 Native (non-Docker) reproduction of the upstream env:
   - toolchain dirs are prepended to PATH per language
   - the upstream /testbed convention is rewritten to the local checkout path
-  - after test_cmds, the harness cats reports/* (rows redirect `go test -json >
-    reports/<lang>-test-results.json`; the row's print_cmds list is often empty)
+  - after test_cmds, the harness collects the report files the frameworks wrote
+    (surefire/gradle XML, gradle HTML, reports/* go-json dumps) and feeds them to
+    the parser alongside console output; the row's print_cmds list is often empty
   - JS/TS: if package.json exists without node_modules, deps are installed with the
     repo's own package manager (detected from lockfile)
   - rust: cargo target dirs are wiped between rows AND all builds go to one shared
@@ -28,23 +29,24 @@ Native (non-Docker) reproduction of the upstream env:
 v0.7: TimeoutExpired.stdout/stderr can be bytes (python quirk under capture_output) --
 decode before concatenating. This crashed slow maven builds at the 2100s timeout.
 v0.8: disk guard. Three rust jobs died on the 50G ephemeral-storage quota mid-row.
-Now: shared CARGO_TARGET_DIR, a check before every test phase that wipes build
-caches when free space < 6G (raising "disk_pressure" instead of getting the pod
-evicted, which loses every remaining row), and df/du logging after each phase so
-the next quota failure is diagnosable from the log.
+v0.9: java report files (surefire/gradle XML + gradle HTML) are collected and fed
+to the parser; disk guard is du-based (container quota) and rust builds run under
+a du watchdog so a runaway build kills the row, not the pod.
 
 Usage (inside a job with the right language toolchain image):
   python verify.py --lang go --file pilot/candidates/go.jsonl --limit 6
 """
-import argparse, json, os, subprocess, sys, time, traceback
+import argparse, json, os, shlex, subprocess, sys, time, traceback
 
 REPO_ID = "rootxhacker/patchbench"
 CACHE = "/tmp/cache/repos"
 CMD_TIMEOUT_S = 2100
 GIT_TIMEOUT_S = 900
 MAX_CONTEXT_LINES = 1500
-DISK_FREE_MIN_BYTES = 6 * 1024**3   # reclaim below this
-DISK_ABORT_BYTES = 2 * 1024**3      # abort row below this after reclaim
+# The 50G limit is a per-container ephemeral-storage quota. df/statvfs report the
+# host filesystem and never see it, so disk accounting must be du-based.
+CONTAINER_QUOTA_BYTES = 50 * 1024**3
+DU_LIMIT_BYTES = 42 * 1024**3
 RUST_SHARED_TARGET = "/tmp/pb-cargo-target"
 
 LANG_PATH_PREPEND = {
@@ -84,19 +86,22 @@ def sh(cmds, cwd, timeout=CMD_TIMEOUT_S):
     return True, ""
 
 
-def free_bytes(path="/tmp"):
+def used_bytes():
+    """Bytes used in the du-monitored dirs. df/statvfs see the host fs, not the
+    per-container ephemeral-storage quota, so du is the only honest measure."""
+    _, out, _ = run("du -sb /tmp /usr/local/cargo /root/.cache /var/tmp 2>/dev/null "
+                    "| awk '{s+=$1} END {print s+0}'", "/tmp", 300)
     try:
-        st = os.statvfs(path)
-        return st.f_bavail * st.f_frsize
-    except OSError:
-        return 1 << 62
+        return int(out.strip().splitlines()[-1])
+    except (ValueError, IndexError):
+        return 0
 
 
 def log_disk(tag):
-    _, out, _ = run("df -h /tmp 2>/dev/null | tail -n +2; "
-                    "du -sh /tmp/pb-cargo-target /tmp/cache /usr/local/cargo/registry 2>/dev/null",
-                    "/tmp", 120)
-    print(f"[disk:{tag}] free={free_bytes() >> 30}G | {out.strip()[:400]}", flush=True)
+    _, out, _ = run("du -sb /tmp/pb-cargo-target /tmp/cache /usr/local/cargo/registry "
+                    "2>/dev/null", "/tmp", 120)
+    print(f"[disk:{tag}] container_used={used_bytes() >> 30}G | {out.strip()[:400]}",
+          flush=True)
 
 
 def reclaim_disk():
@@ -105,12 +110,16 @@ def reclaim_disk():
 
 
 def disk_guard(tag):
-    """Raise instead of letting the pod get evicted -- an eviction loses all rows."""
-    if free_bytes() < DISK_FREE_MIN_BYTES:
-        print(f"[disk:{tag}] low, reclaiming shared target dir", flush=True)
+    """Raise instead of blowing the container's ephemeral-storage quota -- an
+    eviction loses all remaining rows."""
+    u = used_bytes()
+    if u > DU_LIMIT_BYTES:
+        print(f"[disk:{tag}] used={u >> 30}G > limit={DU_LIMIT_BYTES >> 30}G, "
+              "reclaiming shared target dir", flush=True)
         reclaim_disk()
-    if free_bytes() < DISK_ABORT_BYTES:
-        raise RuntimeError(f"disk_pressure: only {free_bytes() >> 30}G free after reclaim "
+        u = used_bytes()
+    if u > CONTAINER_QUOTA_BYTES - 2 * 1024**3:
+        raise RuntimeError(f"disk_pressure: used={u >> 30}G after reclaim "
                            f"(tag={tag}); aborting row to save the remaining rows")
 
 
@@ -162,25 +171,80 @@ def ensure_js_deps(repo_dir):
     return None if ok else f"js deps install failed: {err}"
 
 
+DEFAULT_REPORT_FINDS = [r'for f in reports/*; do [ -f "$f" ] && cat "$f"; done']
+REPORT_FINDS = {
+    "java": DEFAULT_REPORT_FINDS + [
+        r'find . \( -path "*surefire-reports*" -o -path "*failsafe-reports*" '
+        r'-o -path "*build/test-results*" \) -name "*.xml" -type f '
+        r'| sort | head -400 | while read -r f; do cat "$f"; done',
+        r'find . -path "*reports/tests*" -name "*.html" -type f '
+        r'| sort | head -200 | while read -r f; do cat "$f"; done',
+    ],
+}
+
+
+def collect_reports(repo_dir, lang):
+    """Cat the report files the test frameworks wrote (per-language find commands)
+    into the output stream the log parser sees. Each output capped at 8M chars."""
+    outs = []
+    for cmd in REPORT_FINDS.get(lang, DEFAULT_REPORT_FINDS):
+        _, o, _ = run(cmd, repo_dir, 300)
+        if o.strip():
+            outs.append(o[:8_000_000])
+    return "\n".join(outs)
+
+
+WATCHDOG_LANGS = {"rust"}
+
+
+def watchdog_wrap(cmd):
+    """Run cmd in its own process group under a du watchdog. setsid is critical:
+    without it cargo survives `kill -9 -- -$pid` and keeps writing to the quota.
+    Build runs in FOREGROUND; the du monitor polls in BACKGROUND; `wait $pid`
+    decides the exit code (avoids the kill -0 zombie-hang on fast commands)."""
+    limit = DU_LIMIT_BYTES
+    q = shlex.quote(cmd)
+    return (
+        f"printf %s {q} > /tmp/pb_cmd.sh\n"
+        "setsid bash /tmp/pb_cmd.sh & pid=$!\n"
+        "( while kill -0 $pid 2>/dev/null; do\n"
+        "    used=$(du -sb /tmp /usr/local/cargo 2>/dev/null "
+        "| awk '{s+=$1} END {print s+0}')\n"
+        f"    if [ \"$used\" -gt {limit} ]; then\n"
+        "      kill -9 -- -$pid 2>/dev/null\n"
+        "      echo \"[DISK_WATCHDOG] killed build: container=${used}B\"\n"
+        "      exit 0\n"
+        "    fi\n"
+        "    sleep 60 >/dev/null 2>&1\n"
+        "  done ) & mon=$!\n"
+        "wait $pid; rc=$?\n"
+        "kill $mon 2>/dev/null\n"
+        "exit $rc\n"
+    )
+
+
 def run_tests(row, repo_dir, lang, phase_tag=""):
-    """Run rebuild_cmds, test_cmds, print_cmds, then surface any reports/* the test
-    commands wrote. Returns (tests_dict, combined_output_tail)."""
+    """Run rebuild_cmds, test_cmds, print_cmds, then collect the report files the
+    test frameworks wrote (surefire/gradle XML, gradle HTML, reports/*) and feed
+    them to the log parser. Returns (tests_dict, combined_output_tail)."""
     disk_guard(f"{phase_tag}-pre")
     parser = get_parser(row)
     dep_err = ensure_js_deps(repo_dir)
-    sh(row.get("rebuild_cmds"), repo_dir)
+    wrap = watchdog_wrap if lang in WATCHDOG_LANGS else (lambda c: c)
+    for c in (row.get("rebuild_cmds") or []):
+        run(wrap(c), repo_dir, CMD_TIMEOUT_S)
     run("mkdir -p reports", repo_dir, 30)
     out = ""
     if dep_err:
         out += dep_err + "\n"
     for c in (row.get("test_cmds") or []):
-        _, o, _ = run(c, repo_dir, CMD_TIMEOUT_S)
+        _, o, _ = run(wrap(c), repo_dir, CMD_TIMEOUT_S)
         out += o + "\n"
     for c in (row.get("print_cmds") or []):
         _, o, _ = run(c, repo_dir, 120)
         out += o + "\n"
-    _, o, _ = run("for f in reports/*; do [ -f \"$f\" ] && cat \"$f\"; done", repo_dir, 120)
-    out += o + "\n"
+    out += collect_reports(repo_dir, lang) + "\n"
+    disk_guard(f"{phase_tag}-post")
     log_disk(f"{phase_tag}-post")
     return parser(out), out[-3000:]
 
@@ -383,6 +447,8 @@ def main():
                   f"pre_ok={rec.get('f2p_pre_ok')} post_ok={rec.get('f2p_post_ok')} "
                   f"p2p_ok={rec.get('p2p_post_ok')} parsed={rec.get('pre_detail', {}).get('parsed_count', '?')} "
                   f"err={(rec.get('error') or '')[:200]}", flush=True)
+            if row["language"] == "rust":
+                run(f"rm -rf {RUST_SHARED_TARGET}", "/tmp", 600)
             done += 1
 
     for path, dest in [(out_path, f"pilot/results/{args.lang}.jsonl"),