From ade3b891376be73afa224b6b6337e1d8252ab8fa Mon Sep 17 00:00:00 2001 From: Zeusina Date: Wed, 14 Oct 2026 22:37:48 +0300 Subject: [PATCH] chore: add private-safe controller startup diagnostics Add fixed startup branch labels and numeric apply exit status without relaxing startup guards or exposing private values. Cover shared launch/ACK and wrapper branches plus failed apply cleanup. Diagnostics only; the ACK publication race remains unchanged. Co-authored-by: GPT-6 --- cmd/zapret-autotune/resource_apply.go | 1 + cmd/zapret-autotune/resource_apply_test.go | 5 +- .../check_startup_diagnostics.py | 94 +++++++++++++++++++ deploy/managed-target/check_supervision.py | 13 ++- managed-target-entrypoint.sh | 19 +++- managed-target-supervision.sh | 6 +- 6 files changed, 131 insertions(+), 7 deletions(-) create mode 100644 deploy/managed-target/check_startup_diagnostics.py diff --git a/cmd/zapret-autotune/resource_apply.go b/cmd/zapret-autotune/resource_apply.go index a012892..9e76715 100644 --- a/cmd/zapret-autotune/resource_apply.go +++ b/cmd/zapret-autotune/resource_apply.go @@ -317,6 +317,7 @@ func resourceApplyMode(config string, d managedDeps) error { } func resourceApplyCLI(config string, stdout, stderr io.Writer, d managedDeps) int { + fmt.Fprintln(stderr, "controller-startup: resource_apply=entry") blocked := func() int { fmt.Fprintln(stderr, "BLOCKED: generic apply trust/health incomplete; deployment preserved or prepared for recovery") return 78 diff --git a/cmd/zapret-autotune/resource_apply_test.go b/cmd/zapret-autotune/resource_apply_test.go index ca22292..b147e01 100644 --- a/cmd/zapret-autotune/resource_apply_test.go +++ b/cmd/zapret-autotune/resource_apply_test.go @@ -337,9 +337,12 @@ func TestResourceApplyHealthCollector(t *testing.T) { func TestResourceApplyUnauthorizedCLI(t *testing.T) { var out bytes.Buffer d := managedDeps{} - if code := resourceApplyCLI("/private/config", &out, &out, d); code != 78 { + if code := resourceApplyCLI("/private/SECRET_SENTINEL", &out, &out, d); code != 78 { t.Fatal(code) } + if got, want := out.String(), "controller-startup: resource_apply=entry\nBLOCKED: generic apply trust/health incomplete; deployment preserved or prepared for recovery\n"; got != want { + t.Fatalf("unexpected diagnostic: %q", got) + } } func TestResourceApplyFreshBeforeStaging(t *testing.T) { diff --git a/deploy/managed-target/check_startup_diagnostics.py b/deploy/managed-target/check_startup_diagnostics.py new file mode 100644 index 0000000..c2f79c0 --- /dev/null +++ b/deploy/managed-target/check_startup_diagnostics.py @@ -0,0 +1,94 @@ +"""Offline deterministic startup guards: python3 deploy/managed-target/check_startup_diagnostics.py.""" +from pathlib import Path +import subprocess +import tempfile + +ROOT = Path(__file__).resolve().parents[2] +entry = (ROOT / 'managed-target-entrypoint.sh').read_text() +capture = entry[entry.index('capture_monitor_session() {'):entry.index('# Wait with a watchdog:')] +launch = entry[entry.index('launch_controller() {'):entry.index('run_cycle() {')] +fixture_launch = launch.replace(' 8<&- 9<&- &', ' 8<&- 9<&-').replace( + 'monitor_ack_deadline=$(($(date +%s) + 5))', 'monitor_ack_deadline=100') +secret = 'SECRET_SENTINEL' + +# Run the actual shared launch for both callers. Only platform operations are +# stubbed, so no daemon or monitor is started, and no deadline is extended. +for role in ('managed resource-apply --resource-config', 'managed monitor'): + for scenario, diagnostic in ( + ('empty', 'ack=read_failed'), ('malformed', 'ack=invalid_pid'), + ('wrong', 'ack=identity_mismatch'), ('session', 'launch=session_mismatch'), + ('gone', 'launch=child_gone'), ('timeout', 'launch=ack_timeout'), + ): + with tempfile.TemporaryDirectory(prefix='startup-diagnostics-') as tmp: + script = f'''set -eu +config_dir='{tmp}' +monitor_sid= +scenario={scenario} +date() {{ echo 100; }} +setsid() {{ + case "$scenario" in + empty) : > "$config_dir/monitor-ready" ;; + malformed) echo '{secret}' > "$config_dir/monitor-ready" ;; + wrong) echo 1 > "$config_dir/monitor-ready" ;; + session) echo "$!" > "$config_dir/monitor-ready" ;; + esac +}} +kill() {{ [ "$scenario" != gone ]; }} +signal_tree() {{ :; }} +proc_identity() {{ proc_sid=1; }} +{capture} +sleep 30 & seed=$! +# The fake launch is synchronous, preserving $! as the seeded owned child. +{fixture_launch} +code=0 +launch_controller {role} '{secret}' || code=$? +[ "$code" -eq 78 ] +[ -z "$monitor_sid" ] +# Model delayed publication after an empty ACK: failure already closed the gate. +printf '%s\\n' "$seed" > "$config_dir/monitor-ready" +command kill "$seed" +wait "$seed" 2>/dev/null || true +''' + result = subprocess.run(['sh', '-c', script], capture_output=True, timeout=3) + assert result.returncode == 0, (role, scenario, result.stderr) + assert result.stderr == f'controller-startup: {diagnostic}\n'.encode(), result.stderr + assert secret.encode() not in result.stdout + result.stderr + +helper = (ROOT / 'managed-target-supervision.sh').read_text() +with tempfile.TemporaryDirectory(prefix='delayed-ack-') as tmp: + wrapper_path = Path(tmp) / 'wrapper.sh' + wrapper_path.write_text(helper.replace(' printf \'%s\\n\' "$$" > "$config_dir/monitor-ready"', + ' : > "$config_dir/monitor-ready"\n sleep 1\n printf \'%s\\n\' "$$" > "$config_dir/monitor-ready"')) + real_launch = launch.replace('/opt/managed-target-supervision.sh', str(wrapper_path)).replace( + '/usr/local/bin/zapret-autotune', '/bin/true') + result = subprocess.run(['sh', '-c', f'''set -eu +config_dir='{tmp}' +monitor_sid= +. '{ROOT / 'managed-target-supervision.sh'}' +{capture} +{real_launch} +code=0 +launch_controller managed resource-apply '{secret}' || code=$? +signal_tree "$monitor_pid" KILL +wait "$monitor_pid" 2>/dev/null || true +[ "$code" -eq 78 ] +[ -z "$monitor_sid" ] +'''], capture_output=True, timeout=3) + assert result.returncode == 0, result.stderr + assert result.stderr == b'controller-startup: ack=read_failed\n', result.stderr + +wrapper = helper[helper.index('if [ "${1-}" = --monitor ]; then'):helper.index('elif [ "${1-}" = --watchdog ]; then')] + '\nfi\n' +for identity, diagnostic, code in ( + ('return 1', 'identity_unavailable', 78), + ('proc_sid=1', 'not_session_leader', 78), + ('proc_sid=$$', 'exec_pending', 0), +): + with tempfile.TemporaryDirectory(prefix='wrapper-diagnostics-') as tmp: + result = subprocess.run(['sh', '-c', f'proc_identity() {{ {identity}; }}\n{wrapper}', + 'fixture', '--monitor', tmp, '/bin/true', secret], capture_output=True, timeout=3) + assert result.returncode == code, result.stderr + assert result.stderr == f'controller-startup: wrapper={diagnostic}\n'.encode(), result.stderr + ready = Path(tmp) / 'monitor-ready' + assert ready.exists() == (code == 0) + assert secret.encode() not in result.stdout + result.stderr +print('startup diagnostic fixtures passed (shared apply/monitor launch and wrapper)') diff --git a/deploy/managed-target/check_supervision.py b/deploy/managed-target/check_supervision.py index f8f6c54..3e7254f 100644 --- a/deploy/managed-target/check_supervision.py +++ b/deploy/managed-target/check_supervision.py @@ -78,7 +78,7 @@ if name == 'sleep': sys.exit(0) if scenario.startswith('generic-budget-') and seconds != 60: os.execv(os.environ['REAL_SLEEP'], [os.environ['REAL_SLEEP'], *sys.argv[1:]]) - if seconds == 60 and scenario in ('generic-ss', 'generic-unsafe', 'generic-budget-monitor', 'generic-budget-reconcile', 'generic-budget-ack', 'generic-apply-blocked'): + if seconds == 60 and scenario in ('generic-ss', 'generic-unsafe', 'generic-budget-monitor', 'generic-budget-reconcile', 'generic-budget-ack', 'generic-apply-blocked', 'generic-apply-abrupt', 'generic-apply-cleanup'): log('generic-pause') (root / 'budget-pause').touch() if scenario != 'generic-ss': @@ -335,6 +335,8 @@ elif command == 'resource-apply': log('resource-apply') if scenario == 'generic-apply-blocked': sys.exit(78) + if scenario in ('generic-apply-abrupt', 'generic-apply-cleanup'): + sys.exit(23) if scenario == 'generic-apply-cancel': def restored(*_): log('resource-restored') @@ -384,6 +386,8 @@ def run(scenario, expected, dns='', mode='native'): text = text.replace('config_dir=/run/zapret-autotune-ss', f'config_dir={configs}') text = text.replace('/usr/local/bin/zapret-autotune', str(binary / 'autotune')) text = text.replace('/opt/zapret2/init.d/sysv/zapret2', str(binary / 'zapret2')) + if scenario == 'generic-apply-cleanup': + text = text.replace('cleanup_session || { echo', "cleanup_session() { return 78; }\n cleanup_session || { echo", 1) if scenario.endswith('-race'): barrier = f'{binary / "autotune"} qualification-race-barrier "$monitor_pid"\n' loop = 'while dns_alive && kill -0 "$server_pid" && kill -0 "$local_pid" && kill -0 "$monitor_pid"; do' @@ -439,6 +443,10 @@ def run(scenario, expected, dns='', mode='native'): assert result.returncode == expected, (scenario, result.returncode, result.stderr, events) assert b'Illegal number' not in result.stderr, (scenario, result.stderr) assert b'ab' * 32 not in result.stdout + result.stderr + if scenario in ('generic-apply-blocked', 'generic-apply-abrupt', 'generic-apply-cleanup'): + code = 78 if scenario == 'generic-apply-blocked' else 23 + assert f'controller-startup: apply_wait_exit={code}\n'.encode() in result.stderr, result.stderr + assert (b'controller-startup: apply_cleanup=failed\n' in result.stderr) == (scenario == 'generic-apply-cleanup'), result.stderr for pid in ((root / 'children').read_text().splitlines() if (root / 'children').exists() else []): assert not Path(f'/proc/{pid}').exists(), (scenario, 'child not joined', pid) if scenario == 'orphans': @@ -506,6 +514,9 @@ assert 'resource-restored' in events and 'start' not in events and 'monitor 1' n assert events.index('resource-restored') < events.index('stop') < events.index('dns-stop'), events events = run('generic-apply-blocked', 0, mode='doh') assert 'start' not in events and 'monitor 1' not in events and 'generic-pause' in events, events +for scenario, code in (('generic-apply-abrupt', 0), ('generic-apply-cleanup', 78)): + events = run(scenario, code, mode='doh') + assert 'start' not in events and 'monitor 1' not in events and 'resource-applied' not in events, events for scenario in ('generic-budget-monitor', 'generic-budget-reconcile', 'generic-budget-ack'): events = run(scenario, 78, mode='doh') assert events.count('start') == 1 and 'stop' not in events, (scenario, events) diff --git a/managed-target-entrypoint.sh b/managed-target-entrypoint.sh index c06e34e..591808f 100644 --- a/managed-target-entrypoint.sh +++ b/managed-target-entrypoint.sh @@ -130,9 +130,13 @@ cleanup_session() { capture_monitor_session() { [ -z "$monitor_sid" ] || return 0 if [ -e "$config_dir/monitor-ready" ]; then - read -r candidate_sid < "$config_dir/monitor-ready" || return 78 - case "$candidate_sid" in ''|*[!0-9]*) return 78 ;; esac - [ "$candidate_sid" = "$monitor_pid" ] && [ "$candidate_sid" -gt 1 ] && [ "$candidate_sid" != "$$" ] || return 78 + { read -r candidate_sid < "$config_dir/monitor-ready"; } 2>/dev/null || { + echo 'controller-startup: ack=read_failed' >&2; return 78; + } + case "$candidate_sid" in ''|*[!0-9]*) echo 'controller-startup: ack=invalid_pid' >&2; return 78 ;; esac + [ "$candidate_sid" = "$monitor_pid" ] && [ "$candidate_sid" -gt 1 ] && [ "$candidate_sid" != "$$" ] || { + echo 'controller-startup: ack=identity_mismatch' >&2; return 78; + } monitor_sid=$candidate_sid elif proc_identity "$monitor_pid" && [ "$proc_sid" = "$monitor_pid" ] && [ "$proc_sid" -gt 1 ]; then monitor_sid=$proc_sid @@ -339,12 +343,18 @@ launch_controller() { monitor_ack_deadline=$(($(date +%s) + 5)) while [ ! -e "$config_dir/monitor-ready" ]; do if ! kill -0 "$monitor_pid" 2>/dev/null || [ "$(date +%s)" -ge "$monitor_ack_deadline" ]; then + if ! kill -0 "$monitor_pid" 2>/dev/null; then + echo 'controller-startup: launch=child_gone' >&2 + else + echo 'controller-startup: launch=ack_timeout' >&2 + fi signal_tree "$monitor_pid" KILL return 78 fi done capture_monitor_session || return 78 if proc_identity "$monitor_pid" && [ "$proc_sid" != "$monitor_sid" ]; then + echo 'controller-startup: launch=session_mismatch' >&2 monitor_sid= return 78 fi @@ -387,8 +397,9 @@ if [ "${ZAPRET_AUTOTUNE_RESOURCE_APPLY-0}" = 1 ]; then { dns_alive && kill -0 "$server_pid" && kill -0 "$local_pid"; } || return 75 apply_code=0 wait "$monitor_pid" || apply_code=$? + echo "controller-startup: apply_wait_exit=$apply_code" >&2 monitor_pid= - cleanup_session || return 78 + cleanup_session || { echo 'controller-startup: apply_cleanup=failed' >&2; return 78; } [ "$apply_code" -eq 0 ] || return 78 fi # Idempotent apply may have only verified the already committed config. diff --git a/managed-target-supervision.sh b/managed-target-supervision.sh index 2884a5f..9b80037 100644 --- a/managed-target-supervision.sh +++ b/managed-target-supervision.sh @@ -61,11 +61,15 @@ if [ "${1-}" = --monitor ]; then [ "$#" -ge 3 ] || exit 64 config_dir=$2 shift 2 - proc_identity "$$" && [ "$proc_sid" = "$$" ] && [ "$$" -gt 1 ] || exit 78 + proc_identity "$$" || { echo 'controller-startup: wrapper=identity_unavailable' >&2; exit 78; } + [ "$proc_sid" = "$$" ] && [ "$$" -gt 1 ] || { + echo 'controller-startup: wrapper=not_session_leader' >&2; exit 78; + } # Acknowledge the private session before exec, so even an immediate monitor # crash leaves its ownership recorded. No worker can precede this handshake. trap 'exit 143' INT TERM printf '%s\n' "$$" > "$config_dir/monitor-ready" + echo 'controller-startup: wrapper=exec_pending' >&2 exec "$@" elif [ "${1-}" = --watchdog ]; then set -eu