360 lines
14 KiB
Bash
Executable File
360 lines
14 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
demo_repository_root() {
|
|
cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd -P
|
|
}
|
|
|
|
demo_is_uint() {
|
|
[[ ${1:-} =~ ^[0-9]+$ ]]
|
|
}
|
|
|
|
demo_is_process_id() {
|
|
[[ ${1:-} =~ ^[1-9][0-9]*$ ]] && ((10#$1 > 1))
|
|
}
|
|
|
|
demo_read_one_line() {
|
|
local path=$1 destination=$2 value extra
|
|
IFS= read -r value <"$path" || return 1
|
|
if IFS= read -r extra < <(sed -n '2p' "$path") && [[ -n "$extra" ]]; then return 1; fi
|
|
printf -v "$destination" '%s' "$value"
|
|
}
|
|
|
|
demo_read_process_identity() {
|
|
local pid=$1 state_name=$2 start_name=$3 pgid_name=$4 sid_name=$5 stat rest
|
|
local -a fields
|
|
demo_is_process_id "$pid" || return 1
|
|
{ IFS= read -r stat <"/proc/$pid/stat"; } 2>/dev/null || return 1
|
|
rest=${stat##*) }
|
|
read -r -a fields <<<"$rest"
|
|
((${#fields[@]} >= 20)) || return 1
|
|
demo_is_uint "${fields[2]}" && demo_is_uint "${fields[3]}" && demo_is_uint "${fields[19]}" || return 1
|
|
printf -v "$state_name" '%s' "${fields[0]}"
|
|
printf -v "$pgid_name" '%s' "${fields[2]}"
|
|
printf -v "$sid_name" '%s' "${fields[3]}"
|
|
printf -v "$start_name" '%s' "${fields[19]}"
|
|
}
|
|
|
|
demo_start_tick() {
|
|
local state start pgid sid
|
|
demo_read_process_identity "$1" state start pgid sid || return 1
|
|
printf '%s\n' "$start"
|
|
}
|
|
|
|
demo_process_group() {
|
|
local state start pgid sid
|
|
demo_read_process_identity "$1" state start pgid sid || return 1
|
|
printf '%s\n' "$pgid"
|
|
}
|
|
|
|
demo_pid_is_running() {
|
|
local state start pgid sid
|
|
demo_read_process_identity "$1" state start pgid sid && [[ "$state" != Z ]]
|
|
}
|
|
|
|
demo_process_has_command_line() {
|
|
local pid=$1 first
|
|
{ IFS= read -r -d '' first <"/proc/$pid/cmdline"; } 2>/dev/null || return 1
|
|
[[ -n "$first" ]]
|
|
}
|
|
|
|
demo_resolve_command() {
|
|
local value=$1 resolved
|
|
if [[ "$value" == */* ]]; then
|
|
readlink -f -- "$value" 2>/dev/null
|
|
else
|
|
resolved=$(command -v -- "$value" 2>/dev/null) || return 1
|
|
readlink -f -- "$resolved" 2>/dev/null
|
|
fi
|
|
}
|
|
|
|
demo_entry_index() {
|
|
local expected=$1 array_name=$2 argument resolved index
|
|
local -n argv_ref=$array_name
|
|
for index in "${!argv_ref[@]}"; do
|
|
argument=${argv_ref[index]}
|
|
resolved=$(demo_resolve_command "$argument" 2>/dev/null || true)
|
|
if [[ "$resolved" == "$expected" ]]; then printf '%s\n' "$index"; return 0; fi
|
|
done
|
|
return 1
|
|
}
|
|
|
|
demo_interpreter_for_entry() {
|
|
local entry=$1 line interpreter
|
|
IFS= read -r line <"$entry" 2>/dev/null || return 1
|
|
[[ "$line" == '#!'* ]] || return 1
|
|
line=${line#\#!}
|
|
read -r -a interpreter <<<"$line"
|
|
((${#interpreter[@]} > 0)) || return 1
|
|
if [[ ${interpreter[0]} == */env && ${interpreter[1]:-} ]]; then demo_resolve_command "${interpreter[1]}"
|
|
else demo_resolve_command "${interpreter[0]}"; fi
|
|
}
|
|
|
|
demo_has_exact_tail() {
|
|
local array_name=$1 begin=$2
|
|
local -n argv_ref=$array_name
|
|
shift 2
|
|
local -a wanted=("$@")
|
|
local index
|
|
((${#argv_ref[@]} - begin == ${#wanted[@]})) || return 1
|
|
for index in "${!wanted[@]}"; do
|
|
[[ ${argv_ref[begin+index]} == "${wanted[index]}" ]] || return 1
|
|
done
|
|
}
|
|
|
|
demo_command_matches() {
|
|
local root=$1 pid=$2 kind=$3 expected executable interpreter entry_index
|
|
local -a arguments=()
|
|
# Status 2 means /proc became unreadable while identity was being checked.
|
|
# Status 1 remains a definitive command mismatch.
|
|
[[ -r "/proc/$pid/cmdline" && -e "/proc/$pid/exe" ]] || return 2
|
|
{ mapfile -d '' -t arguments <"/proc/$pid/cmdline"; } 2>/dev/null || return 2
|
|
((${#arguments[@]} > 0)) || return 2
|
|
executable=$(readlink -f -- "/proc/$pid/exe" 2>/dev/null) || return 2
|
|
|
|
if [[ "$kind" == anvil ]]; then
|
|
expected=$(demo_resolve_command anvil) || return 1
|
|
elif [[ "$kind" == vite ]]; then
|
|
expected=$(readlink -f -- "$root/web/node_modules/.bin/vite" 2>/dev/null) || return 1
|
|
else
|
|
return 1
|
|
fi
|
|
entry_index=$(demo_entry_index "$expected" arguments) || return 1
|
|
if [[ "$executable" != "$expected" ]]; then
|
|
interpreter=$(demo_interpreter_for_entry "$expected") || return 1
|
|
[[ "$executable" == "$interpreter" && "$entry_index" -eq 1 ]] || return 1
|
|
else
|
|
[[ "$entry_index" -eq 0 ]] || return 1
|
|
fi
|
|
|
|
if [[ "$kind" == anvil ]]; then
|
|
local dev_phrase='test test test test test test test test test test test junk'
|
|
demo_has_exact_tail arguments "$((entry_index + 1))" \
|
|
--host 127.0.0.1 --port 8545 --chain-id 31337 --mnemonic "$dev_phrase"
|
|
else
|
|
demo_has_exact_tail arguments "$((entry_index + 1))" web --host 127.0.0.1 --port 5173
|
|
fi
|
|
}
|
|
|
|
demo_identity_matches() {
|
|
local root=$1 kind=$2 pid=$3 expected_start=$4 expected_pgid=$5 state start pgid sid
|
|
demo_read_process_identity "$pid" state start pgid sid || return 1
|
|
[[ "$state" != Z && "$start" == "$expected_start" && "$pgid" == "$expected_pgid" \
|
|
&& "$sid" == "$expected_pgid" && "$pid" == "$expected_pgid" ]] || return 1
|
|
demo_command_matches "$root" "$pid" "$kind"
|
|
}
|
|
|
|
demo_capture_raw_launch() {
|
|
local pid=$1 start_name=$2 pgid_name=$3 state raw_actual_start raw_actual_pgid sid
|
|
demo_read_process_identity "$pid" state raw_actual_start raw_actual_pgid sid || return 1
|
|
[[ "$state" != Z && "$pid" == "$raw_actual_pgid" && "$pid" == "$sid" ]] || return 1
|
|
printf -v "$start_name" '%s' "$raw_actual_start"
|
|
printf -v "$pgid_name" '%s' "$raw_actual_pgid"
|
|
}
|
|
|
|
demo_capture_process() {
|
|
local root=$1 kind=$2 pid=$3 start_name=$4 pgid_name=$5 actual_start actual_pgid
|
|
demo_capture_raw_launch "$pid" actual_start actual_pgid || return 1
|
|
demo_command_matches "$root" "$pid" "$kind" || return 1
|
|
printf -v "$start_name" '%s' "$actual_start"
|
|
printf -v "$pgid_name" '%s' "$actual_pgid"
|
|
}
|
|
|
|
demo_remove_record() {
|
|
local root=$1 kind=$2 path
|
|
for path in "$root/.demo/$kind.pid" "$root/.demo/$kind.start" "$root/.demo/$kind.pgid"; do
|
|
if [[ -e "$path" ]]; then
|
|
rm -f -- "$path"
|
|
printf 'Removed %s\n' "${path#"$root/"}"
|
|
fi
|
|
done
|
|
}
|
|
|
|
demo_publish_process() {
|
|
local root=$1 kind=$2 pid=$3 start=$4 pgid=$5 path
|
|
demo_is_process_id "$pid" && demo_is_uint "$start" && demo_is_process_id "$pgid" && [[ "$pid" == "$pgid" ]] || return 1
|
|
demo_identity_matches "$root" "$kind" "$pid" "$start" "$pgid" || return 1
|
|
mkdir -p "$root/.demo"
|
|
chmod 0700 "$root/.demo"
|
|
for path in "$root/.demo/$kind.pid" "$root/.demo/$kind.start" "$root/.demo/$kind.pgid"; do [[ ! -e "$path" ]] || return 1; done
|
|
printf '%s\n' "$start" >"$root/.demo/$kind.start"
|
|
printf '%s\n' "$pgid" >"$root/.demo/$kind.pgid"
|
|
chmod 0600 "$root/.demo/$kind.start" "$root/.demo/$kind.pgid"
|
|
demo_identity_matches "$root" "$kind" "$pid" "$start" "$pgid" || return 1
|
|
# PID is the atomic commit marker. PID equals PGID, so a hard link publishes
|
|
# the validated value without a temporary path or separately visible write.
|
|
ln -- "$root/.demo/$kind.pgid" "$root/.demo/$kind.pid" || return 1
|
|
chmod 0600 "$root/.demo/$kind.pid"
|
|
}
|
|
|
|
demo_record_process() {
|
|
local root=$1 kind=$2 pid=$3 start pgid
|
|
demo_capture_process "$root" "$kind" "$pid" start pgid || return 1
|
|
demo_publish_process "$root" "$kind" "$pid" "$start" "$pgid"
|
|
}
|
|
|
|
demo_collect_group_members() {
|
|
local expected_pgid=$1 expected_sid=$2 output_name=$3 pid ps_pgid ps_sid ps_state state start pgid sid
|
|
local -n output_ref=$output_name
|
|
output_ref=()
|
|
while read -r pid ps_pgid ps_sid ps_state; do
|
|
[[ "$ps_pgid" == "$expected_pgid" && "$ps_sid" == "$expected_sid" && "$ps_state" != Z* ]] || continue
|
|
demo_read_process_identity "$pid" state start pgid sid || continue
|
|
[[ "$state" != Z && "$pgid" == "$expected_pgid" && "$sid" == "$expected_sid" ]] || continue
|
|
output_ref+=("$pid:$start")
|
|
done < <(ps -eo pid=,pgid=,sid=,stat=)
|
|
}
|
|
|
|
demo_anchor_allows_signal() {
|
|
local root=$1 kind=$2 leader=$3 expected_start=$4 expected_pgid=$5 identity_mode=${6:-validated}
|
|
local state start pgid sid command_status attempt
|
|
local attempts=${DEMO_ANCHOR_RECHECK_ATTEMPTS:-10} interval=${DEMO_ANCHOR_RECHECK_INTERVAL:-0.01}
|
|
demo_is_uint "$attempts" && ((10#$attempts > 0)) || attempts=10
|
|
[[ "$interval" =~ ^[0-9]+([.][0-9]+)?$ ]] || interval=0.01
|
|
for ((attempt = 0; attempt < attempts; attempt++)); do
|
|
if ! demo_read_process_identity "$leader" state start pgid sid; then return 0; fi
|
|
[[ "$start" == "$expected_start" && "$pgid" == "$expected_pgid" && "$sid" == "$expected_pgid" ]] || return 1
|
|
[[ "$state" == Z ]] && return 0
|
|
[[ "$identity_mode" == raw ]] && return 0
|
|
if demo_command_matches "$root" "$leader" "$kind"; then return 0; else command_status=$?; fi
|
|
((command_status == 2)) || return 1
|
|
if ((attempt + 1 < attempts)); then sleep "$interval"; fi
|
|
done
|
|
return 1
|
|
}
|
|
|
|
demo_signal_member() {
|
|
local pid=$1 expected_start=$2 expected_pgid=$3 expected_sid=$4 signal=$5 state start pgid sid signal_status
|
|
if ! demo_read_process_identity "$pid" state start pgid sid; then return 0; fi
|
|
[[ "$state" != Z ]] || return 0
|
|
[[ "$start" == "$expected_start" && "$pgid" == "$expected_pgid" && "$sid" == "$expected_sid" ]] || return 2
|
|
if kill -"$signal" -- "$pid" 2>/dev/null; then return 0; else signal_status=$?; fi
|
|
if ! demo_read_process_identity "$pid" state start pgid sid; then return 0; fi
|
|
[[ "$state" != Z ]] || return 0
|
|
[[ "$start" == "$expected_start" && "$pgid" == "$expected_pgid" && "$sid" == "$expected_sid" ]] || return 0
|
|
printf 'Failed to signal unchanged live PID %s with %s\n' "$pid" "$signal" >&2
|
|
return "$signal_status"
|
|
}
|
|
|
|
demo_group_has_live_members() {
|
|
local pgid=$1 sid=$2
|
|
local -a members
|
|
demo_collect_group_members "$pgid" "$sid" members
|
|
((${#members[@]} > 0))
|
|
}
|
|
|
|
demo_stop_owned_session() {
|
|
local root=$1 kind=$2 leader=$3 expected_start=$4 expected_pgid=$5 identity_mode=$6 member member_pid member_start result
|
|
local -a members
|
|
[[ "$identity_mode" == validated || "$identity_mode" == raw ]] || return 1
|
|
demo_is_process_id "$leader" && demo_is_uint "$expected_start" && demo_is_process_id "$expected_pgid" \
|
|
&& [[ "$leader" == "$expected_pgid" ]] || return 1
|
|
demo_anchor_allows_signal "$root" "$kind" "$leader" "$expected_start" "$expected_pgid" "$identity_mode" || {
|
|
printf 'Refusing %s PID %s: process identity changed\n' "$kind" "$leader" >&2
|
|
return 1
|
|
}
|
|
demo_collect_group_members "$expected_pgid" "$expected_pgid" members
|
|
if ((${#members[@]} == 0)); then
|
|
demo_remove_record "$root" "$kind"
|
|
return 0
|
|
fi
|
|
|
|
printf 'Stopping validated %s session/process group %s\n' "$kind" "$expected_pgid"
|
|
for member in "${members[@]}"; do
|
|
IFS=: read -r member_pid member_start <<<"$member"
|
|
[[ "$member_pid" != "$leader" ]] || continue
|
|
if ! demo_anchor_allows_signal "$root" "$kind" "$leader" "$expected_start" "$expected_pgid" "$identity_mode"; then
|
|
printf 'Refusing TERM: %s leader identity changed or remained unverifiable\n' "$kind" >&2
|
|
return 1
|
|
fi
|
|
demo_signal_member "$member_pid" "$member_start" "$expected_pgid" "$expected_pgid" TERM || return 1
|
|
done
|
|
for member in "${members[@]}"; do
|
|
IFS=: read -r member_pid member_start <<<"$member"
|
|
[[ "$member_pid" == "$leader" ]] || continue
|
|
if ! demo_anchor_allows_signal "$root" "$kind" "$leader" "$expected_start" "$expected_pgid" "$identity_mode"; then
|
|
printf 'Refusing TERM: %s leader identity changed or remained unverifiable\n' "$kind" >&2
|
|
return 1
|
|
fi
|
|
demo_signal_member "$member_pid" "$member_start" "$expected_pgid" "$expected_pgid" TERM || return 1
|
|
done
|
|
for ((result = 0; result < ${DEMO_TERM_WAIT_ATTEMPTS:-50}; result++)); do
|
|
demo_group_has_live_members "$expected_pgid" "$expected_pgid" || break
|
|
sleep 0.1
|
|
done
|
|
|
|
if demo_group_has_live_members "$expected_pgid" "$expected_pgid"; then
|
|
printf 'Escalating surviving validated %s session members to KILL\n' "$kind"
|
|
for ((result = 0; result < ${DEMO_KILL_WAIT_ATTEMPTS:-20}; result++)); do
|
|
demo_collect_group_members "$expected_pgid" "$expected_pgid" members
|
|
((${#members[@]} > 0)) || break
|
|
for member in "${members[@]}"; do
|
|
IFS=: read -r member_pid member_start <<<"$member"
|
|
if ! demo_anchor_allows_signal "$root" "$kind" "$leader" "$expected_start" "$expected_pgid" "$identity_mode"; then
|
|
printf 'Refusing KILL escalation: %s leader identity changed\n' "$kind" >&2
|
|
return 1
|
|
fi
|
|
if demo_signal_member "$member_pid" "$member_start" "$expected_pgid" "$expected_pgid" KILL; then
|
|
:
|
|
else
|
|
result=$?
|
|
printf 'Refusing KILL escalation: %s member identity changed (%s)\n' "$kind" "$result" >&2
|
|
return 1
|
|
fi
|
|
done
|
|
sleep 0.05
|
|
done
|
|
fi
|
|
wait "$leader" 2>/dev/null || true
|
|
if demo_group_has_live_members "$expected_pgid" "$expected_pgid"; then
|
|
printf 'Validated %s session/process group %s did not stop\n' "$kind" "$expected_pgid" >&2
|
|
return 1
|
|
fi
|
|
demo_remove_record "$root" "$kind"
|
|
}
|
|
|
|
demo_stop_launch() {
|
|
demo_stop_owned_session "$1" "$2" "$3" "$4" "$5" validated
|
|
}
|
|
|
|
demo_stop_raw_launch() {
|
|
demo_stop_owned_session "$1" "$2" "$3" "$4" "$5" raw
|
|
}
|
|
|
|
demo_stop_recorded() {
|
|
local root=$1 kind=$2 pid start pgid
|
|
local pid_path="$root/.demo/$kind.pid" start_path="$root/.demo/$kind.start" pgid_path="$root/.demo/$kind.pgid"
|
|
[[ "$kind" == anvil || "$kind" == vite ]] || return 1
|
|
if [[ ! -e "$pid_path" ]]; then
|
|
if [[ ! -e "$start_path" && ! -e "$pgid_path" ]]; then return 0; fi
|
|
if [[ -e "$start_path" && -e "$pgid_path" ]] && demo_read_one_line "$start_path" start \
|
|
&& demo_read_one_line "$pgid_path" pgid && demo_is_uint "$start" && demo_is_process_id "$pgid"; then
|
|
pid=$pgid
|
|
printf 'Recovering partial %s launch record with validated in-memory shape\n' "$kind"
|
|
else
|
|
printf 'Removing incomplete %s launch metadata without signaling\n' "$kind"
|
|
demo_remove_record "$root" "$kind"
|
|
return 0
|
|
fi
|
|
else
|
|
if ! demo_read_one_line "$pid_path" pid || ! demo_is_process_id "$pid"; then
|
|
printf 'Refusing invalid %s PID record\n' "$kind" >&2
|
|
return 1
|
|
fi
|
|
if ! demo_read_one_line "$start_path" start || ! demo_is_uint "$start"; then
|
|
printf 'Refusing incomplete %s start-tick record\n' "$kind" >&2
|
|
return 1
|
|
fi
|
|
if ! demo_read_one_line "$pgid_path" pgid || ! demo_is_process_id "$pgid"; then
|
|
printf 'Refusing incomplete %s process-group record\n' "$kind" >&2
|
|
return 1
|
|
fi
|
|
fi
|
|
[[ "$pid" == "$pgid" ]] || { printf 'Refusing %s: PID/PGID ownership mismatch\n' "$kind" >&2; return 1; }
|
|
if ! demo_group_has_live_members "$pgid" "$pgid" && [[ ! -e "/proc/$pid/stat" ]]; then
|
|
printf 'Discarding stale %s process record for PID %s\n' "$kind" "$pid"
|
|
demo_remove_record "$root" "$kind"
|
|
return 0
|
|
fi
|
|
demo_stop_launch "$root" "$kind" "$pid" "$start" "$pgid"
|
|
}
|