refactor(issue-17): item 4 - the delegate-job wrapper's decisions move to Python
The wrapper keeps spawn / wait / kill, key injection and the herdr
diagnostic probe; what it decided in bash is now lib_py/delegation/wrapper.py,
reached through one `_decide` helper:
- finalize_unfinished: the clock choice, the disk grace and broker
re-observation, the close request / label, the close and the event
(finalize-begin / finalize-end; bash runs only the busy probe between them)
- start_stall_watch: whether to watch (MAM_STALL_WATCH, remote, human)
- _map_sub_rc, _rc_for (+ MAM_DELEGATE_FAIL_CLOSED), the subscriber
early-exit check and cmd_wait's rc normalisation
- mam_int / mam_int_knob run lib_py/ints.py, which is also the runner's
_positive_int: one implementation of the Issue #26 rule
No behaviour change: tests/test_issue17_item4_decisions.py runs the old
bash functions (copied verbatim from 7209750) and the new wrapper on the
same inputs and compares output, FINAL_JOB_STATUS and the registry /
publish calls. Three static tests that pinned the old bash literals now
pin the Python entry points instead.
Refs #17
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
GodopuandClaude Opus 5.5 committed
1 parent
7209750ac7
commit
63d9c205ff
13 files changed
+1131
-289
No files matched your search
@@ -0,0 +1,264 @@
|
||||
# Issue #17 item 4: the decision functions as they were in bash at base 7209750
|
||||
# (v4.8.5), copied verbatim, for tests/test_issue17_item4_decisions.py to run
|
||||
# side by side with the new wrapper. Never sourced by the skills.
|
||||
|
||||
mam_int() {
|
||||
# Spelled-out ASCII sets, not [[:space:]]/[0-9]: those follow the locale, and
|
||||
# the runner's _positive_int takes ASCII only (review R2: U+2003 30 U+2003
|
||||
# was 30 here under en_US.UTF-8 and invalid there).
|
||||
local _ws=$' \t\n\r\v\f' _re
|
||||
_re="^[${_ws}]*([0123456789]+)[${_ws}]*\$"
|
||||
[[ "${1-}" =~ $_re ]] || return 1
|
||||
local d="${BASH_REMATCH[1]}"
|
||||
d="${d#"${d%%[!0]*}"}"
|
||||
[ ${#d} -le 9 ] || return 1
|
||||
local n=$(( 10#${d:-0} ))
|
||||
[ "$n" -ge "$2" ] || return 1
|
||||
printf '%s\n' "$n"
|
||||
}
|
||||
mam_int_knob() {
|
||||
local raw="${!1-}"
|
||||
[ -n "$raw" ] || { printf '%s\n' "$2"; return 0; }
|
||||
mam_int "$raw" "$3" && return 0
|
||||
echo "WARNING: $1=$raw ignored (not a decimal integer >= $3); using $2" >&2
|
||||
printf '%s\n' "$2"
|
||||
}
|
||||
|
||||
start_stall_watch() {
|
||||
local session="$1" agent="$2" tok="${3:-}" att="${4:-}"
|
||||
STALL_PID=""
|
||||
[ "${MAM_STALL_WATCH:-1}" = "0" ] && return 0
|
||||
if _is_remote "$session"; then
|
||||
echo "stall watch: remote job, no local pane - stall detection off" >&2; return 0
|
||||
fi
|
||||
if [ "$agent" = "human" ] || [ "${session#herdr:}" = "human" ]; then
|
||||
echo "stall watch: human job, no local pane - stall detection off" >&2; return 0
|
||||
fi
|
||||
local args=(--job "$JOB_ID" --registry-dir "$REGISTRY_DIR" --target "${session#herdr:}"
|
||||
--agent "$agent" --herdr-session "${HERDR_SESSION_NAME:-}" --watch-pid "$$")
|
||||
[ -n "$tok" ] && args+=(--expect-dispatch-token "$tok")
|
||||
[ -n "$att" ] && args+=(--attempt-id "$att")
|
||||
PYTHONPATH="$SCRIPT_DIR/..${PYTHONPATH:+:$PYTHONPATH}" "$PY" -m lib_py.stall_watch "${args[@]}" \
|
||||
>"$REGISTRY_DIR/$JOB_ID.stall.out" 2>&1 &
|
||||
STALL_PID=$!
|
||||
echo "stall watch pid: $STALL_PID (log: $REGISTRY_DIR/$JOB_ID.stall.out)"
|
||||
}
|
||||
|
||||
_disk_status() {
|
||||
local jid="$1"
|
||||
"$PY" -c "import json, os; p=os.path.join('$REGISTRY_DIR', '$jid.json'); print(json.load(open(p)).get('status','')) if os.path.exists(p) else print('')" 2>/dev/null || true
|
||||
}
|
||||
|
||||
_recent_disk_heartbeat() {
|
||||
local job_id="$1" window="$2" f="$REGISTRY_DIR/$job_id.events.log"
|
||||
[ -f "$f" ] || return 1
|
||||
"$PY" - "$f" "$window" <<'PYEOF'
|
||||
import calendar, json, sys, time
|
||||
path, window = sys.argv[1], float(sys.argv[2])
|
||||
last = ""
|
||||
with open(path) as fh:
|
||||
for line in fh:
|
||||
if line.strip():
|
||||
last = line
|
||||
try:
|
||||
stamp = json.loads(last)["timestamp"]
|
||||
seen = calendar.timegm(time.strptime(stamp, "%Y-%m-%dT%H:%M:%SZ"))
|
||||
except Exception:
|
||||
sys.exit(1)
|
||||
sys.exit(0 if time.time() - seen <= window else 1)
|
||||
PYEOF
|
||||
}
|
||||
|
||||
_map_sub_rc() {
|
||||
local sub_rc="$1" job_id="$2"
|
||||
local job_status="running"
|
||||
if [[ $sub_rc -eq $SUB_RC_COMPLETED ]]; then
|
||||
job_status="completed"
|
||||
elif [[ $sub_rc -eq $SUB_RC_ERROR ]]; then
|
||||
job_status="error"
|
||||
elif [[ $sub_rc -eq $SUB_RC_BROKER_UNAVAILABLE ]]; then
|
||||
job_status="broker_unavailable"
|
||||
local disk_st
|
||||
disk_st="$(_disk_status "$job_id")"
|
||||
if [[ "$disk_st" == "completed" || "$disk_st" == "error" || "$disk_st" == "cancelled" ]]; then
|
||||
job_status="$disk_st"
|
||||
fi
|
||||
else
|
||||
job_status="timeout" # SUB_RC_NO_EVENT, SUB_RC_WALL_CLOCK (and any other code)
|
||||
fi
|
||||
echo "$job_status"
|
||||
}
|
||||
|
||||
_rc_for() {
|
||||
case "$1" in
|
||||
completed) echo 0 ;;
|
||||
error) echo 1 ;;
|
||||
timeout) echo 2 ;;
|
||||
broker_unavailable) echo 3 ;;
|
||||
cancelled) echo 5 ;;
|
||||
*) echo 1 ;;
|
||||
esac
|
||||
}
|
||||
|
||||
finalize_unfinished() {
|
||||
local job_id="$1" job_status="$2" sub_rc="$3" phase="${4:-}" FINALIZE_CLOCK=""
|
||||
if [ "${MAM_DELEGATE_FAIL_CLOSED:-1}" = "0" ]; then
|
||||
return 0
|
||||
fi
|
||||
if [ "$job_status" = "completed" ]; then
|
||||
return 0
|
||||
fi
|
||||
# Issue #30: what the stall watcher saw goes with an unfinished job's close.
|
||||
if [ -s "$REGISTRY_DIR/$job_id.stall.out" ]; then
|
||||
echo "stall watch log for $job_id (last 3 lines):" >&2
|
||||
tail -n 3 "$REGISTRY_DIR/$job_id.stall.out" >&2 || true
|
||||
fi
|
||||
|
||||
local cur_disk_st="$(_disk_status "$job_id")"
|
||||
if [ "$cur_disk_st" = "completed" ] || [ "$cur_disk_st" = "error" ] || [ "$cur_disk_st" = "cancelled" ]; then
|
||||
FINAL_JOB_STATUS="$cur_disk_st"
|
||||
[ "$cur_disk_st" = "completed" ] && return 0
|
||||
else
|
||||
FINAL_JOB_STATUS="$job_status"
|
||||
fi
|
||||
# broker_unavailable: re-observe the disk at 3 s intervals until this
|
||||
# dispatch's wall-clock deadline (START_TIME + TIMEOUT). The deadline is read
|
||||
# off the clock on every pass; summing the sleeps alone ignores the time the
|
||||
# disk probes themselves take and overruns TIMEOUT.
|
||||
if [ "$job_status" = "broker_unavailable" ]; then
|
||||
local deadline left disk_st
|
||||
deadline=$(( ${START_TIME:-$(date +%s)} + TIMEOUT ))
|
||||
while :; do
|
||||
left=$(( deadline - $(date +%s) ))
|
||||
[ "$left" -le 0 ] && break
|
||||
[ "$left" -gt 3 ] && left=3
|
||||
sleep "$left"
|
||||
disk_st="$(_disk_status "$job_id")"
|
||||
if [ "$disk_st" = "completed" ] || [ "$disk_st" = "error" ] || [ "$disk_st" = "cancelled" ]; then
|
||||
job_status="$disk_st"
|
||||
FINAL_JOB_STATUS="$disk_st"
|
||||
[ "$disk_st" = "completed" ] && return 0
|
||||
break
|
||||
fi
|
||||
done
|
||||
# Issue #33 (review R3): a wait that ran into the deadline is the wall clock.
|
||||
[ "$(date +%s)" -ge "$deadline" ] && FINALIZE_CLOCK="wall"
|
||||
fi
|
||||
|
||||
# timeout: if subscriber timed out, check if agent is still actively working in herdr
|
||||
if [ "$job_status" = "timeout" ]; then
|
||||
local target_sess="${5:-${current_session:-${target_session:-$AGENT_SESSION}}}"
|
||||
local sess="${target_sess#herdr:}"
|
||||
local target_agent
|
||||
target_agent=$(_sanitize_herdr_agent_name "$sess")
|
||||
|
||||
# ISSUE-14 / ISSUE-18: the subscriber's idle clock only counts events it
|
||||
# received over the wire. Keep re-observing the disk while the *contract*
|
||||
# says the agent is alive: an event in events.log at most IDLE_TIMEOUT
|
||||
# (K x N) old (_recent_disk_heartbeat - publish_event records every event
|
||||
# there before its wire publish, the automatic heartbeat timer included).
|
||||
# herdr status and the pane are NOT evidence any more; they are logged
|
||||
# once here as a diagnostic, so an operator can tell a dead agent from a
|
||||
# silent one on the same host. Window policy: entering this grace opens
|
||||
# one IDLE_TIMEOUT window and every disk event re-opens it from the time
|
||||
# of that poll, so an agent that leaves no event at all is closed about
|
||||
# 2 x IDLE_TIMEOUT after its last wire event. Evidence only ever extends
|
||||
# the idle window, never this dispatch's wall clock: the loop ends at
|
||||
# START_TIME + TIMEOUT read off the clock on every pass.
|
||||
local deadline evidence_until left disk_st
|
||||
deadline=$(( ${START_TIME:-$(date +%s)} + TIMEOUT ))
|
||||
evidence_until=$(( $(date +%s) + IDLE_TIMEOUT ))
|
||||
if [ "$AGENT" != "human" ] && [ "$sess" != "human" ] && [ -n "$sess" ] && ! _is_remote "$target_sess"; then
|
||||
local diag="no"
|
||||
_within_deadline "$deadline" _agent_still_working "$sess" "$target_agent" && diag="yes"
|
||||
echo "liveness: no wire event for ${IDLE_TIMEOUT}s on job $job_id; herdr/pane says busy=$diag (diagnostic only, not evidence)" >&2
|
||||
fi
|
||||
while [ "$(date +%s)" -lt "$deadline" ]; do
|
||||
disk_st="$(_disk_status "$job_id")"
|
||||
if [ "$disk_st" = "completed" ] || [ "$disk_st" = "error" ] || [ "$disk_st" = "cancelled" ]; then
|
||||
job_status="$disk_st"
|
||||
FINAL_JOB_STATUS="$disk_st"
|
||||
[ "$disk_st" = "completed" ] && return 0
|
||||
break
|
||||
fi
|
||||
if _recent_disk_heartbeat "$job_id" "$IDLE_TIMEOUT"; then
|
||||
evidence_until=$(( $(date +%s) + IDLE_TIMEOUT ))
|
||||
elif [ "$(date +%s)" -ge "$evidence_until" ]; then
|
||||
break
|
||||
fi
|
||||
left=$(( deadline - $(date +%s) ))
|
||||
[ "$left" -le 0 ] && break
|
||||
sleep 1
|
||||
done
|
||||
[ "$(date +%s)" -ge "$deadline" ] && FINALIZE_CLOCK="wall"
|
||||
fi
|
||||
|
||||
# Issue #33: the subscriber's rc says which clock ran out (4 wall clock,
|
||||
# 2 no event); the disk-heartbeat grace above that ends on the deadline is
|
||||
# the wall clock too. bash only carries the label.
|
||||
local clock="${FINALIZE_CLOCK:-idle}"
|
||||
[ "$sub_rc" = "$SUB_RC_WALL_CLOCK" ] && clock="wall"
|
||||
local close_req="deadline_timeout"
|
||||
[ "$clock" = "wall" ] && [ "$phase" != "inject" ] && close_req="wall_clock_timeout"
|
||||
local detail=""
|
||||
if [ "$phase" = "preflight" ] || [ "$phase" = "idle_wait" ]; then
|
||||
close_req="cancelled"
|
||||
detail="session_busy"
|
||||
# Issue #34: a target the preflight could not see was never busy
|
||||
[ "$phase" = "preflight" ] && [ -n "${PREFLIGHT_REASON:-}" ] && detail="$PREFLIGHT_REASON"
|
||||
fi
|
||||
|
||||
[ "$close_req" != "cancelled" ] && echo "finalize: $job_id closed by $([ "$clock" = "wall" ] && echo wall_clock || echo no_event) clock (budget ${TIMEOUT}s / idle ${IDLE_TIMEOUT}s)" >&2
|
||||
local close_args=(--job "$job_id" --request "$close_req")
|
||||
[ -n "$detail" ] && close_args+=(--detail "$detail")
|
||||
[ -n "${_disp_tok:-}" ] && close_args+=(--expect-dispatch-token "$_disp_tok")
|
||||
|
||||
local close_rc=0
|
||||
"$PY" "$SCRIPT_DIR/scripts/registry.py" --registry-dir "$REGISTRY_DIR" close "${close_args[@]}" 2>&1 || close_rc=$?
|
||||
|
||||
# If close failed due to dispatch token mismatch (rc=4), suppress secondary event emission
|
||||
# to prevent CAS/ABA bypass
|
||||
if [ $close_rc -eq 4 ]; then
|
||||
echo "finalize_unfinished: dispatch token mismatch (stale attempt); suppressing event emission" >&2
|
||||
return 0
|
||||
fi
|
||||
|
||||
# Check if job completed on disk (universal, for all TYPEs)
|
||||
local cur_disk_st
|
||||
cur_disk_st="$(_disk_status "$job_id")"
|
||||
if [ "$cur_disk_st" = "completed" ]; then
|
||||
FINAL_JOB_STATUS="completed"
|
||||
return 0
|
||||
fi
|
||||
|
||||
# direct path only: publish MQTT error/cancelled event (loop/discuss forbidden: O-1)
|
||||
if [ "$TYPE" = "direct" ]; then
|
||||
local disp_arg=()
|
||||
[ -n "${_disp_tok:-}" ] && disp_arg=(--expect-dispatch-token "$_disp_tok")
|
||||
if [ "$close_req" = "cancelled" ]; then
|
||||
"$PY" "$SCRIPT_DIR/scripts/publish_event.py" --registry-dir "$REGISTRY_DIR" --job "$job_id" --event cancelled --detail "$detail" ${disp_arg[@]+"${disp_arg[@]}"} 2>/dev/null || true
|
||||
elif [ "$sub_rc" -ne "$SUB_RC_ERROR" ] || [ "$phase" = "inject" ]; then
|
||||
local err_detail="$close_req"
|
||||
[ "$phase" = "inject" ] && err_detail="agent_blocked"
|
||||
"$PY" "$SCRIPT_DIR/scripts/publish_event.py" --registry-dir "$REGISTRY_DIR" --job "$job_id" --event error --detail "$err_detail" ${disp_arg[@]+"${disp_arg[@]}"} 2>/dev/null || true
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
cmd_wait() {
|
||||
parse_opts "$@"
|
||||
PY="$(pick_python)"
|
||||
local rc=0
|
||||
if [[ -n "$JOB_ID" ]]; then
|
||||
"$PY" "$SCRIPT_DIR/scripts/job_subscriber.py" --registry-dir "$REGISTRY_DIR" \
|
||||
--job "$JOB_ID" --timeout "$TIMEOUT" || rc=$?
|
||||
else
|
||||
"$PY" "$SCRIPT_DIR/scripts/job_subscriber.py" --registry-dir "$REGISTRY_DIR" \
|
||||
--wait-any --timeout "$TIMEOUT" || rc=$?
|
||||
fi
|
||||
# Issue #33: either clock is a timeout (rc 2) to callers of `wait`, as before;
|
||||
# the subscriber's own log says which clock it was.
|
||||
[ "$rc" -eq "$SUB_RC_WALL_CLOCK" ] && rc=$SUB_RC_NO_EVENT
|
||||
return "$rc"
|
||||
}
|
||||
|
||||
@@ -0,0 +1,424 @@
|
||||
"""Issue #17 item 4: the delegate-job wrapper's decisions moved from bash to
|
||||
Python (lib_py/delegation/wrapper.py, lib_py/ints.py) with no behaviour change.
|
||||
|
||||
- U: unit tables for the new Python code (every input -> label / exit code,
|
||||
invalid input, boundaries).
|
||||
- C: comparison - the same input through the old bash functions (base
|
||||
7209750, tests/data/issue17_item4_old_decisions.sh) and through the new
|
||||
wrapper gives the same output, the same FINAL_JOB_STATUS and the same
|
||||
registry.py / publish_event.py calls.
|
||||
- S: static guard - the wrapper no longer carries the moved decisions.
|
||||
Runs on macOS and Linux: no /proc, no broker (registry.py / publish_event.py
|
||||
are stand-ins that log their argv).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parent.parent
|
||||
SKILLS = REPO_ROOT / ".agents" / "skills"
|
||||
WRAPPER = SKILLS / "multi-agent-mux-delegate-job" / "multi-agent-mux-delegate-job"
|
||||
LIB_INT = SKILLS / "lib_int.sh"
|
||||
INTS_PY = SKILLS / "lib_py" / "ints.py"
|
||||
OLD = REPO_ROOT / "tests" / "data" / "issue17_item4_old_decisions.sh"
|
||||
|
||||
if str(SKILLS) not in sys.path:
|
||||
sys.path.insert(0, str(SKILLS))
|
||||
|
||||
from lib_py import ints # noqa: E402
|
||||
from lib_py.delegation import wrapper as decide # noqa: E402
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# U - unit tables
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def test_u_subscriber_codes_mirror_job_subscriber():
|
||||
from lib_py.delegation import job_subscriber
|
||||
assert (decide.SUB_RC_COMPLETED, decide.SUB_RC_ERROR, decide.SUB_RC_NO_EVENT, decide.SUB_RC_BROKER_UNAVAILABLE,
|
||||
decide.SUB_RC_WALL_CLOCK) == (job_subscriber.RC_COMPLETED, job_subscriber.RC_ERROR, job_subscriber.RC_NO_EVENT,
|
||||
job_subscriber.RC_BROKER_UNAVAILABLE, job_subscriber.RC_WALL_CLOCK)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("disk", [None, "", "pending", "running", "completed", "error", "cancelled", "garbage"])
|
||||
@pytest.mark.parametrize("rc,want", [(0, "completed"), (1, "error"), (2, "timeout"), (3, None), (4, "timeout"),
|
||||
(5, "timeout"), (124, "timeout"), (-1, "timeout")])
|
||||
def test_u_sub_status_table(tmp_path, rc, want, disk):
|
||||
if disk == "garbage":
|
||||
(tmp_path / "j.json").write_text("{not json")
|
||||
elif disk is not None:
|
||||
(tmp_path / "j.json").write_text(json.dumps({"status": disk}))
|
||||
if want is None: # broker unavailable: a terminal record on disk wins
|
||||
want = disk if disk in ("completed", "error", "cancelled") else "broker_unavailable"
|
||||
assert decide.sub_status(rc, str(tmp_path), "j") == want
|
||||
|
||||
|
||||
@pytest.mark.parametrize("rc,up", [(0, True), (3, True), (1, False), (2, False), (4, False), (143, False)])
|
||||
def test_u_subscriber_up(rc, up):
|
||||
assert decide.subscriber_up(rc) is up
|
||||
|
||||
|
||||
@pytest.mark.parametrize("fc", [None, "", "1", "0", "yes"])
|
||||
@pytest.mark.parametrize("status,code", [("completed", 0), ("error", 1), ("timeout", 2), ("broker_unavailable", 3),
|
||||
("cancelled", 5), ("running", 1), ("", 1), ("pending", 1)])
|
||||
def test_u_exit_code_table(monkeypatch, status, code, fc):
|
||||
if fc is None:
|
||||
monkeypatch.delenv("MAM_DELEGATE_FAIL_CLOSED", raising=False)
|
||||
else:
|
||||
monkeypatch.setenv("MAM_DELEGATE_FAIL_CLOSED", fc)
|
||||
assert decide.exit_code(status) == (0 if fc == "0" else code)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("rc,want", [(0, 0), (1, 1), (2, 2), (3, 3), (4, 2), (5, 5)])
|
||||
def test_u_wait_rc(rc, want):
|
||||
assert decide.wait_rc(rc) == want
|
||||
|
||||
|
||||
@pytest.mark.parametrize("env,session,agent,watch,msg", [
|
||||
(None, "herdr:c", "claude", True, ""),
|
||||
("", "herdr:c", "claude", True, ""),
|
||||
("1", "c", "codex", True, ""),
|
||||
("0", "herdr:c", "claude", False, ""),
|
||||
("0", "remote:r", "claude", False, ""),
|
||||
(None, "remote:r", "claude", False, "remote job"),
|
||||
(None, "remote:human", "human", False, "remote job"),
|
||||
(None, "herdr:c", "human", False, "human job"),
|
||||
(None, "herdr:human", "claude", False, "human job"),
|
||||
(None, "human", "claude", False, "human job"),
|
||||
(None, "herdr:herdr:human", "claude", True, ""), # ${session#herdr:} strips one prefix
|
||||
])
|
||||
def test_u_stall_watch_table(monkeypatch, capsys, env, session, agent, watch, msg):
|
||||
if env is None:
|
||||
monkeypatch.delenv("MAM_STALL_WATCH", raising=False)
|
||||
else:
|
||||
monkeypatch.setenv("MAM_STALL_WATCH", env)
|
||||
assert decide.stall_watch(session, agent) is watch
|
||||
err = capsys.readouterr().err
|
||||
assert (msg in err) if msg else err == ""
|
||||
|
||||
|
||||
def _events(reg: Path, jid: str, *stamps: str) -> None:
|
||||
with open(reg / f"{jid}.events.log", "w") as fh:
|
||||
for s in stamps:
|
||||
fh.write((json.dumps({"event": "progress", "timestamp": s}) if s else "") + "\n")
|
||||
|
||||
|
||||
def test_u_recent_disk_heartbeat(tmp_path):
|
||||
now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
|
||||
old = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(time.time() - 100))
|
||||
assert decide.recent_disk_heartbeat(str(tmp_path), "j", 10) is False # no file
|
||||
_events(tmp_path, "j", old, now, "")
|
||||
assert decide.recent_disk_heartbeat(str(tmp_path), "j", 10) is True # the last non-blank line
|
||||
_events(tmp_path, "j", now, old)
|
||||
assert decide.recent_disk_heartbeat(str(tmp_path), "j", 10) is False
|
||||
assert decide.recent_disk_heartbeat(str(tmp_path), "j", 200) is True
|
||||
for bad in ("{not json", json.dumps({"event": "x"}), json.dumps({"timestamp": "yesterday"})):
|
||||
(tmp_path / "j.events.log").write_text(bad + "\n")
|
||||
assert decide.recent_disk_heartbeat(str(tmp_path), "j", 10**9) is False
|
||||
|
||||
|
||||
def _ns(**kw):
|
||||
import argparse
|
||||
base = dict(job="j", registry_dir="", status="timeout", start_time=None, timeout=60, idle_timeout=20,
|
||||
agent="claude", session="herdr:c")
|
||||
base.update(kw)
|
||||
return argparse.Namespace(**base)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("status,session,agent,step", [
|
||||
("timeout", "herdr:c", "claude", "probe"), ("timeout", "c", "codex", "probe"),
|
||||
("timeout", "remote:c", "claude", "go"), ("timeout", "herdr:human", "claude", "go"),
|
||||
("timeout", "herdr:c", "human", "go"), ("timeout", "", "claude", "go"), ("timeout", "herdr:", "claude", "go"),
|
||||
("error", "herdr:c", "claude", "go"), ("broker_unavailable", "herdr:c", "claude", "go"),
|
||||
("cancelled", "herdr:c", "claude", "go"),
|
||||
])
|
||||
def test_u_finalize_begin_steps(tmp_path, monkeypatch, status, session, agent, step):
|
||||
monkeypatch.delenv("MAM_DELEGATE_FAIL_CLOSED", raising=False)
|
||||
out = decide.finalize_begin(_ns(registry_dir=str(tmp_path), status=status, session=session, agent=agent,
|
||||
start_time=1000, timeout=60, idle_timeout=20)).split()
|
||||
assert out[0] == step and out[1] == status and out[3] == "1060"
|
||||
assert abs(int(out[2]) - (int(time.time()) + 20)) <= 1
|
||||
|
||||
|
||||
def test_u_finalize_begin_keep_done_and_disk(tmp_path, monkeypatch, capsys):
|
||||
monkeypatch.delenv("MAM_DELEGATE_FAIL_CLOSED", raising=False)
|
||||
reg = str(tmp_path)
|
||||
assert decide.finalize_begin(_ns(registry_dir=reg, status="completed")) == "keep"
|
||||
monkeypatch.setenv("MAM_DELEGATE_FAIL_CLOSED", "0")
|
||||
assert decide.finalize_begin(_ns(registry_dir=reg, status="error")) == "keep"
|
||||
monkeypatch.setenv("MAM_DELEGATE_FAIL_CLOSED", "1")
|
||||
(tmp_path / "j.json").write_text(json.dumps({"status": "completed"}))
|
||||
assert decide.finalize_begin(_ns(registry_dir=reg, status="timeout")) == "done completed"
|
||||
for disk in ("error", "cancelled"):
|
||||
(tmp_path / "j.json").write_text(json.dumps({"status": disk}))
|
||||
assert decide.finalize_begin(_ns(registry_dir=reg, status="timeout")).split()[:2] == ["probe", disk]
|
||||
(tmp_path / "j.json").write_text(json.dumps({"status": "running"}))
|
||||
(tmp_path / "j.stall.out").write_text("a\nb\nc\nd\n")
|
||||
capsys.readouterr()
|
||||
assert decide.finalize_begin(_ns(registry_dir=reg, status="error")).split()[:2] == ["go", "error"]
|
||||
assert capsys.readouterr().err == "stall watch log for j (last 3 lines):\nb\nc\nd\n"
|
||||
|
||||
|
||||
def test_u_cli_refuses_bad_input(tmp_path):
|
||||
env = {**os.environ, "PYTHONPATH": str(SKILLS)}
|
||||
for argv in (["sub-status", "x", "--job", "j", "--registry-dir", "."], ["sub-status", "1"], ["exit-code"],
|
||||
["wait-rc", "1.5"], ["nope"], [], ["finalize-end", "--job", "j"]):
|
||||
res = subprocess.run([sys.executable, "-m", "lib_py.delegation.wrapper", *argv], capture_output=True,
|
||||
text=True, env=env, timeout=60)
|
||||
assert res.returncode == 2 and res.stdout == "", (argv, res.stdout, res.stderr)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("value,minimum,want", [
|
||||
("999999999", 1, 999999999), ("1000000000", 1, None), ("0999999999", 1, 999999999), ("1", 1, 1),
|
||||
("0", 1, None), ("0", 0, 0), ("00", 0, 0), (" 7\n", 7, 7), ("6", 7, None), ("+5", 0, None), ("5 5", 0, None),
|
||||
("٥", 0, None), ("", 0, None), (None, 0, None)])
|
||||
def test_u_ints_boundaries(value, minimum, want):
|
||||
assert ints.positive_int(value, minimum) == want
|
||||
|
||||
|
||||
def test_u_ints_cli(tmp_path):
|
||||
def run(*a):
|
||||
return subprocess.run([sys.executable, "-I", str(INTS_PY), *a], capture_output=True, text=True, timeout=60)
|
||||
assert run("int", "0700", "1").stdout == "700\n"
|
||||
assert run("int", "abc", "1").returncode == 1
|
||||
res = run("knob", "K", "abc", "30", "1")
|
||||
assert res.stdout == "30\n" and "WARNING: K=abc ignored (not a decimal integer >= 1); using 30" in res.stderr
|
||||
assert run("knob", "K", "", "$X", "0").stdout == "$X\n" # the default is printed as given
|
||||
for bad in ([], ["int", "1"], ["knob", "K", "1", "2"], ["other", "1", "2"]):
|
||||
assert run(*bad).returncode == 2, bad
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# C - old bash vs new wrapper, same input, same result
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _shim(tmp_path: Path) -> Path:
|
||||
"""The wrapper's $PY: registry.py / publish_event.py / job_subscriber.py and
|
||||
the stall watcher are stand-ins that log their argv; anything else is the
|
||||
real interpreter."""
|
||||
shim = tmp_path / "py-shim"
|
||||
shim.write_text(
|
||||
"#!/bin/sh\n"
|
||||
'case "$1" in\n'
|
||||
' */scripts/registry.py) shift; echo "registry.py $*" >>"$CALL_LOG"; echo close-out; echo close-err >&2; '
|
||||
'exit "${CLOSE_RC:-0}";;\n'
|
||||
' */scripts/publish_event.py) shift; echo "publish_event.py $*" >>"$CALL_LOG"; echo pub-out; '
|
||||
'echo pub-err >&2; exit 0;;\n'
|
||||
' */scripts/job_subscriber.py) shift; echo "job_subscriber.py $*" >>"$CALL_LOG"; exit "${SUB_RC:-0}";;\n'
|
||||
"esac\n"
|
||||
'case "$*" in *lib_py.stall_watch*) echo "stall_watch $*" >>"$CALL_LOG"; exit 0;; esac\n'
|
||||
f'exec "{sys.executable}" "$@"\n')
|
||||
shim.chmod(0o755)
|
||||
return shim
|
||||
|
||||
|
||||
def _env(tmp_path: Path, **extra) -> dict:
|
||||
env = {k: v for k, v in os.environ.items()
|
||||
if not k.startswith(("HERDR_", "MAM_", "SKS_")) and k not in ("PYTHONPATH",)}
|
||||
env.update(MAM_DELEGATE_JOB_NO_MAIN="1", MAM_ENV_FILE=str(tmp_path / ".mam.env.absent"), HOME=str(tmp_path),
|
||||
DELEGATE_JOB_LOGS_DIR=str(tmp_path / "logs"))
|
||||
env.update({k: str(v) for k, v in extra.items() if v is not None})
|
||||
return env
|
||||
|
||||
|
||||
def _run_both(tmp_path: Path, body: str, env_extra: dict, setup=None):
|
||||
"""Run `body` after sourcing the new wrapper, once as is and once with the
|
||||
old functions sourced over it. Returns [(rc, stdout, stderr, calls)] old, new."""
|
||||
out = []
|
||||
for which in ("old", "new"):
|
||||
work = tmp_path / which
|
||||
reg = work / "reg"
|
||||
reg.mkdir(parents=True)
|
||||
if setup:
|
||||
setup(reg)
|
||||
log = work / "calls.log"
|
||||
log.write_text("")
|
||||
shim = _shim(work)
|
||||
script = (f'source "{WRAPPER}"\n' + (f'source "{OLD}"\n' if which == "old" else "")
|
||||
+ f'REGISTRY_DIR="{reg}"; PY="{shim}"\n' + body)
|
||||
res = subprocess.run(["bash", "-c", script], capture_output=True, text=True, cwd=str(work), timeout=120,
|
||||
env=_env(work, CALL_LOG=log, DELEGATE_JOB_PYTHON=shim, **env_extra))
|
||||
norm = lambda t: t.replace(str(work), "<W>") # noqa: E731
|
||||
calls = re.sub(r"--watch-pid \d+", "--watch-pid <pid>", norm(log.read_text()))
|
||||
out.append((res.returncode, norm(res.stdout), norm(res.stderr), calls))
|
||||
return out
|
||||
|
||||
|
||||
def _finalize_body(status, sub_rc, phase, *, typ="direct", agent="claude", session="herdr:c", timeout=5, idle=0,
|
||||
start_offset=-100, tok="tok1", reason="", fifth=None):
|
||||
return ("_agent_still_working() { return 1; }\n"
|
||||
"_sanitize_herdr_agent_name() { printf '%s\\n' \"$1\"; }\n"
|
||||
f'TYPE="{typ}"; AGENT="{agent}"; AGENT_SESSION="{session}"; TIMEOUT={timeout}; IDLE_TIMEOUT={idle}\n'
|
||||
f'START_TIME=$(( $(date +%s) + {start_offset} )); _disp_tok="{tok}"; PREFLIGHT_REASON="{reason}"\n'
|
||||
'FINAL_JOB_STATUS="unset"\n'
|
||||
f'finalize_unfinished j1 "{status}" "{sub_rc}" "{phase}"' + (f' "{fifth}"' if fifth else "") + "\n"
|
||||
'echo "FINAL=$FINAL_JOB_STATUS"\n')
|
||||
|
||||
|
||||
def _disk(status):
|
||||
def setup(reg):
|
||||
if status is not None:
|
||||
(reg / "j1.json").write_text(json.dumps({"job_id": "j1", "status": status}))
|
||||
return setup
|
||||
|
||||
|
||||
PAIRS = [("error", 1), ("timeout", 2), ("timeout", 4), ("broker_unavailable", 3), ("completed", 0), ("error", 2)]
|
||||
PHASES = ["direct", "inject", "preflight", "idle_wait", "subscriber", "worker"]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("phase", PHASES)
|
||||
@pytest.mark.parametrize("status,sub_rc", PAIRS)
|
||||
def test_c_finalize_labels_closes_and_events(tmp_path, status, sub_rc, phase):
|
||||
"""Past the wall clock: every status x subscriber rc x phase."""
|
||||
old, new = _run_both(tmp_path, _finalize_body(status, sub_rc, phase, reason="target_not_found"), {},
|
||||
setup=_disk("running"))
|
||||
assert old == new, (old, new)
|
||||
assert "FINAL=" in new[1]
|
||||
|
||||
|
||||
VARIANTS = [
|
||||
# (status, sub_rc, phase, body kwargs, disk, env)
|
||||
("timeout", 2, "direct", dict(start_offset=0, timeout=60, idle=0), "running", {}), # idle clock
|
||||
("timeout", 2, "direct", dict(start_offset=0, timeout=60, idle=0, agent="human"), "running", {}),
|
||||
("timeout", 2, "direct", dict(session="remote:r"), "running", {}),
|
||||
("timeout", 2, "worker", dict(fifth="herdr:other"), "running", {}),
|
||||
("timeout", 2, "direct", dict(typ="loop"), "running", {}),
|
||||
("error", 1, "inject", dict(typ="discuss"), "running", {}),
|
||||
("timeout", 2, "direct", {}, "completed", {}),
|
||||
("timeout", 2, "direct", {}, "error", {}),
|
||||
("broker_unavailable", 3, "direct", {}, "cancelled", {}),
|
||||
("broker_unavailable", 3, "direct", {}, None, {}),
|
||||
("error", 1, "direct", {}, "garbage", {}),
|
||||
("timeout", 4, "direct", dict(tok=""), "running", {}),
|
||||
("error", 1, "preflight", dict(reason=""), "running", {}),
|
||||
("error", 1, "preflight", dict(reason="target_not_found", tok=""), "running", {}),
|
||||
("error", 2, "idle_wait", dict(reason="target_not_found"), "running", {}),
|
||||
("timeout", 2, "direct", {}, "running", {"CLOSE_RC": "4"}),
|
||||
("error", 1, "inject", {}, "running", {"CLOSE_RC": "1"}),
|
||||
("error", 1, "direct", {}, "running", {"MAM_DELEGATE_FAIL_CLOSED": "0"}),
|
||||
("completed", 0, "direct", {}, "error", {}),
|
||||
("broker_unavailable", 3, "direct", dict(start_offset=0, timeout=1), "running", {}), # one 1 s re-observation
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("status,sub_rc,phase,kw,disk,env", VARIANTS)
|
||||
def test_c_finalize_variants(tmp_path, status, sub_rc, phase, kw, disk, env):
|
||||
def setup(reg):
|
||||
if disk == "garbage":
|
||||
(reg / "j1.json").write_text("{not json")
|
||||
else:
|
||||
_disk(disk)(reg)
|
||||
(reg / "j1.stall.out").write_text("one\ntwo\nthree\nfour\n")
|
||||
old, new = _run_both(tmp_path, _finalize_body(status, sub_rc, phase, **kw), env, setup=setup)
|
||||
assert old == new, (old, new)
|
||||
|
||||
|
||||
def test_c_finalize_heartbeat_grace_runs_to_the_wall_clock(tmp_path):
|
||||
"""Fresh disk heartbeats keep the grace open until the deadline (2 s)."""
|
||||
def setup(reg):
|
||||
_disk("running")(reg)
|
||||
_events(reg, "j1", time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(time.time() + 30)))
|
||||
t0 = time.time()
|
||||
old, new = _run_both(tmp_path, _finalize_body("timeout", 2, "direct", start_offset=0, timeout=2, idle=1), {},
|
||||
setup=setup)
|
||||
assert old == new, (old, new)
|
||||
assert "wall_clock_timeout" in new[3] and time.time() - t0 >= 3
|
||||
|
||||
|
||||
def test_c_finalize_grace_sees_a_late_completion(tmp_path):
|
||||
"""A record that turns completed during the grace ends it as completed."""
|
||||
body = ("( sleep 1; printf '%s' '{\"status\": \"completed\"}' > \"$REGISTRY_DIR/j1.json\" ) &\n"
|
||||
+ _finalize_body("timeout", 2, "direct", start_offset=0, timeout=30, idle=10))
|
||||
old, new = _run_both(tmp_path, body, {}, setup=_disk("running"))
|
||||
assert old == new, (old, new)
|
||||
assert "FINAL=completed" in new[1] and new[3] == ""
|
||||
|
||||
|
||||
@pytest.mark.parametrize("rc", [0, 1, 2, 3, 4, 5])
|
||||
def test_c_sub_status_exit_code_and_subscriber_up(tmp_path, rc):
|
||||
body = (f'st=$(_map_sub_rc {rc} j1 2>/dev/null || _decide sub-status {rc} --job j1 --registry-dir "$REGISTRY_DIR")\n'
|
||||
'echo "status=$st"\n')
|
||||
# the old file defines _map_sub_rc; the new wrapper does not
|
||||
for disk in (None, "running", "completed", "error", "cancelled"):
|
||||
old, new = _run_both(tmp_path / str(disk), body, {}, setup=_disk(disk))
|
||||
assert old == new, (disk, old, new)
|
||||
for fc in ("1", "0"):
|
||||
code = (f'if declare -F _rc_for >/dev/null; then if [ "${{MAM_DELEGATE_FAIL_CLOSED:-1}}" = "0" ]; then echo 0; '
|
||||
f'else _rc_for "$(_map_sub_rc {rc} j1)"; fi; else _decide exit-code "$(_decide sub-status {rc} --job j1 '
|
||||
f'--registry-dir "$REGISTRY_DIR")"; fi\n')
|
||||
old, new = _run_both(tmp_path / f"fc{fc}", code, {"MAM_DELEGATE_FAIL_CLOSED": fc})
|
||||
assert old == new, (fc, old, new)
|
||||
up = (f'if declare -F _rc_for >/dev/null; then sub_exit={rc}; '
|
||||
f'if [ $sub_exit -eq $SUB_RC_COMPLETED ] || [ $sub_exit -eq $SUB_RC_BROKER_UNAVAILABLE ]; then echo up; '
|
||||
f'else echo down; fi; else _decide subscriber-up {rc} && echo up || echo down; fi\n')
|
||||
old, new = _run_both(tmp_path / "up", up, {})
|
||||
assert old == new, (old, new)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("rc", [0, 1, 2, 3, 4, 5])
|
||||
@pytest.mark.parametrize("job", ["", "j1"])
|
||||
def test_c_cmd_wait(tmp_path, rc, job):
|
||||
body = (f'set +e; cmd_wait {"--job " + job if job else ""} --timeout 5; echo "rc=$?"\n')
|
||||
old, new = _run_both(tmp_path, body, {"SUB_RC": rc})
|
||||
assert old == new, (old, new)
|
||||
assert f"rc={2 if rc == 4 else rc}" in new[1]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("env,session,agent", [
|
||||
(None, "herdr:c", "claude"), ("0", "herdr:c", "claude"), (None, "remote:r", "claude"),
|
||||
(None, "herdr:c", "human"), (None, "herdr:human", "codex"), ("", "c", "codex")])
|
||||
@pytest.mark.parametrize("tok,att", [("", ""), ("tok1", "2")])
|
||||
def test_c_start_stall_watch(tmp_path, env, session, agent, tok, att):
|
||||
body = (f'JOB_ID=j1; start_stall_watch "{session}" "{agent}" "{tok}" "{att}" >out.txt\n'
|
||||
'[ -z "$STALL_PID" ] || wait "$STALL_PID"\n'
|
||||
'sed "s/pid: [0-9]*/pid: N/" out.txt; echo "spawned=${STALL_PID:+yes}"\n')
|
||||
old, new = _run_both(tmp_path, body, {"MAM_STALL_WATCH": env, "HERDR_SESSION_NAME": "hs"})
|
||||
assert old == new, (old, new)
|
||||
|
||||
|
||||
INT_INPUTS = ["30", "0700", "0900", " 30 ", "0", "-5", "abc", "", "1e3", "9999999999", "000000000030",
|
||||
"999999999", "1000000000", " 30 ", "٣٠", "\t7\n", "9" * 5000]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("locale", ["C", "en_US.UTF-8"])
|
||||
@pytest.mark.parametrize("minimum", [0, 1])
|
||||
def test_c_mam_int_and_knob(tmp_path, locale, minimum):
|
||||
old_fns = subprocess.run(["sed", "-n", "/^mam_int()/,/^}/p;/^mam_int_knob()/,/^}/p", str(OLD)],
|
||||
capture_output=True, text=True, check=True).stdout
|
||||
probe = ('for v in "${VALUES[@]}"; do printf "[%s]" "$(mam_int "$v" "$MIN" || echo invalid)"; '
|
||||
'K="$v" mam_int_knob K 42 "$MIN"; done; echo; mam_int_knob UNSET_KNOB 9 "$MIN"\n')
|
||||
arr = "VALUES=(" + " ".join("$'" + v.encode("unicode_escape").decode().replace("'", "\\'") + "'"
|
||||
for v in INT_INPUTS) + ")\n"
|
||||
outs = []
|
||||
for src in (old_fns, f'source "{LIB_INT}"\n'):
|
||||
res = subprocess.run(["bash", "-c", src + arr + probe], capture_output=True, text=True, timeout=120,
|
||||
env={**os.environ, "MIN": str(minimum), "LC_ALL": locale, "LANG": locale})
|
||||
outs.append((res.returncode, res.stdout, res.stderr))
|
||||
assert outs[0] == outs[1], outs
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# S - static guard
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def test_s_the_wrapper_carries_no_moved_decision():
|
||||
text = "\n".join(l for l in WRAPPER.read_text().splitlines() if not l.lstrip().startswith("#"))
|
||||
for name in ("_map_sub_rc", "_rc_for", "_disk_status", "_recent_disk_heartbeat", "FINALIZE_CLOCK"):
|
||||
assert name not in text, name
|
||||
for knob in ("MAM_DELEGATE_FAIL_CLOSED", "MAM_STALL_WATCH"):
|
||||
assert "${" + knob not in text, knob
|
||||
# subscriber codes are compared nowhere in bash any more
|
||||
assert not re.search(r"-(eq|ne) +\"?\$SUB_RC_", text)
|
||||
assert not re.search(r"= +\"?\$SUB_RC_", text)
|
||||
for label in ("wall_clock_timeout", "deadline_timeout", "agent_blocked", "session_busy"):
|
||||
assert label not in text, label
|
||||
assert "BASH_REMATCH" not in LIB_INT.read_text()
|
||||
@@ -83,8 +83,9 @@ INPUTS = ["30", "0700", "0900", " 30 ", "0", "-5", "abc", "", "1e3", "9999999999
|
||||
# arithmetic, each with where the value goes. B5 fails on any `${MAM_/SKS_/
|
||||
# DELEGATE_JOB_/RECONCILE_…:-<digit>…}` that is neither here nor normalised
|
||||
# through INT_KNOBS, so a new knob has to be classified to land.
|
||||
# Issue #17 item 4: MAM_DELEGATE_FAIL_CLOSED and MAM_STALL_WATCH are read by
|
||||
# lib_py/delegation/wrapper.py now, not by shell code.
|
||||
NOT_ARITHMETIC = {
|
||||
"MAM_DELEGATE_FAIL_CLOSED": "string compare", "MAM_STALL_WATCH": "string compare",
|
||||
"MAM_ALLOW_UNSIGNED_DISPATCH": "string compare", "MAM_DELEGATE_JOB_NO_MAIN": "string compare",
|
||||
"MAM_NO_AUTOSTART": "string compare", "MAM_SHIM_DEBUG": "string compare",
|
||||
"MAM_NO_SUBSCRIBER_DAEMON": "string compare", "MAM_DELEGATION_PY": "string compare",
|
||||
|
||||
@@ -385,15 +385,16 @@ def test_event_to_status_mapping_is_frozen(mam_sandbox):
|
||||
def test_wrapper_exit_code_mapping_literals_are_frozen(mam_sandbox):
|
||||
wrapper = SKILLS / "multi-agent-mux-delegate-job" / "multi-agent-mux-delegate-job"
|
||||
text = wrapper.read_text(encoding="utf-8")
|
||||
for literal in (
|
||||
'if [[ $sub_rc -eq $SUB_RC_COMPLETED ]]; then',
|
||||
'elif [[ $sub_rc -eq $SUB_RC_ERROR ]]; then',
|
||||
'elif [[ $sub_rc -eq $SUB_RC_BROKER_UNAVAILABLE ]]; then',
|
||||
'[ "$sub_rc" = "$SUB_RC_WALL_CLOCK" ] && clock="wall"',
|
||||
'job_status="completed"',
|
||||
'job_status="error"',
|
||||
):
|
||||
# Issue #17 item 4: the mapping moved to lib_py/delegation/wrapper.py; the
|
||||
# wrapper reaches it only through `_decide`.
|
||||
for literal in ('_decide sub-status "$sub_rc"', '_decide exit-code "$job_status"', "--sub-rc \"$sub_rc\""):
|
||||
assert literal in text, literal
|
||||
decide = _import_delegation(mam_sandbox, "wrapper")
|
||||
assert decide.EXIT_CODES == {"completed": 0, "error": 1, "timeout": 2, "broker_unavailable": 3, "cancelled": 5}
|
||||
assert [decide.sub_status(rc, str(mam_sandbox), "none") for rc in range(6)] == [
|
||||
"completed", "error", "timeout", "broker_unavailable", "timeout", "timeout"]
|
||||
assert (decide.SUB_RC_COMPLETED, decide.SUB_RC_ERROR, decide.SUB_RC_NO_EVENT, decide.SUB_RC_BROKER_UNAVAILABLE,
|
||||
decide.SUB_RC_WALL_CLOCK) == tuple(int(v) for v in re.findall(r"\bSUB_RC_[A-Z_]+=([0-9]+)", text))
|
||||
# Issue #33: the wrapper's SUB_RC_* mirror job_subscriber's RC_* exactly,
|
||||
# and the wrapper compares subscriber codes only by those names.
|
||||
job_subscriber = _import_delegation(mam_sandbox, "job_subscriber")
|
||||
|
||||
@@ -841,11 +841,16 @@ def test_g9_subscriber_broker_down_no_disk_terminal_exits_3(mam_sandbox, monkeyp
|
||||
|
||||
|
||||
def test_g10_delegate_job_rc3_not_mistaken_for_error(mam_sandbox):
|
||||
"""G-10: multi-agent-mux-delegate-job maps rc=3 to broker_unavailable and checks disk status."""
|
||||
"""G-10: multi-agent-mux-delegate-job maps rc=3 to broker_unavailable and checks disk status.
|
||||
Issue #17 item 4: the mapping is lib_py/delegation/wrapper.py's sub_status."""
|
||||
delegate_script = mam_sandbox / "skills" / "multi-agent-mux-delegate-job" / "multi-agent-mux-delegate-job"
|
||||
content = delegate_script.read_text()
|
||||
assert "elif [[ $sub_rc -eq $SUB_RC_BROKER_UNAVAILABLE ]]; then" in content
|
||||
assert 'job_status="broker_unavailable"' in content
|
||||
assert '_decide sub-status "$sub_rc"' in delegate_script.read_text()
|
||||
from lib_py.delegation import wrapper
|
||||
reg = mam_sandbox / "g10-reg"
|
||||
reg.mkdir()
|
||||
assert wrapper.sub_status(3, str(reg), "g10") == "broker_unavailable"
|
||||
(reg / "g10.json").write_text('{"status": "completed"}')
|
||||
assert wrapper.sub_status(3, str(reg), "g10") == "completed"
|
||||
|
||||
|
||||
def test_claude_adapter_ready_tokens_includes_modern_banners():
|
||||
|
||||
Reference in new issue
Block a user