499 lines
19 KiB
Bash
Executable File
499 lines
19 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# scripts/manual/run_client_to_rct_transport_probe.sh
|
|
# Manual: client-origin bundled transport probe to the RCT UVC/UAC endpoints.
|
|
# Not part of CI; hardware/lab manual only.
|
|
#
|
|
# This runner keeps server->RCT calibration tooling untouched. It starts an
|
|
# RCT capture, injects deterministic flash/tone media through
|
|
# `lesavka-sync-probe`, then measures final sync, freshness, and smoothness from
|
|
# the captured UVC/UAC output.
|
|
|
|
set -euo pipefail
|
|
SCRIPT_DIR="$(cd -- "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
|
|
REPO_ROOT="$(cd -- "${SCRIPT_DIR}/../.." >/dev/null 2>&1 && pwd)"
|
|
TETHYS_HOST=${TETHYS_HOST:-tethys}
|
|
LESAVKA_SERVER_HOST=${LESAVKA_SERVER_HOST:-theia}
|
|
LESAVKA_SERVER_ADDR=${LESAVKA_SERVER_ADDR:-auto}
|
|
LESAVKA_SERVER_SCHEME=${LESAVKA_SERVER_SCHEME:-https}
|
|
LESAVKA_TLS_DOMAIN=${LESAVKA_TLS_DOMAIN:-lesavka-server}
|
|
SERVER_TUNNEL_REMOTE_PORT=${SERVER_TUNNEL_REMOTE_PORT:-50051}
|
|
SSH_OPTS=${SSH_OPTS:-"-o BatchMode=yes -o ConnectTimeout=5"}
|
|
|
|
LESAVKA_CLIENT_RCT_MODE=${LESAVKA_CLIENT_RCT_MODE:-auto}
|
|
REMOTE_CAPTURE_STACK=${REMOTE_CAPTURE_STACK:-pulse}
|
|
REMOTE_PULSE_CAPTURE_TOOL=${REMOTE_PULSE_CAPTURE_TOOL:-gst}
|
|
REMOTE_PULSE_VIDEO_MODE=${REMOTE_PULSE_VIDEO_MODE:-cfr}
|
|
REMOTE_PULSE_AUDIO_ANCHOR_SILENCE=${REMOTE_PULSE_AUDIO_ANCHOR_SILENCE:-1}
|
|
REMOTE_CAPTURE_READY_TIMEOUT_SECONDS=${REMOTE_CAPTURE_READY_TIMEOUT_SECONDS:-30}
|
|
REMOTE_CAPTURE_READY_SETTLE_SECONDS=${REMOTE_CAPTURE_READY_SETTLE_SECONDS:-1}
|
|
REMOTE_CAPTURE_PREROLL_DISCARD_SECONDS=${REMOTE_CAPTURE_PREROLL_DISCARD_SECONDS:-3}
|
|
LESAVKA_CLIENT_RCT_START_DELAY_SECONDS=${LESAVKA_CLIENT_RCT_START_DELAY_SECONDS:-0}
|
|
|
|
PROBE_DURATION_SECONDS=${PROBE_DURATION_SECONDS:-20}
|
|
PROBE_WARMUP_SECONDS=${PROBE_WARMUP_SECONDS:-4}
|
|
PROBE_PULSE_PERIOD_MS=${PROBE_PULSE_PERIOD_MS:-1000}
|
|
PROBE_PULSE_WIDTH_MS=${PROBE_PULSE_WIDTH_MS:-120}
|
|
PROBE_MARKER_TICK_PERIOD=${PROBE_MARKER_TICK_PERIOD:-5}
|
|
PROBE_EVENT_WIDTH_CODES=${PROBE_EVENT_WIDTH_CODES:-1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
|
|
PROBE_START_GRACE_SECONDS=${PROBE_START_GRACE_SECONDS:-12}
|
|
TAIL_SECONDS=${TAIL_SECONDS:-4}
|
|
PROBE_TIMEOUT_SECONDS=${PROBE_TIMEOUT_SECONDS:-$((PROBE_DURATION_SECONDS + PROBE_START_GRACE_SECONDS + TAIL_SECONDS + 20))}
|
|
CAPTURE_SECONDS=${CAPTURE_SECONDS:-$((PROBE_DURATION_SECONDS + PROBE_START_GRACE_SECONDS + TAIL_SECONDS))}
|
|
|
|
LESAVKA_CLIENT_RCT_MAX_AGE_MS=${LESAVKA_CLIENT_RCT_MAX_AGE_MS:-1000}
|
|
LESAVKA_CLIENT_RCT_MIN_PAIRS=${LESAVKA_CLIENT_RCT_MIN_PAIRS:-13}
|
|
LESAVKA_CLIENT_RCT_REQUIRE_SMOOTHNESS=${LESAVKA_CLIENT_RCT_REQUIRE_SMOOTHNESS:-0}
|
|
LESAVKA_CLIENT_RCT_SYNC_SAMPLE_INTERVAL_SECONDS=${LESAVKA_CLIENT_RCT_SYNC_SAMPLE_INTERVAL_SECONDS:-0.5}
|
|
|
|
LOCAL_OUTPUT_DIR=${LOCAL_OUTPUT_DIR:-/tmp}
|
|
STAMP="$(date +%Y%m%d-%H%M%S)"
|
|
LOCAL_REPORT_DIR="${LOCAL_OUTPUT_DIR%/}/lesavka-client-rct-transport-probe-${STAMP}"
|
|
LOCAL_CAPTURE="${LOCAL_REPORT_DIR}/capture.mkv"
|
|
LOCAL_CAPTURE_LOG="${LOCAL_REPORT_DIR}/capture.log"
|
|
LOCAL_REPORT_JSON="${LOCAL_REPORT_DIR}/report.json"
|
|
LOCAL_REPORT_TXT="${LOCAL_REPORT_DIR}/report.txt"
|
|
LOCAL_EVENTS_CSV="${LOCAL_REPORT_DIR}/events.csv"
|
|
LOCAL_CLIENT_TIMELINE_JSON="${LOCAL_REPORT_DIR}/client-transport-timeline.json"
|
|
LOCAL_CLOCK_ALIGNMENT_JSON="${LOCAL_REPORT_DIR}/clock-alignment.json"
|
|
LOCAL_TRANSPORT_SUMMARY_JSON="${LOCAL_REPORT_DIR}/client-rct-transport-summary.json"
|
|
LOCAL_TRANSPORT_SUMMARY_TXT="${LOCAL_REPORT_DIR}/client-rct-transport-summary.txt"
|
|
LOCAL_UPSTREAM_SYNC_JSONL="${LOCAL_REPORT_DIR}/upstream-sync-samples.jsonl"
|
|
LOCAL_UPSTREAM_SYNC_TXT="${LOCAL_REPORT_DIR}/upstream-sync-samples.txt"
|
|
LOCAL_CLIENT_SEND_JSONL="${LOCAL_REPORT_DIR}/client-send-bundles.jsonl"
|
|
LOCAL_UVC_FRAME_META_JSONL="${LOCAL_REPORT_DIR}/uvc-frame-meta.jsonl"
|
|
LOCAL_UVC_FRAME_META_SUMMARY_JSON="${LOCAL_REPORT_DIR}/uvc-frame-meta-summary.json"
|
|
LOCAL_UVC_FRAME_META_SUMMARY_TXT="${LOCAL_REPORT_DIR}/uvc-frame-meta-summary.txt"
|
|
LOCAL_RUN_LOG="${LOCAL_REPORT_DIR}/client-rct-run.log"
|
|
REMOTE_CAPTURE=${REMOTE_CAPTURE:-"/tmp/lesavka-client-rct-transport-probe-${STAMP}.mkv"}
|
|
LESAVKA_CLIENT_RCT_UVC_FRAME_META_LOG_REMOTE=${LESAVKA_CLIENT_RCT_UVC_FRAME_META_LOG_REMOTE:-}
|
|
LESAVKA_CLIENT_RCT_UVC_FRAME_META_LOG_REQUIRED=${LESAVKA_CLIENT_RCT_UVC_FRAME_META_LOG_REQUIRED:-0}
|
|
CAPTURE_READY_MARKER="__LESAVKA_CAPTURE_READY__"
|
|
mkdir -p "${LOCAL_REPORT_DIR}"
|
|
exec > >(tee -a "${LOCAL_RUN_LOG}") 2>&1
|
|
SERVER_TUNNEL_PID=""
|
|
CAPTURE_PID=""
|
|
RESOLVED_LESAVKA_SERVER_ADDR=""
|
|
|
|
cleanup() {
|
|
if [[ -n "${SERVER_TUNNEL_PID}" ]] && kill -0 "${SERVER_TUNNEL_PID}" >/dev/null 2>&1; then
|
|
kill "${SERVER_TUNNEL_PID}" >/dev/null 2>&1 || true
|
|
wait "${SERVER_TUNNEL_PID}" >/dev/null 2>&1 || true
|
|
fi
|
|
}
|
|
trap cleanup EXIT
|
|
|
|
parse_mode() {
|
|
local mode=$1
|
|
if [[ "${mode}" == "auto" ]]; then
|
|
printf '0 0 0\n'
|
|
return 0
|
|
fi
|
|
if [[ "${mode}" =~ ^([0-9]+)x([0-9]+)@([0-9]+)$ ]]; then
|
|
printf '%s %s %s\n' "${BASH_REMATCH[1]}" "${BASH_REMATCH[2]}" "${BASH_REMATCH[3]}"
|
|
return 0
|
|
fi
|
|
echo "invalid LESAVKA_CLIENT_RCT_MODE=${mode}; expected WIDTHxHEIGHT@FPS" >&2
|
|
return 1
|
|
}
|
|
|
|
pick_tunnel_port() {
|
|
python3 - <<'PY'
|
|
import socket
|
|
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
|
|
sock.bind(("127.0.0.1", 0))
|
|
print(sock.getsockname()[1])
|
|
PY
|
|
}
|
|
|
|
wait_for_local_port() {
|
|
local port=$1
|
|
local deadline=$(( $(date +%s) + 15 ))
|
|
until python3 - <<'PY' "${port}"
|
|
import socket
|
|
import sys
|
|
port = int(sys.argv[1])
|
|
try:
|
|
with socket.create_connection(("127.0.0.1", port), timeout=1):
|
|
pass
|
|
except OSError:
|
|
sys.exit(1)
|
|
PY
|
|
do
|
|
if (( $(date +%s) >= deadline )); then
|
|
echo "timed out waiting for localhost:${port}" >&2
|
|
return 1
|
|
fi
|
|
sleep 0.25
|
|
done
|
|
}
|
|
|
|
sleep_start_delay() {
|
|
[[ "${LESAVKA_CLIENT_RCT_START_DELAY_SECONDS}" =~ ^[0-9]+$ ]] || {
|
|
echo "LESAVKA_CLIENT_RCT_START_DELAY_SECONDS must be a non-negative number" >&2
|
|
exit 2
|
|
}
|
|
if (( LESAVKA_CLIENT_RCT_START_DELAY_SECONDS > 0 )); then
|
|
echo "==> delaying client-to-RCT transport probe start for ${LESAVKA_CLIENT_RCT_START_DELAY_SECONDS}s"
|
|
sleep "${LESAVKA_CLIENT_RCT_START_DELAY_SECONDS}"
|
|
fi
|
|
}
|
|
|
|
start_server_tunnel() {
|
|
if [[ "${LESAVKA_SERVER_ADDR}" != "auto" ]]; then
|
|
RESOLVED_LESAVKA_SERVER_ADDR="${LESAVKA_SERVER_ADDR}"
|
|
return 0
|
|
fi
|
|
local local_port
|
|
local_port="$(pick_tunnel_port)"
|
|
echo "==> opening SSH tunnel to ${LESAVKA_SERVER_HOST}:127.0.0.1:${SERVER_TUNNEL_REMOTE_PORT} on localhost:${local_port}"
|
|
ssh ${SSH_OPTS} -o ExitOnForwardFailure=yes \
|
|
-N -L "127.0.0.1:${local_port}:127.0.0.1:${SERVER_TUNNEL_REMOTE_PORT}" \
|
|
"${LESAVKA_SERVER_HOST}" &
|
|
SERVER_TUNNEL_PID=$!
|
|
wait_for_local_port "${local_port}"
|
|
RESOLVED_LESAVKA_SERVER_ADDR="${LESAVKA_SERVER_SCHEME}://127.0.0.1:${local_port}"
|
|
echo " ↪ tunneled to ${LESAVKA_SERVER_HOST}:127.0.0.1:${SERVER_TUNNEL_REMOTE_PORT}"
|
|
}
|
|
|
|
sample_capture_clock_alignment() {
|
|
echo "==> sampling client/Tethys clock alignment for transport freshness"
|
|
python3 "${REPO_ROOT}/scripts/manual/client_rct_clock_alignment.py" \
|
|
"${TETHYS_HOST}" \
|
|
"${SSH_OPTS}" \
|
|
"${LOCAL_CLOCK_ALIGNMENT_JSON}"
|
|
}
|
|
|
|
build_probe_tools() {
|
|
echo "==> prebuilding client transport probe/analyzer"
|
|
(
|
|
cd "${REPO_ROOT}"
|
|
cargo build -p lesavka_client --bin lesavka-sync-probe --bin lesavka-sync-analyze --bin lesavka-relayctl
|
|
)
|
|
}
|
|
|
|
print_versions() {
|
|
echo "==> Lesavka versions under test"
|
|
(
|
|
cd "${REPO_ROOT}"
|
|
LESAVKA_TLS_DOMAIN="${LESAVKA_TLS_DOMAIN}" \
|
|
"${REPO_ROOT}/target/debug/lesavka-relayctl" \
|
|
--server "${RESOLVED_LESAVKA_SERVER_ADDR}" version
|
|
) | sed 's/^/ ↪ /' || true
|
|
}
|
|
|
|
start_tethys_capture() {
|
|
local width=$1 height=$2 fps=$3
|
|
echo "==> starting RCT UVC/UAC capture on ${TETHYS_HOST}"
|
|
ssh ${SSH_OPTS} "${TETHYS_HOST}" bash -s -- \
|
|
"${REMOTE_CAPTURE}" \
|
|
"${CAPTURE_SECONDS}" \
|
|
"${width}" \
|
|
"${height}" \
|
|
"${fps}" \
|
|
"${REMOTE_CAPTURE_STACK}" \
|
|
"${REMOTE_PULSE_CAPTURE_TOOL}" \
|
|
"${REMOTE_PULSE_VIDEO_MODE}" \
|
|
"${REMOTE_PULSE_AUDIO_ANCHOR_SILENCE}" \
|
|
"${REMOTE_CAPTURE_PREROLL_DISCARD_SECONDS}" \
|
|
"${REMOTE_CAPTURE_READY_SETTLE_SECONDS}" \
|
|
"${CAPTURE_READY_MARKER}" \
|
|
>"${LOCAL_CAPTURE_LOG}" 2>&1 <<'REMOTE_CAPTURE_SCRIPT' &
|
|
set -euo pipefail
|
|
remote_capture=$1
|
|
capture_seconds=$2
|
|
width=$3
|
|
height=$4
|
|
fps=$5
|
|
capture_stack=$6
|
|
pulse_tool=$7
|
|
video_mode=$8
|
|
anchor_silence=$9
|
|
preroll_discard=${10}
|
|
ready_settle=${11}
|
|
ready_marker=${12}
|
|
|
|
resolve_video_device() {
|
|
find /dev/v4l/by-id -maxdepth 1 -type l \
|
|
-name 'usb-Lesavka_Lesavka_Composite*video-index0' | sort | head -n 1
|
|
}
|
|
|
|
resolve_pulse_source() {
|
|
pactl list short sources 2>/dev/null \
|
|
| awk '
|
|
/alsa_input\..*Lesavka_Lesavka_Composite/ { print $2; found=1; exit }
|
|
/Lesavka_Lesavka_Composite/ && $2 !~ /\.monitor$/ && !fallback { fallback=$2 }
|
|
END {
|
|
if (found) exit 0
|
|
if (fallback != "") { print fallback; exit 0 }
|
|
exit 1
|
|
}
|
|
'
|
|
}
|
|
|
|
current_video_profile() {
|
|
v4l2-ctl -d "${video_device}" --all 2>/dev/null \
|
|
| awk '
|
|
/Width\/Height[[:space:]]*:/ {
|
|
split($0, a, ":")
|
|
gsub(/^[ \t]+/, "", a[2])
|
|
split(a[2], wh, "/")
|
|
width=wh[1]
|
|
height=wh[2]
|
|
next
|
|
}
|
|
/Frames per second[[:space:]]*:/ {
|
|
split($0, a, ":")
|
|
gsub(/^[ \t]+/, "", a[2])
|
|
split(a[2], fps_parts, "\\.")
|
|
fps=fps_parts[1]
|
|
}
|
|
END {
|
|
if (width && height && fps) {
|
|
printf "%s %s %s\n", width, height, fps
|
|
exit 0
|
|
}
|
|
exit 1
|
|
}
|
|
'
|
|
}
|
|
|
|
gst_audio_mixer_element() {
|
|
if gst-inspect-1.0 audiomixer 2>/dev/null | grep -q 'ignore-inactive-pads'; then
|
|
printf 'audiomixer name=amix ignore-inactive-pads=true'
|
|
else
|
|
printf 'audiomixer name=amix'
|
|
fi
|
|
}
|
|
|
|
run_preroll() {
|
|
local video_device=$1
|
|
local seconds=$2
|
|
[[ "${seconds}" =~ ^[0-9]+$ && "${seconds}" -gt 0 ]] || return 0
|
|
printf 'discarding %ss of post-enumeration capture before probe\n' "${seconds}" >&2
|
|
timeout --kill-after=2 --signal=INT "${seconds}" \
|
|
gst-launch-1.0 -q -e v4l2src device="${video_device}" do-timestamp=true num-buffers="$((fps * seconds))" \
|
|
! "image/jpeg,width=${width},height=${height},framerate=${fps}/1" ! fakesink \
|
|
>/dev/null 2>&1 || true
|
|
}
|
|
|
|
run_gst_pulse_capture() {
|
|
local video_device=$1
|
|
local pulse_source=$2
|
|
local video_caps="image/jpeg,width=${width},height=${height},framerate=${fps}/1"
|
|
local decode_chain="jpegdec !"
|
|
local audio_mixer
|
|
audio_mixer="$(gst_audio_mixer_element)"
|
|
local audio_anchor=()
|
|
if [[ "${anchor_silence}" != "0" ]]; then
|
|
printf 'anchoring Pulse capture audio timeline with generated silence\n' >&2
|
|
audio_anchor=(audiotestsrc wave=silence is-live=true do-timestamp=true ! "audio/x-raw,rate=48000,channels=2" ! queue ! amix.)
|
|
fi
|
|
printf 'capture_start_unix_ns=%s\n' "$(date +%s%N)" >&2
|
|
if [[ "${video_mode}" == "cfr" ]]; then
|
|
timeout --kill-after=5 --signal=INT "$((capture_seconds + 3))" \
|
|
gst-launch-1.0 -q -e \
|
|
matroskamux name=mux ! filesink location="${remote_capture}" \
|
|
v4l2src device="${video_device}" do-timestamp=true ! ${video_caps} ! \
|
|
${decode_chain} videoconvert ! videorate ! video/x-raw,framerate="${fps}"/1 ! \
|
|
x264enc tune=zerolatency speed-preset=ultrafast key-int-max=1 bitrate=5000 ! \
|
|
h264parse ! queue ! mux. \
|
|
${audio_mixer} ! audio/x-raw,rate=48000,channels=2 ! queue ! mux. \
|
|
"${audio_anchor[@]}" \
|
|
pulsesrc device="${pulse_source}" do-timestamp=true ! audio/x-raw,rate=48000,channels=2 ! \
|
|
audioconvert ! audioresample ! audio/x-raw,rate=48000,channels=2 ! queue ! amix. &
|
|
else
|
|
timeout --kill-after=5 --signal=INT "$((capture_seconds + 3))" \
|
|
gst-launch-1.0 -q -e \
|
|
matroskamux name=mux ! filesink location="${remote_capture}" \
|
|
v4l2src device="${video_device}" do-timestamp=true ! ${video_caps} ! queue ! mux. \
|
|
${audio_mixer} ! audio/x-raw,rate=48000,channels=2 ! queue ! mux. \
|
|
"${audio_anchor[@]}" \
|
|
pulsesrc device="${pulse_source}" do-timestamp=true ! audio/x-raw,rate=48000,channels=2 ! \
|
|
audioconvert ! audioresample ! audio/x-raw,rate=48000,channels=2 ! queue ! amix. &
|
|
fi
|
|
local capture_pid=$!
|
|
sleep "${ready_settle}"
|
|
printf '%s\n' "${ready_marker}" >&2
|
|
wait "${capture_pid}"
|
|
}
|
|
|
|
rm -f "${remote_capture}"
|
|
video_device="$(resolve_video_device)"
|
|
if [[ -z "${video_device}" ]]; then
|
|
printf 'Lesavka UVC video device not found on RCT host; refusing unrelated capture devices.\n' >&2
|
|
exit 2
|
|
fi
|
|
if [[ "${width}" == "0" || "${height}" == "0" || "${fps}" == "0" ]]; then
|
|
if read -r width height fps < <(current_video_profile); then
|
|
:
|
|
else
|
|
printf 'unable to auto-detect current UVC mode; set LESAVKA_CLIENT_RCT_MODE=WIDTHxHEIGHT@FPS\n' >&2
|
|
exit 2
|
|
fi
|
|
fi
|
|
printf 'using video device: %s\n' "${video_device}" >&2
|
|
printf 'using video mode: %sx%s @ %s fps (mjpeg)\n' "${width}" "${height}" "${fps}" >&2
|
|
|
|
case "${capture_stack}" in
|
|
pulse)
|
|
if [[ "${pulse_tool}" != "gst" ]]; then
|
|
printf 'unsupported REMOTE_PULSE_CAPTURE_TOOL=%s for client-to-RCT probe; use gst\n' "${pulse_tool}" >&2
|
|
exit 2
|
|
fi
|
|
pulse_source="$(resolve_pulse_source)"
|
|
if [[ -z "${pulse_source}" ]]; then
|
|
printf 'Lesavka Pulse audio source not found; refusing timing-sensitive fallback.\n' >&2
|
|
exit 2
|
|
fi
|
|
printf 'using Pulse source: %s\n' "${pulse_source}" >&2
|
|
run_preroll "${video_device}" "${preroll_discard}"
|
|
run_gst_pulse_capture "${video_device}" "${pulse_source}"
|
|
;;
|
|
*)
|
|
printf 'unsupported REMOTE_CAPTURE_STACK=%s for client-to-RCT probe\n' "${capture_stack}" >&2
|
|
exit 2
|
|
;;
|
|
esac
|
|
REMOTE_CAPTURE_SCRIPT
|
|
CAPTURE_PID=$!
|
|
}
|
|
|
|
wait_for_capture_ready() {
|
|
local deadline=$(( $(date +%s) + REMOTE_CAPTURE_READY_TIMEOUT_SECONDS ))
|
|
until grep -q "${CAPTURE_READY_MARKER}" "${LOCAL_CAPTURE_LOG}" 2>/dev/null; do
|
|
if ! kill -0 "${CAPTURE_PID}" >/dev/null 2>&1; then
|
|
wait "${CAPTURE_PID}" || true
|
|
echo "RCT capture failed before the client probe could start; see ${LOCAL_CAPTURE_LOG}" >&2
|
|
exit 90
|
|
fi
|
|
if (( $(date +%s) >= deadline )); then
|
|
echo "timed out waiting for RCT capture readiness; see ${LOCAL_CAPTURE_LOG}" >&2
|
|
exit 90
|
|
fi
|
|
sleep 0.25
|
|
done
|
|
}
|
|
|
|
run_client_sync_probe() {
|
|
echo "==> running client-origin bundled transport probe against ${RESOLVED_LESAVKA_SERVER_ADDR}"
|
|
(
|
|
cd "${REPO_ROOT}"
|
|
LESAVKA_TLS_DOMAIN="${LESAVKA_TLS_DOMAIN}" \
|
|
LESAVKA_SYNC_PROBE_SEND_LOG="${LOCAL_CLIENT_SEND_JSONL}" \
|
|
timeout --signal=INT "${PROBE_TIMEOUT_SECONDS}" \
|
|
"${REPO_ROOT}/target/debug/lesavka-sync-probe" \
|
|
--server "${RESOLVED_LESAVKA_SERVER_ADDR}" \
|
|
--duration-seconds "${PROBE_DURATION_SECONDS}" \
|
|
--warmup-seconds "${PROBE_WARMUP_SECONDS}" \
|
|
--pulse-period-ms "${PROBE_PULSE_PERIOD_MS}" \
|
|
--pulse-width-ms "${PROBE_PULSE_WIDTH_MS}" \
|
|
--marker-tick-period "${PROBE_MARKER_TICK_PERIOD}" \
|
|
--event-width-codes "${PROBE_EVENT_WIDTH_CODES}" \
|
|
--timeline-json "${LOCAL_CLIENT_TIMELINE_JSON}"
|
|
)
|
|
}
|
|
|
|
run_client_sync_probe_with_sampler() {
|
|
run_client_sync_probe &
|
|
local probe_pid=$!
|
|
python3 "${REPO_ROOT}/scripts/manual/client_rct_upstream_sync_sampler.py" \
|
|
"${REPO_ROOT}/target/debug/lesavka-relayctl" \
|
|
"${RESOLVED_LESAVKA_SERVER_ADDR}" \
|
|
"${LESAVKA_TLS_DOMAIN}" \
|
|
"${probe_pid}" \
|
|
"${LESAVKA_CLIENT_RCT_SYNC_SAMPLE_INTERVAL_SECONDS}" \
|
|
"${LOCAL_UPSTREAM_SYNC_JSONL}" \
|
|
"${LOCAL_UPSTREAM_SYNC_TXT}" &
|
|
local sampler_pid=$!
|
|
local probe_status=0
|
|
wait "${probe_pid}" || probe_status=$?
|
|
wait "${sampler_pid}" || true
|
|
return "${probe_status}"
|
|
}
|
|
|
|
fetch_and_analyze_capture() {
|
|
echo "==> fetching RCT capture back to ${LOCAL_CAPTURE}"
|
|
scp ${SSH_OPTS} "${TETHYS_HOST}:${REMOTE_CAPTURE}" "${LOCAL_CAPTURE}"
|
|
echo "==> analyzing RCT capture"
|
|
local analyze_args=("${LOCAL_CAPTURE}" --report-dir "${LOCAL_REPORT_DIR}")
|
|
if [[ -n "${PROBE_EVENT_WIDTH_CODES}" ]]; then
|
|
analyze_args+=(--event-width-codes "${PROBE_EVENT_WIDTH_CODES}")
|
|
fi
|
|
(
|
|
cd "${REPO_ROOT}"
|
|
"${REPO_ROOT}/target/debug/lesavka-sync-analyze" "${analyze_args[@]}"
|
|
)
|
|
}
|
|
|
|
write_transport_summary() {
|
|
python3 "${REPO_ROOT}/scripts/manual/client_rct_transport_summary.py" \
|
|
"${LOCAL_REPORT_JSON}" \
|
|
"${LOCAL_CLIENT_TIMELINE_JSON}" \
|
|
"${LOCAL_CAPTURE_LOG}" \
|
|
"${LOCAL_CLOCK_ALIGNMENT_JSON}" \
|
|
"${LOCAL_CAPTURE}" \
|
|
"${LOCAL_TRANSPORT_SUMMARY_JSON}" \
|
|
"${LOCAL_TRANSPORT_SUMMARY_TXT}" \
|
|
"${LESAVKA_CLIENT_RCT_MAX_AGE_MS}" \
|
|
"${LESAVKA_CLIENT_RCT_MIN_PAIRS}" \
|
|
"${LESAVKA_CLIENT_RCT_REQUIRE_SMOOTHNESS}"
|
|
}
|
|
|
|
fetch_and_summarize_uvc_frame_meta_log() {
|
|
SSH_OPTS="${SSH_OPTS}" "${REPO_ROOT}/scripts/manual/client_rct_uvc_frame_meta_fetch.sh" \
|
|
"${LESAVKA_SERVER_HOST}" \
|
|
"${LESAVKA_CLIENT_RCT_UVC_FRAME_META_LOG_REMOTE}" \
|
|
"${LESAVKA_CLIENT_RCT_UVC_FRAME_META_LOG_REQUIRED}" \
|
|
"${LOCAL_UVC_FRAME_META_JSONL}" \
|
|
"${LOCAL_UVC_FRAME_META_SUMMARY_JSON}" \
|
|
"${LOCAL_UVC_FRAME_META_SUMMARY_TXT}" \
|
|
"${LOCAL_CLIENT_TIMELINE_JSON}" \
|
|
"${MODE_FPS}" \
|
|
"${REPO_ROOT}"
|
|
}
|
|
|
|
read -r MODE_WIDTH MODE_HEIGHT MODE_FPS < <(parse_mode "${LESAVKA_CLIENT_RCT_MODE}")
|
|
|
|
echo "==> client-to-RCT bundled transport probe"
|
|
echo " ↪ mode=${LESAVKA_CLIENT_RCT_MODE}"
|
|
echo " ↪ capture_stack=${REMOTE_CAPTURE_STACK} pulse_tool=${REMOTE_PULSE_CAPTURE_TOOL} video_mode=${REMOTE_PULSE_VIDEO_MODE}"
|
|
echo " ↪ server_addr=${LESAVKA_SERVER_ADDR}"
|
|
echo " ↪ max_client_to_rct_age_ms=${LESAVKA_CLIENT_RCT_MAX_AGE_MS}"
|
|
echo " ↪ start_delay=${LESAVKA_CLIENT_RCT_START_DELAY_SECONDS}s"
|
|
echo " ↪ uvc_frame_meta_log_remote=${LESAVKA_CLIENT_RCT_UVC_FRAME_META_LOG_REMOTE:-disabled}"
|
|
echo " ↪ artifact_dir=${LOCAL_REPORT_DIR}"
|
|
echo " ↪ run_log=${LOCAL_RUN_LOG}"
|
|
echo " ↪ no remote sudo/reconfigure will be attempted by this script"
|
|
|
|
sleep_start_delay
|
|
start_server_tunnel
|
|
build_probe_tools
|
|
print_versions
|
|
sample_capture_clock_alignment
|
|
start_tethys_capture "${MODE_WIDTH}" "${MODE_HEIGHT}" "${MODE_FPS}"
|
|
wait_for_capture_ready
|
|
sleep 1
|
|
run_client_sync_probe_with_sampler
|
|
|
|
capture_status=0
|
|
wait "${CAPTURE_PID}" || capture_status=$?
|
|
if [[ "${capture_status}" -ne 0 && "${capture_status}" -ne 124 ]]; then
|
|
echo "RCT capture exited with status ${capture_status}; see ${LOCAL_CAPTURE_LOG}" >&2
|
|
exit "${capture_status}"
|
|
fi
|
|
|
|
fetch_and_analyze_capture
|
|
write_transport_summary
|
|
fetch_and_summarize_uvc_frame_meta_log
|
|
|
|
echo "==> done"
|
|
printf '%s\n' \
|
|
"artifact_dir: ${LOCAL_REPORT_DIR}" "capture: ${LOCAL_CAPTURE}" \
|
|
"report_json: ${LOCAL_REPORT_JSON}" "report_txt: ${LOCAL_REPORT_TXT}" \
|
|
"events_csv: ${LOCAL_EVENTS_CSV}" "client_timeline_json: ${LOCAL_CLIENT_TIMELINE_JSON}" \
|
|
"clock_alignment_json: ${LOCAL_CLOCK_ALIGNMENT_JSON}" "transport_summary_json: ${LOCAL_TRANSPORT_SUMMARY_JSON}" \
|
|
"transport_summary_txt: ${LOCAL_TRANSPORT_SUMMARY_TXT}" "upstream_sync_jsonl: ${LOCAL_UPSTREAM_SYNC_JSONL}" \
|
|
"upstream_sync_txt: ${LOCAL_UPSTREAM_SYNC_TXT}" "client_send_jsonl: ${LOCAL_CLIENT_SEND_JSONL}" \
|
|
"uvc_frame_meta_jsonl: ${LOCAL_UVC_FRAME_META_JSONL}" "uvc_frame_meta_summary_json: ${LOCAL_UVC_FRAME_META_SUMMARY_JSON}" \
|
|
"uvc_frame_meta_summary_txt: ${LOCAL_UVC_FRAME_META_SUMMARY_TXT}" "run_log: ${LOCAL_RUN_LOG}"
|