From d61c99cdbc2a04b01041744a57a2c55b7e27459a Mon Sep 17 00:00:00 2001 From: kzolotarev95 Date: Fri, 16 Oct 2026 01:29:25 +0400 Subject: [PATCH] Fix Xray recovery after reboot with persistent boot cache --- files/usr/sbin/owrt-remote | 348 +++++++++++++++++++++++++++++---- install.sh | 4 +- tests/XRAY_BOOT.md | 95 +++++++++ tests/test_xray_boot_deploy.py | 130 ++++++++++++ tests/test_xray_bootstrap.py | 334 +++++++++++++++++++++++++++++++ vps/deploy-xray-boot-fix.ps1 | 138 +++++++++++++ 6 files changed, 1004 insertions(+), 45 deletions(-) create mode 100644 tests/XRAY_BOOT.md create mode 100644 tests/test_xray_boot_deploy.py create mode 100644 tests/test_xray_bootstrap.py create mode 100644 vps/deploy-xray-boot-fix.ps1 diff --git a/files/usr/sbin/owrt-remote b/files/usr/sbin/owrt-remote index e0f4055..075c3b3 100644 --- a/files/usr/sbin/owrt-remote +++ b/files/usr/sbin/owrt-remote @@ -23,6 +23,7 @@ usage() { owrt-remote status owrt-remote doctor owrt-remote install-xray-tmp + owrt-remote prepare-xray owrt-remote stop-xray owrt-remote render-client [--stdout] owrt-remote run @@ -1482,24 +1483,239 @@ doctor() { fi } -# Override Xray bootstrap with boot-safe retry logic. -fetch_file() { - local url dst - url="$1" - dst="$2" - rm -f "$dst" - if command -v curl >/dev/null 2>&1 && curl -fsSL "$url" -o "$dst"; then - return 0 - fi - if command -v uclient-fetch >/dev/null 2>&1 && uclient-fetch -q -O "$dst" "$url"; then - return 0 - fi - if command -v wget >/dev/null 2>&1 && wget -q -O "$dst" "$url"; then - return 0 - fi - rm -f "$dst" - return 1 +# Keep the executable in RAM, but retain one compressed, verified boot copy. +# Cache writes happen only when the executable changes, never per Heartbeat. +xray_runtime_dir() { printf '%s' "${OWRT_REMOTE_XRAY_RUNTIME:-/tmp/owrt-xray}"; } +xray_process_start() { awk '{print $22}' "/proc/$1/stat" 2>/dev/null; } +xray_process_identity() { + local rest + read -r XRAY_SELF_PID rest /dev/null; do + [ -d "$XRAY_LOCK" ] || return 1 + owner=''; current='' + read -r owner current <"$XRAY_LOCK/owner" 2>/dev/null || true + saved="$owner $current" + case "$owner:$current" in + *[!0-9:]*|:*|*:) current=''; [ "$attempt" -lt 5 ] || current=stale ;; + *) [ "$(xray_process_start "$owner")" = "$current" ] || current=stale ;; + esac + if [ "$current" = stale ]; then xray_bootstrap_reap "$saved" "$attempt"; fi + attempt=$((attempt+1)); [ "$attempt" -lt 150 ] || { log 'Xray: загрузчик уже работает; повтор будет выполнен позже'; return 1; } + sleep 1 + done + printf '%s %s\n' "$XRAY_SELF_PID" "$XRAY_SELF_BIRTH" >"$XRAY_LOCK/owner" || { rmdir "$XRAY_LOCK" 2>/dev/null || true; return 1; } +} +xray_bootstrap_reap() { + local owner current saved + saved="$1" + if mkdir "$XRAY_LOCK/reap" 2>/dev/null; then + printf '%s %s\n' "$XRAY_SELF_PID" "$XRAY_SELF_BIRTH" >"$XRAY_LOCK/reap/owner" + # Re-read after claiming reaping: another waiter may have acquired + # a new lock since our first observation of the dead process. + owner=''; current=''; read -r owner current <"$XRAY_LOCK/owner" 2>/dev/null || true + if [ "$saved" = "$owner $current" ]; then rm -f "$XRAY_LOCK/owner"; fi + rm -f "$XRAY_LOCK/reap/owner"; rmdir "$XRAY_LOCK/reap"; rmdir "$XRAY_LOCK" 2>/dev/null || true + return 0 + fi + # A SIGKILL during reaping must not leave a permanent bootstrap lock. + owner=''; current=''; read -r owner current <"$XRAY_LOCK/reap/owner" 2>/dev/null || true + case "$owner:$current" in + *[!0-9:]*|:*|*:) [ "$2" -ge 10 ] || return 0 ;; + *) [ "$(xray_process_start "$owner")" != "$current" ] || return 0 ;; + esac + rm -f "$XRAY_LOCK/reap/owner"; rmdir "$XRAY_LOCK/reap" 2>/dev/null || true +} +xray_bootstrap_unlock() { rm -f "$XRAY_LOCK/owner"; rmdir "$XRAY_LOCK" 2>/dev/null || true; } +xray_cache_mount() { + local path + path="$1" + while [ ! -e "$path" ]; do path="$(dirname "$path")"; done + path="$(readlink -f "$path")" || return 1 + awk -v path="$path" ' + (path == $2 || index(path, $2 "/") == 1 || $2 == "/") && length($2) > best { + best=length($2); mount=$2; fs=$3; flags=$4 + } + END { if (best) print mount, fs, flags; else exit 1 } + ' /proc/mounts +} +xray_cache_dir() { + local mount fs flags candidate + read -r mount fs flags </dev/null)" || return 1 + digest="${digest%% *}" + case "$digest" in ''|*[!0-9a-f]*) return 1 ;; esac + [ "${#digest}" = 64 ] || return 1 + printf '%s' "$digest" +} +xray_cache_save() ( + # A subshell already isolates these variables (BusyBox ash rejects local here). + bin="$1" + [ -s "$bin" ] && [ -x "$bin" ] || return 1 + "$bin" version >/dev/null 2>&1 || return 1 + store="$(xray_cache_dir)" || { log 'Xray: постоянный кэш недоступен; после перезагрузки потребуется загрузка из сети'; return 1; } + asset="$(xray_release_asset)" || return 1 + digest="$(xray_digest "$bin")" || return 1 + target="$store/$asset.$digest.gz" + # An existing valid copy requires no Flash writes, including after reboot. + if [ -s "$target" ] && gzip -t "$target" 2>/dev/null; then return 0; fi + umask 077 + mkdir -p "$store" || return 1 + chmod 700 "$store" || return 1 + # Writers hold bootstrap-lock; only incomplete staging files are disposable. + rm -f "$store"/.new.* + free="$(df -Pk "$store" | awk 'NR==2 { print $4 }')" + case "$free" in ''|*[!0-9]*) return 1 ;; esac + # Size is measured by streaming compression, without a second RAM copy. + size="$(gzip -c "$bin" | wc -c)" + case "$size" in ''|*[!0-9]*) return 1 ;; esac + if [ "$size" -le 0 ] || [ "$size" -gt 16777216 ] || [ "$free" -lt "$(( (size+1023)/1024 + 2048 ))" ]; then + log 'Xray: недостаточно места для постоянного кэша с резервом 2 МиБ; рабочий Xray сохранён' + return 1 + fi + temp="$(mktemp "$store/.new.XXXXXX")" || return 1 + trap 'rm -f "$temp"' EXIT + trap 'exit 1' INT TERM + gzip -c "$bin" >"$temp" && gzip -t "$temp" || return 1 + [ "$(wc -c <"$temp")" -le 16777216 ] || return 1 + mv -f "$temp" "$target" || return 1 + # Once per binary update: commit the replacement before deleting the last + # bootable copy. No Flash sync is performed by Heartbeat or normal startup. + sync || return 1 + # Only after publishing the replacement may the previous copy be removed. + for old in "$store"/Xray-*.zip.*.gz; do [ "$old" = "$target" ] || rm -f "$old"; done + log "Xray: сжатая загрузочная копия сохранена на постоянном разделе; bytes=$(wc -c <"$target")" +) +xray_cache_restore() ( + store="$(xray_cache_dir)" || return 1 + asset="$(xray_release_asset)" || return 1 + dir="$(xray_runtime_dir)"; mkdir -p "$dir" || return 1 + temp="$(mktemp "$dir/.restore.XXXXXX")" || return 1 + trap 'rm -f "$temp"' EXIT + trap 'exit 1' INT TERM + for cache in "$store/$asset."*.gz; do + [ -s "$cache" ] || continue + [ "$(wc -c <"$cache")" -le 16777216 ] || continue + digest="${cache#"$store/$asset."}"; digest="${digest%.gz}" + case "$digest" in ''|*[!0-9a-f]*) continue ;; esac + [ "${#digest}" = 64 ] || continue + # Bound even an invalid compressed file; verify bytes before execution. + gzip -t "$cache" 2>/dev/null || { log 'Xray: повреждён постоянный кэш; требуется повторная загрузка'; continue; } + gzip -dc "$cache" | head -c 67108865 >"$temp" + size="$(wc -c <"$temp")" + [ "$size" -le 67108864 ] && [ "$(xray_digest "$temp")" = "$digest" ] || continue + chmod 755 "$temp" && "$temp" version >/dev/null 2>&1 || continue + mv -f "$temp" "$dir/xray" || return 1 + if [ "$(uci_get xray_bin '')" != "$dir/xray" ]; then + uci set "$CONFIG.$SECTION.xray_bin=$dir/xray" && uci commit "$CONFIG" || return 1 + fi + log 'Xray: восстановлен из постоянного кэша без загрузки из интернета' + return 0 + done + return 1 +) + +# Keep a finite wait even without BusyBox's optional timeout applet. The +# foreground poll avoids a racing/orphaned watchdog when downloads finish fast. +xray_native_fetch() ( + dst="$1"; shift + client='' + trap 'result=$?; [ -z "$client" ] || { kill -KILL "$client" 2>/dev/null || true; wait "$client" 2>/dev/null || true; }; [ "$result" = 0 ] || rm -f "$dst"' EXIT + trap 'exit 1' INT TERM + # Shells report file blocks in 512 or 1024 bytes: either limit stays <=32 MiB. + ulimit -f 32768 || return 1 + "$@" & client=$! + ticks=0 + while kill -0 "$client" 2>/dev/null; do + if [ "$ticks" -ge 120 ]; then + kill -KILL "$client" 2>/dev/null || true + wait "$client" 2>/dev/null || true + client=''; return 28 + fi + sleep 1; ticks=$((ticks+1)) + done + rc=0; wait "$client" || rc=$?; client='' + return "$rc" +) + +# Bound one complete download, including redirects. In WAN mode use the +# selected resolver on every HTTPS hop, retaining hostname verification/SNI. +fetch_file() ( + url="$1"; dst="$2"; rm -f "$dst" + stats='' + trap 'result=$?; rm -f "$stats"; [ "$result" = 0 ] || rm -f "$dst"' EXIT + trap 'exit 1' INT TERM + unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY all_proxy ALL_PROXY + if command -v curl >/dev/null 2>&1; then + stats="$(mktemp "${TMPDIR:-/tmp}/owrt-xray-http.XXXXXX")" || return 1 + started="$(remote_clock_ms)"; hop=0; rc=1 + while [ "$hop" -le 5 ]; do + origin="$(remote_url_origin "$url")" || return 3 + case "$origin" in https://*) ;; *) log 'Xray: отклонена загрузка без HTTPS'; return 3 ;; esac + set -- -q -fsS --connect-timeout 10 --noproxy '*' --proto '=https' --max-filesize 33554432 + if truthy "$(uci_get wan_direct 0)"; then + host="${origin#https://}"; port="${host##*:}"; host="${host%:*}" + device="$(wan_device)" || return 1 + ip="$(wan_resolve_host "$host")" || return 6 + set -- "$@" --interface "$device" --resolve "$host:$port:$ip" + fi + remaining=$((120000 - $(remote_clock_ms) + started)) + [ "$remaining" -gt 0 ] || return 28 + remaining="$(LC_ALL=C awk -v ms="$remaining" 'BEGIN { printf "%.3f", ms/1000 }')" + rc=0 + curl "$@" --max-time "$remaining" -o "$dst" -w '%{http_code} %{redirect_url}\n' "$url" >"$stats" || rc=$? + [ "$rc" = 0 ] || return "$rc" + code=''; redirect=''; read -r code redirect <"$stats" || true + case "$code" in + 301|302|303|307|308) rc=47; [ -n "$redirect" ] || return 47; url="$redirect"; hop=$((hop+1)) ;; + 200) [ -s "$dst" ] || { rc=1; return 1; }; return 0 ;; + *) rc=22; return 22 ;; + esac + done + return 47 + fi + # Minimal images without curl keep bounded native HTTPS clients. These do + # not offer curl's per-host resolver override. + if truthy "$(uci_get wan_direct 0)"; then log 'Xray: curl отсутствует; загрузчик использует системный DNS'; fi + rc=1 + case "$url" in https://*) ;; *) return 3 ;; esac + if command -v uclient-fetch >/dev/null 2>&1; then + xray_native_fetch "$dst" uclient-fetch -q -T 15 -O "$dst" "$url" && rc=0 + elif command -v wget >/dev/null 2>&1; then + xray_native_fetch "$dst" wget -q -T 15 -O "$dst" "$url" && rc=0 + fi + [ "$rc" = 0 ] && [ -s "$dst" ] && [ "$(wc -c <"$dst")" -le 33554432 ] +) install_package() { local pkg @@ -1550,9 +1766,14 @@ ensure_fetch_tool() { return 1 } -install_xray_tmp() { - local dir zip asset url version entry candidates - dir="/tmp/owrt-xray" +install_xray_tmp() ( + xray_bootstrap_lock || return 1 + trap 'xray_bootstrap_unlock' EXIT + trap 'exit 1' INT TERM + install_xray_tmp_locked +) +install_xray_tmp_locked() ( + dir="$(xray_runtime_dir)" zip="$dir/xray.zip" asset="$(xray_release_asset)" || { log "unknown Xray asset for $(uname -m 2>/dev/null)" @@ -1560,7 +1781,12 @@ install_xray_tmp() { } url="$XRAY_RELEASE_BASE_URL/$asset" - mkdir -p /var/lock /var/run "$dir" + mkdir -p "$dir" || return 1 + # An interrupted previous download is disposable; the working binary and + # compressed boot copy are never removed before a candidate is validated. + rm -f "$dir/xray.zip.new" "$dir/xray.new" + trap 'rm -f "$dir/xray.zip.new" "$dir/xray.new"' EXIT + trap 'exit 1' INT TERM if ! command -v unzip >/dev/null 2>&1; then install_package unzip || { log "cannot install unzip" @@ -1573,17 +1799,17 @@ install_xray_tmp() { return 1 } - printf 'Skachivayu Xray: %s\n' "$asset" - rm -f "$zip" "$dir/xray" "$dir/xray_softfloat" - fetch_file "$url" "$zip" || { - log "cannot download Xray: $url" + log "Xray: загрузка $asset; общий тайм-аут=120s" + fetch_file "$url" "$zip.new" || { + log "Xray: не удалось загрузить $asset; рабочий бинарник и кэш сохранены" return 1 } - [ -s "$zip" ] || { + [ -s "$zip.new" ] || { log "downloaded Xray archive is empty: $zip" - rm -f "$zip" return 1 } + mv -f "$zip.new" "$zip" || return 1 + unzip -t "$zip" >/dev/null 2>&1 || { log 'Xray: архив не прошёл проверку целостности; рабочий бинарник сохранён'; return 1; } candidates="xray" case "$(xray_arch)" in @@ -1593,17 +1819,19 @@ install_xray_tmp() { esac for entry in $candidates; do - ( cd "$dir" && unzip -o "$zip" "$entry" >/dev/null ) || continue - [ -s "$dir/$entry" ] || continue - chmod +x "$dir/$entry" - version="$("$dir/$entry" version 2>&1)" || { - rm -f "$dir/$entry" + # Extract only the named executable, never arbitrary paths from the ZIP. + unzip -p "$zip" "$entry" 2>/dev/null | head -c 67108865 >"$dir/xray.new" + [ -s "$dir/xray.new" ] || continue + [ "$(wc -c <"$dir/xray.new")" -le 67108864 ] || continue + chmod 755 "$dir/xray.new" + version="$("$dir/xray.new" version 2>&1)" || { + rm -f "$dir/xray.new" continue } version="$(printf '%s\n' "$version" | sed -n '1p')" - - uci set "$CONFIG.$SECTION.xray_bin=$dir/$entry" - uci commit "$CONFIG" + mv -f "$dir/xray.new" "$dir/$entry" || return 1 + uci set "$CONFIG.$SECTION.xray_bin=$dir/$entry" && uci commit "$CONFIG" || return 1 + xray_cache_save "$dir/$entry" || true printf 'OK: Xray installed in %s\n' "$dir/$entry" printf 'OK: %s\n' "$version" printf 'OK: xray_bin saved in /etc/config/owrtremote\n' @@ -1611,14 +1839,15 @@ install_xray_tmp() { done log "downloaded Xray does not start" - rm -f "$dir/xray" "$dir/xray_softfloat" return 1 -} +) ensure_xray_available() { local configured candidate found configured="$(uci_get xray_bin /usr/bin/xray)" - [ -x "$configured" ] && return 0 + if [ -x "$configured" ]; then + return 0 + fi for candidate in /usr/bin/xray /usr/bin/xray-core /usr/local/bin/xray /opt/bin/xray /tmp/owrt-xray/xray /tmp/owrt-xray/xray_softfloat /tmp/xray /tmp/xray_softfloat; do if [ -x "$candidate" ]; then @@ -1640,20 +1869,50 @@ ensure_xray_available() { return 0 fi - log "Xray missing ($configured), reinstalling temporary Xray in /tmp..." - install_xray_tmp + prepare_xray_tmp } +prepare_xray_tmp() ( + xray_bootstrap_lock || return 1 + trap 'xray_bootstrap_unlock' EXIT + trap 'exit 1' INT TERM + # Recheck after acquiring the lock: a concurrent installer may have finished. + configured="$(uci_get xray_bin /usr/bin/xray)" + [ ! -x "$configured" ] || return 0 + xray_cache_restore && return 0 + log 'Xray: загрузочной копии нет; требуется загрузка из сети' + install_xray_tmp_locked +) +prepare_xray() ( + ensure_xray_available || return 1 + bin="$(xray_bin_path)" + case "$bin" in + /tmp/*|"$(xray_runtime_dir)"/*) + xray_bootstrap_lock || return 1 + trap 'xray_bootstrap_unlock' EXIT + trap 'exit 1' INT TERM + xray_cache_save "$bin" || log 'Xray: запускается из RAM; автономное восстановление после перезагрузки пока недоступно' + ;; + esac +) ensure_xray_available_with_retry() { - local attempts delay try_num + local attempts delay try_num managed attempts="${1:-18}" delay="${2:-10}" try_num=1 - while [ "$try_num" -le "$attempts" ]; do + managed="${OWRT_REMOTE_SERVICE_LOG:-0}" + while [ "$try_num" -le "$attempts" ] || [ "$managed" = 1 ]; do + if [ "$managed" = 1 ]; then + truthy "$(uci_get enabled 0)" || return 1 + wait_for_selected_wan || return 1 + fi if ensure_xray_available; then return 0 fi - [ "$try_num" -ge "$attempts" ] && break + if [ "$try_num" -ge "$attempts" ]; then + [ "$managed" = 1 ] || break + delay=60 + fi log "Xray is not ready yet, retry in ${delay}s (${try_num}/${attempts})" sleep "$delay" try_num=$((try_num + 1)) @@ -1726,6 +1985,9 @@ case "$cmd" in install-xray-tmp) install_xray_tmp ;; + prepare-xray) + prepare_xray + ;; stop-xray) stop_xray ;; diff --git a/install.sh b/install.sh index 40ef8f6..359466c 100644 --- a/install.sh +++ b/install.sh @@ -210,8 +210,8 @@ install_xray_runtime() { [ "${ROOT%/}" = "" ] || return 0 remote_bin="$(target_path usr/sbin/owrt-remote)" [ -x "$remote_bin" ] || die "missing $remote_bin after install" - info "Installing Xray to /tmp..." - "$remote_bin" install-xray-tmp || die "failed to install Xray to /tmp" + info "Preparing Xray and its persistent boot cache..." + "$remote_bin" prepare-xray || die "failed to prepare Xray" } # Stop the old log writer before replacing its storage code. Its bounded legacy diff --git a/tests/XRAY_BOOT.md b/tests/XRAY_BOOT.md new file mode 100644 index 0000000..c8be058 --- /dev/null +++ b/tests/XRAY_BOOT.md @@ -0,0 +1,95 @@ +# Восстановление Xray после перезагрузки (локальный фикс v117) + +В предоставленном журнале node-3 после перезагрузки отсутствовал +`/tmp/owrt-xray/xray`. Повторная загрузка завершилась +`curl: (6) Could not resolve host: github.com`. Heartbeat использует отдельный +процесс и продолжал поступать: статус «онлайн» не подтверждает работу туннеля. +В этой ситуации перезапуск Hub не восстанавливает отсутствующий Xray. + +## Изменения клиента + +- Исполняемый Xray остаётся в RAM. После установки/обновления сохраняется одна + сжатая загрузочная копия на проверенном постоянном разделе: + `/overlay/owrt-remote/xray-cache`, либо `/etc/owrt-remote/xray-cache` при + непосредственно смонтированном записываемом ext4/UBIFS и подобных ФС. + Несмонтированный `/overlay`, tmpfs, read-only и перенаправление каталога + симлинком на RAM не принимаются. +- Кэш ограничен 16 МиБ; при создании сохраняется резерв минимум 2 МиБ. + Неизменный бинарник не переписывается. Новый файл публикуется атомарным + переименованием на том же разделе; предыдущая копия удаляется после этого. + При нехватке места Xray продолжает работать, но автономное восстановление + после перезагрузки недоступно — это явно записывается в журнал. +- При запуске сначала проверяется кэш для архитектуры устройства. До исполнения + проверяются gzip, SHA-256 распакованных байтов и размер до 64 МиБ. Изменение + конфигурации UCI ограничено путём `xray_bin`; клиентский JSON не заменяется + загрузчиком. +- Без кэша выполняется HTTPS-загрузка. Для curl ограничены время подключения + (10 секунд), общий бюджет HTTP-загрузки (120 секунд), размер (32 МиБ) + и число перенаправлений (5). При WAN direct каждый HTTPS-хост, включая + хост загружаемого файла после редиректа GitHub, разрешается через выбранный + WAN DNS. Проверка сертификата и исходное имя TLS сохраняются. Системный DNS, + настройки Podkop и правила маршрутизации не меняются. +- Без curl минимальные HTTPS-загрузчики используют системный DNS, собственный + тайм-аут и отдельный ограничитель времени на shell. Он не зависит от наличия + необязательного BusyBox `timeout` и убирает дочерние процессы после завершения. + В таком режиме нет переопределения DNS для отдельного хоста. +- Рабочий бинарник сохраняется при ошибке сети, пустом/повреждённом ZIP или + неработающем кандидате. ZIP проверяется до замены; извлекается только + именованный исполняемый файл. Загрузчики сериализованы блокировкой в RAM. +- Управляемый procd процесс после первых 18 неудач продолжает попытки раз в + 60 секунд, пока Remote включён. Ожидание WAN не расходует попытки запуска. + Ручные вызовы сохраняют конечное число попыток. +- `install.sh` вызывает `prepare-xray`: использует существующий рабочий Xray + и подготавливает кэш. Кнопка явной установки Xray по-прежнему загружает релиз. + +Запись кэша — однократное изменение Flash при изменении бинарника. Heartbeat +не сжимает Xray и не записывает кэш при каждом запросе. + +## Установка из PowerShell Windows 11 + +Нужен рабочий SSH-доступ именно к целевому роутеру: локальная сеть, отдельный +VPN или восстановленный SSH-туннель. IP `192.168.2.1` — основной роутер +пользователя; это не адрес удалённого node-3. + +```powershell +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-xray-boot-fix.ps1" -Router "root@192.168.2.1" -Action Install +``` + +Скрипт заменяет только `/usr/sbin/owrt-remote`, сохраняет первую резервную +копию в `/root/owrt-remote-backup-before-xray-boot-v117`, подготавливает кэш, +перезагружает отдельный Heartbeat instance и запрашивает запуск Xray, если +тот остановлен при работающем Heartbeat. Здоровый туннель не перезапускается. +`XRAY_BOOT_ROUTER_Install_OK` подтверждает установку кода, а не установление +обратного соединения: готовность туннеля проверяется по карточке и журналу VPS. + +Откат возвращает предыдущий агент; рабочий бинарник, кэш и конфигурация +сохраняются. При отсутствии полной резервной копии ничего не заменяется. + +```powershell +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-xray-boot-fix.ps1" -Router "root@192.168.2.1" -Action Rollback +``` + +## Ограничение восстановления node-3 + +Старый установленный клиент не выполняет команды из Heartbeat. Если доступна +только VPS, а обратные Админка/SSH не работают, этот фикс пока нельзя установить +на node-3. Старый загрузчик может восстановиться сам, если доступность DNS/GitHub +вернётся. В противном случае нужен отдельный доступ к роутеру или человек рядом. +Публикация исходников и обновление только Hub не устанавливают новый клиент. + +## Проверки + +`tests/test_xray_bootstrap.py`: очистка RAM с сохранением Flash и восстановление +без сети; отсутствие повторной записи; повреждённый gzip/SHA-256; неудачная +загрузка и некорректный ZIP с сохранением работающего Xray; ограничения места, +проверка ФС, редиректы с WAN DNS, тайм-аут и очистка файлов, продолжение попыток, +конкурентный запуск и восстановление устаревших блокировок. + +`tests/test_xray_boot_deploy.py`: повторная установка, первый backup, откат, +неполная копия/плохой shell, восстановление после ошибки, сохранение здорового +туннеля и запуск только остановленного instance. + +Прогоны выполняются POSIX shell и BusyBox ash на Windows. Проверка Linux +`/proc` и конкурентных процессов выполняется в MSYS; busybox-w32 не предоставляет +Linux `/proc`, поэтому этот адаптер подменяется в его тестах. Проверка на +физическом AX3000T после настоящей перезагрузки ещё необходима. diff --git a/tests/test_xray_boot_deploy.py b/tests/test_xray_boot_deploy.py new file mode 100644 index 0000000..4f0d628 --- /dev/null +++ b/tests/test_xray_boot_deploy.py @@ -0,0 +1,130 @@ +"""Installation/rollback of the Xray boot fix in an isolated filesystem.""" +import json +import os +from pathlib import Path +import shlex +import subprocess +import tempfile +import unittest + +from test_xray_mobile_deploy import SH, GIT_BIN, ROOT + + +class XrayBootDeploymentTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(prefix='xray-boot-deploy-') + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.target = self.root / 'agent' + self.original = b'#!/bin/sh\necho previous-agent\n' + self.target.write_bytes(self.original) + self.backup = self.root / 'backup' + self.config = self.root / 'client.json' + self.config.write_text('keep working config') + self.cache = self.root / 'cache.gz' + self.cache.write_bytes(b'keep working cache') + self.env = {**os.environ, 'PATH': str(GIT_BIN) + os.pathsep + os.environ['PATH'], + 'TEST_ROOT': self.root.as_posix()} + source = (ROOT / 'vps/deploy-xray-boot-fix.ps1').read_text(encoding='utf-8') + self.script = source.split("$RemoteScript = @'\n", 1)[1].split("\n'@", 1)[0] + self.script = self.script.replace('target=/usr/sbin/owrt-remote', 'target=' + shlex.quote(self.target.as_posix())) + self.script = self.script.replace('backup_dir=/root/owrt-remote-backup-before-xray-boot-v117', + 'backup_dir=' + shlex.quote(self.backup.as_posix())) + + def deploy(self, action='Install', bad=False, fail_verify=False, fail_prepare=False, + fail_signal=False, stopped=False, xray_running=True): + stage = self.root / 'stage' + stage.mkdir() + if action == 'Install': + text = '''#!/bin/sh +# xray_cache_restore() +# xray_bootstrap_lock() +[ "${TEST_PREPARE_FAIL:-0}" = 0 ] || exit 6 +echo "$1" >>"$TEST_ROOT/prepared" +''' + if bad: text = '#!/bin/sh\nif true; then\n' + (stage / 'agent').write_text(text, encoding='utf-8', newline='\n') + self.root.joinpath('pid').write_text('' if stopped else '101') + script = self.script.replace('stage=/tmp/__UPLOAD_NAME__', 'stage=' + shlex.quote(stage.as_posix())) + script = script.replace('__UPLOAD_NAME__', 'sandbox').replace('__ACTION__', action) + if fail_verify: script = script.replace('cmp "$source_file" "$target"', 'false') + mocks = r''' +ubus() { + echo "$*" >>"$TEST_ROOT/ubus" + if [ "$3" = signal ]; then + [ "${TEST_SIGNAL_FAIL:-0}" = 0 ] || return 1 + echo 202 >"$TEST_ROOT/pid" + fi + echo '{}' +} +jsonfilter() { + cat >/dev/null + case "$2" in + *.heartbeat.pid) cat "$TEST_ROOT/pid" ;; + *.heartbeat.running) [ -z "$(cat "$TEST_ROOT/pid")" ] || printf true ;; + *.xray.running) printf '%s' "$TEST_XRAY_RUNNING" ;; + esac + return 0 +} +uci() { echo 1; } +sleep() { :; } +''' + result = subprocess.run([SH], input=mocks + '\n' + script, capture_output=True, encoding='utf-8', + env={**self.env, 'TEST_PREPARE_FAIL': str(int(fail_prepare)), + 'TEST_SIGNAL_FAIL': str(int(fail_signal)), + 'TEST_XRAY_RUNNING': str(xray_running).lower()}, timeout=30) + self.assertFalse(stage.exists()) + self.assertFalse(list(self.root.glob('*.new-sandbox'))) + self.assertEqual(self.config.read_text(), 'keep working config') + self.assertEqual(self.cache.read_bytes(), b'keep working cache') + return result + + def test_install_twice_and_rollback_preserve_first_backup(self): + for _ in range(2): + result = self.deploy() + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn('XRAY_BOOT_ROUTER_Install_OK', result.stdout) + self.assertEqual((self.backup / 'agent').read_bytes(), self.original) + result = self.deploy('Rollback') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(self.target.read_bytes(), self.original) + + def test_rejected_shell_and_missing_backup_leave_agent_untouched(self): + for action, bad in (('Install', True), ('Rollback', False)): + result = self.deploy(action, bad=bad) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(self.target.read_bytes(), self.original) + self.assertFalse(self.backup.exists()) + + def test_healthy_tunnel_is_not_restarted(self): + result = self.deploy() + self.assertEqual(result.returncode, 0, result.stderr) + calls = (self.root / 'ubus').read_text() + self.assertIn('"instance":"heartbeat"', calls) + self.assertNotIn('service add', calls) + self.assertNotIn('"instance":"xray"', calls) + + def test_stopped_tunnel_recovery_registers_only_xray(self): + result = self.deploy(xray_running=False) + self.assertEqual(result.returncode, 0, result.stderr) + calls = (self.root / 'ubus').read_text().splitlines() + request = next(line.split('service add ', 1)[1] for line in calls if 'service add ' in line) + self.assertEqual(set(json.loads(request)['instances']), {'xray'}) + + def test_explicitly_stopped_service_stays_stopped(self): + result = self.deploy(stopped=True, xray_running=False) + self.assertEqual(result.returncode, 0, result.stderr) + calls = (self.root / 'ubus').read_text() + self.assertNotIn('service signal', calls) + self.assertNotIn('service add', calls) + + def test_failed_verification_or_preparation_or_reload_restore_agent(self): + for failure in ('fail_verify', 'fail_prepare', 'fail_signal'): + result = self.deploy(**{failure: True}) + self.assertNotEqual(result.returncode, 0) + self.assertNotIn('XRAY_BOOT_ROUTER_Install_OK', result.stdout) + self.assertIn('Restoring the agent', result.stderr) + self.assertEqual(self.target.read_bytes(), self.original) + + +if __name__ == '__main__': unittest.main() diff --git a/tests/test_xray_bootstrap.py b/tests/test_xray_bootstrap.py new file mode 100644 index 0000000..4a17fc2 --- /dev/null +++ b/tests/test_xray_bootstrap.py @@ -0,0 +1,334 @@ +"""Reboot recovery, safe installation and bounded Xray downloads; no router required. + +OWRT_TEST_BUSYBOX selects real BusyBox ash and its built-in applets. +""" +import gzip +import hashlib +import os +from pathlib import Path +import shlex +import subprocess +import unittest +import zipfile + +import test_host_policy as base + + +class XrayBootstrapTests(unittest.TestCase): + config = base.RouterShellTests.config + + def setUp(self): + base.RouterShellTests.setUp(self) + self.runtime = self.directory / 'runtime' + self.runtime.mkdir() + self.store = self.directory / 'flash' + self.binary = self.runtime / 'xray' + self.config(enabled='1', wan_direct='0', xray_bin=self.binary.as_posix()) + self.env['OWRT_REMOTE_XRAY_RUNTIME'] = self.runtime.as_posix() + self.env['PATH'] = str(Path(base.SH).parent) + os.pathsep + os.environ['PATH'] + self.mocks = r''' +xray_cache_dir() { printf '%s' "$TEST_ROOT/flash"; } +xray_release_asset() { printf Xray-linux-arm64-v8a.zip; } +xray_arch() { printf aarch64; } +ensure_ca_certificates() { return 0; } +ensure_fetch_tool() { return 0; } +''' + if os.name == 'nt': + # Windows shells cannot impose Linux RLIMIT_FSIZE. Assert the + # requested ceiling while testing downloader/watchdog separately. + self.mocks += r''' +ulimit() { [ "$1 $2" = '-f 32768' ]; } +''' + if os.environ.get('OWRT_TEST_BUSYBOX') and os.name == 'nt': + # busybox-w32 has no Linux /proc. Real Linux process identities are + # exercised separately by MSYS, including two concurrent installers. + self.mocks += r''' +xray_process_identity() { XRAY_SELF_PID=$$; XRAY_SELF_BIRTH=1; } +xray_process_start() { [ "$1" != "$$" ] || printf 1; } +''' + + def shell(self, commands, mocks='', **env): + shell = os.environ.get('OWRT_TEST_BUSYBOX', base.SH) + args = [shell, 'ash'] if 'busybox' in shell.lower() else [shell] + script = self.directory / 'run.sh' + script.write_text(self.agent + '\n' + base.MOCKS + '\n' + self.mocks + '\n' + mocks + '\n' + commands, + encoding='utf-8', newline='\n') + return subprocess.run(args + [script.as_posix()], capture_output=True, encoding='utf-8', + env={**self.env, **env}, timeout=40) + + def make_binary(self, text='Xray test version'): + data = f'#!/bin/sh\ncase "$1" in version) echo "{text}" ;; *) exit 0 ;; esac\n'.encode() + self.binary.write_bytes(data) + self.binary.chmod(0o755) + return data + + def cache(self, data=None): + data = data or self.make_binary() + self.store.mkdir(exist_ok=True) + path = self.store / ('Xray-linux-arm64-v8a.zip.' + hashlib.sha256(data).hexdigest() + '.gz') + path.write_bytes(gzip.compress(data)) + return path + + def assert_clean(self): + self.assertFalse((self.runtime / 'bootstrap-lock').exists()) + self.assertFalse(list(self.runtime.glob('*.new'))) + self.assertFalse(list(self.runtime.glob('.restore.*'))) + + def test_reboot_restores_verified_cache_without_network_or_flash_rewrite(self): + data = self.make_binary() + result = self.shell('prepare_xray') + self.assertEqual(result.returncode, 0, result.stderr) + cached = list(self.store.glob('*.gz')) + self.assertEqual(len(cached), 1) + before = cached[0].stat().st_mtime_ns + self.binary.unlink() # /tmp disappears on reboot; Flash survives. + result = self.shell('ensure_xray_available', mocks='fetch_file() { echo forbidden-network >&2; return 99; }') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(self.binary.read_bytes(), data) + self.assertEqual(cached[0].stat().st_mtime_ns, before) + self.assertIn('без загрузки из интернета', result.stderr) + self.assert_clean() + + def test_unchanged_binary_does_not_rewrite_flash(self): + self.make_binary() + self.assertEqual(self.shell('prepare_xray').returncode, 0) + cached = next(self.store.glob('*.gz')) + before = cached.stat().st_mtime_ns + result = self.shell('prepare_xray') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(cached.stat().st_mtime_ns, before) + self.assertNotIn('копия сохранена', result.stderr) + self.assert_clean() + + def test_corrupt_or_wrong_digest_cache_is_never_executed(self): + cached = self.cache() + self.binary.unlink() + cached.write_bytes(b'broken gzip') + result = self.shell('ensure_xray_available', mocks='fetch_file() { return 6; }') + self.assertNotEqual(result.returncode, 0) + self.assertFalse(self.binary.exists()) + cached.write_bytes(gzip.compress(b'#!/bin/sh\ntouch "$TEST_ROOT/executed"\n')) + result = self.shell('ensure_xray_available', mocks='fetch_file() { return 6; }') + self.assertNotEqual(result.returncode, 0) + self.assertFalse((self.directory / 'executed').exists()) + self.assert_clean() + + def test_download_failure_preserves_working_binary_and_cache(self): + data = self.make_binary() + cached = self.cache(data) + result = self.shell('install_xray_tmp', mocks='fetch_file() { echo partial >"$2"; return 6; }') + self.assertNotEqual(result.returncode, 0) + self.assertEqual(self.binary.read_bytes(), data) + self.assertEqual(gzip.decompress(cached.read_bytes()), data) + self.assert_clean() + + def test_invalid_zip_preserves_working_binary_and_cache(self): + data = self.make_binary() + cached = self.cache(data) + result = self.shell('install_xray_tmp', mocks='fetch_file() { echo invalid >"$2"; }') + self.assertNotEqual(result.returncode, 0) + self.assertEqual(self.binary.read_bytes(), data) + self.assertTrue(cached.exists()) + self.assert_clean() + + def test_successful_install_validates_then_caches_one_copy(self): + old = self.make_binary('old') + cached = self.cache(old) + new = self.make_binary('new') + self.binary.write_bytes(old) + with zipfile.ZipFile(self.directory / 'release.zip', 'w') as archive: + archive.writestr('xray', new) + archive.writestr('../should-not-extract', 'no') + result = self.shell('install_xray_tmp', mocks='fetch_file() { cp "$TEST_ROOT/release.zip" "$2"; }') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(self.binary.read_bytes(), new) + self.assertFalse(cached.exists()) + self.assertEqual(len(list(self.store.glob('*.gz'))), 1) + self.assertFalse((self.directory / 'should-not-extract').exists()) + self.assert_clean() + + def test_full_or_unmounted_flash_never_breaks_existing_xray(self): + self.make_binary() + for mock in ('xray_cache_dir() { return 1; }', + 'df() { printf "Filesystem blocks used available capacity mount\\nflash 100 99 1 99%% /overlay\\n"; }'): + result = self.shell('prepare_xray', mocks=mock) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertTrue(self.binary.exists()) + self.assertFalse(list(self.store.glob('*.gz'))) + self.assert_clean() + + def test_mount_detection_rejects_tmpfs_readonly_and_unmounted_overlay(self): + # Call the real selector, without creating any system directories. + selector = self.agent.split('xray_cache_dir() {', 1)[1].split('\nxray_digest()', 1)[0] + selector = 'xray_cache_dir() {' + selector + for mount, fs, flags, expected in ( + ('/overlay', 'ubifs', 'rw,relatime', '/overlay/owrt-remote/xray-cache'), + ('/overlay', 'tmpfs', 'rw', None), + ('/overlay', 'ubifs', 'ro', None), + ('/', 'overlay', 'rw', None), + ('/', 'ext4', 'rw', '/etc/owrt-remote/xray-cache'), + ): + result = self.shell('xray_cache_dir', mocks=selector + '\nxray_cache_mount() { printf "%s\\n" ' + + shlex.quote(f'{mount} {fs} {flags}') + '; }') + self.assertEqual(result.returncode == 0, expected is not None, result.stderr) + if expected: self.assertEqual(result.stdout, expected) + + def test_managed_bootstrap_survives_attempt_limit_but_stops_when_disabled(self): + mocks = r''' +ensure_xray_available() { tries=$((tries+1)); [ "$tries" -ge 4 ]; } +wait_for_selected_wan() { return 0; } +sleep() { printf '%s\n' "$1" >>"$TEST_ROOT/delays"; } +''' + result = self.shell('tries=0; ensure_xray_available_with_retry 2 10; echo tries=$tries', mocks=mocks, + OWRT_REMOTE_SERVICE_LOG='1') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn('tries=4', result.stdout) + self.assertEqual((self.directory / 'delays').read_text().splitlines(), ['10', '60', '60']) + self.config(enabled='0') + result = self.shell('ensure_xray_available_with_retry', mocks=mocks, OWRT_REMOTE_SERVICE_LOG='1') + self.assertNotEqual(result.returncode, 0) + + def test_manual_attempt_limit_is_finite(self): + result = self.shell('tries=0; ensure_xray_available_with_retry 2 0; rc=$?; echo tries=$tries; exit "$rc"', + mocks='ensure_xray_available() { tries=$((tries+1)); return 6; }; sleep() { :; }', + OWRT_REMOTE_SERVICE_LOG='0') + self.assertNotEqual(result.returncode, 0) + self.assertIn('tries=2', result.stdout) + + def test_stale_lock_and_abandoned_reaper_are_recovered(self): + lock = self.runtime / 'bootstrap-lock' + (lock / 'reap').mkdir(parents=True) + (lock / 'owner').write_text('999999 123\n') + (lock / 'reap/owner').write_text('999998 456\n') + self.cache() + self.binary.unlink() + result = self.shell('ensure_xray_available') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertTrue(self.binary.exists()) + self.assert_clean() + + @unittest.skipIf(os.name == 'nt' and bool(os.environ.get('OWRT_TEST_BUSYBOX')), + 'busybox-w32 has no /proc process identities; exercised with MSYS') + def test_two_concurrent_preparations_download_once_and_release_lock(self): + data = self.make_binary() + self.binary.unlink() + with zipfile.ZipFile(self.directory / 'release.zip', 'w') as archive: + archive.writestr('xray', data) + script = self.directory / 'parallel.sh' + script.write_text(self.agent + '\n' + base.MOCKS + '\n' + self.mocks + r''' +fetch_file() { echo download >>"$TEST_ROOT/downloads"; sleep 2; cp "$TEST_ROOT/release.zip" "$2"; } +ensure_xray_available +''', encoding='utf-8', newline='\n') + processes = [subprocess.Popen([base.SH, script.as_posix()], env=self.env, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, encoding='utf-8') for _ in range(2)] + try: + for process in processes: + out, err = process.communicate(timeout=25) + self.assertEqual(process.returncode, 0, err) + finally: + for process in processes: + if process.poll() is None: process.kill(); process.wait() + self.assertEqual((self.directory / 'downloads').read_text().splitlines(), ['download']) + self.assertEqual(self.binary.read_bytes(), data) + self.assert_clean() + + CURL_MOCK = r''' +remote_clock_ms() { printf 1000; } +wan_device() { printf wan; } +wan_resolve_host() { echo "$1" >>"$TEST_ROOT/resolved"; printf 192.0.2.42; } +curl() { + local output previous arg url + printf '%s\n' "$*" >>"$TEST_ROOT/fetches" + [ "${http_proxy-unset}|${https_proxy-unset}" = 'unset|unset' ] || return 90 + previous='' + for arg in "$@"; do [ "$previous" != -o ] || output="$arg"; previous="$arg"; url="$arg"; done + case "$url" in + https://github.com/*) + echo redirect-body >"$output" + printf '302 %s\n' "${TEST_REDIRECT:-https://release-assets.githubusercontent.com/test.zip}" ;; + *) echo archive >"$output"; printf '200 \n' ;; + esac +} +''' + + def test_each_download_redirect_uses_wan_dns_and_keeps_tls_verification(self): + self.config(wan_direct='1') + result = self.shell('fetch_file https://github.com/XTLS/release.zip "$TEST_ROOT/download"', + mocks=self.CURL_MOCK, http_proxy='', https_proxy='') + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual((self.directory / 'resolved').read_text().splitlines(), + ['github.com', 'release-assets.githubusercontent.com']) + calls = (self.directory / 'fetches').read_text().splitlines() + for call, host in zip(calls, ('github.com', 'release-assets.githubusercontent.com')): + self.assertIn('--connect-timeout 10', call) + self.assertIn('--max-time 120.000', call) + self.assertIn('--resolve ' + host + ':443:192.0.2.42', call) + self.assertIn('--interface wan', call) + self.assertNotIn('--insecure', call) + self.assertNotIn(' -L ', call) + self.assertFalse(list(self.directory.glob('owrt-xray-http.*'))) + + def test_download_rejects_insecure_redirect_and_cleans_partial_body(self): + result = self.shell('fetch_file https://github.com/test "$TEST_ROOT/download"', mocks=self.CURL_MOCK, + TEST_REDIRECT='http://release-assets.githubusercontent.com/test.zip') + self.assertNotEqual(result.returncode, 0) + self.assertFalse((self.directory / 'download').exists()) + self.assertEqual(len((self.directory / 'fetches').read_text().splitlines()), 1) + + def test_download_timeout_removes_partial_data_and_preserves_error(self): + result = self.shell('fetch_file https://github.com/test "$TEST_ROOT/download"', mocks=r''' +curl() { local arg previous; previous=''; for arg in "$@"; do [ "$previous" != -o ] || echo partial >"$arg"; previous="$arg"; done; return 28; } +''') + self.assertEqual(result.returncode, 28, result.stderr) + self.assertFalse((self.directory / 'download').exists()) + self.assertFalse(list(self.directory.glob('owrt-xray-http.*'))) + + def test_native_fetch_works_without_optional_timeout_applet(self): + mocks = r''' +command() { + if [ "$1" = -v ]; then + case "$2" in curl|timeout) return 1 ;; uclient-fetch) return 0 ;; esac + fi + builtin command "$@" +} +uclient-fetch() { + local previous arg + previous='' + for arg in "$@"; do [ "$previous" != -O ] || printf archive >"$arg"; previous="$arg"; done +} +''' + result = self.shell('fetch_file https://github.com/test "$TEST_ROOT/download"', mocks=mocks) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual((self.directory / 'download').read_text(), 'archive') + + def test_native_deadline_kills_client_and_removes_partial_file(self): + result = self.shell('xray_native_fetch "$TEST_ROOT/partial" slow_client', mocks=r''' +slow_client() { while :; do :; done; } +sleep() { return 0; } +''') + self.assertEqual(result.returncode, 28, result.stderr) + self.assertFalse((self.directory / 'partial').exists()) + + @unittest.skipIf(os.name == 'nt' and bool(os.environ.get('OWRT_TEST_BUSYBOX')), + 'busybox-w32 has no /proc; watchdog child identities tested in MSYS') + def test_native_client_is_reaped_after_success_or_failure(self): + result = self.shell(r''' +client() { + read -r pid rest >"$TEST_ROOT/clients" + command sleep 1 + printf data >"$TEST_ROOT/download" + return "${TEST_CLIENT_RC:-0}" +} +xray_native_fetch "$TEST_ROOT/download" client +''') + self.assertEqual(result.returncode, 0, result.stderr) + for name in ('clients',): + pids = (self.directory / name).read_text().splitlines() + check = self.shell('\n'.join('if kill -0 ' + pid + ' 2>/dev/null; then exit 1; fi' for pid in pids) + '\ntrue') + self.assertEqual(check.returncode, 0, name + ' still alive: ' + check.stderr) + result = self.shell('xray_native_fetch "$TEST_ROOT/partial" false') + self.assertNotEqual(result.returncode, 0) + + +if __name__ == '__main__': unittest.main() diff --git a/vps/deploy-xray-boot-fix.ps1 b/vps/deploy-xray-boot-fix.ps1 new file mode 100644 index 0000000..81d30c0 --- /dev/null +++ b/vps/deploy-xray-boot-fix.ps1 @@ -0,0 +1,138 @@ +param( + [ValidateNotNullOrEmpty()][string]$Router = 'root@192.168.2.1', + [ValidateSet('Install', 'Rollback')][string]$Action = 'Install', + [switch]$PrepareOnly +) + +$ErrorActionPreference = 'Stop' +$RepoRoot = Split-Path -Parent $PSScriptRoot +$UploadName = 'owrt-xray-boot-' + [guid]::NewGuid().ToString('N') +$StageRoot = Join-Path ([System.IO.Path]::GetTempPath()) $UploadName +$Utf8 = [System.Text.UTF8Encoding]::new($false) +$RemoteScript = @' +#!/bin/sh +set -eu +stage=/tmp/__UPLOAD_NAME__ +target=/usr/sbin/owrt-remote +backup_dir=/root/owrt-remote-backup-before-xray-boot-v117 +changed=0 +phase=preflight +heartbeat_pid() { + local state + state=$(ubus call service list '{"name":"owrt-remote"}') || return 1 + printf '%s' "$state" | jsonfilter -e '@["owrt-remote"].instances.heartbeat.pid' || true +} +refresh_heartbeat() { + local old_pid new_pid attempt + old_pid=$(heartbeat_pid) || return 1 + case "$old_pid" in ''|0) echo 'Heartbeat stopped; it stays stopped.'; return 0 ;; *[!0-9]*) return 1 ;; esac + ubus call service signal '{"name":"owrt-remote","instance":"heartbeat","signal":9}' >/dev/null || return 1 + attempt=0 + while [ "$attempt" -lt 20 ]; do + sleep 1 + new_pid=$(heartbeat_pid) || return 1 + case "$new_pid" in ''|0|*[!0-9]*) ;; *) [ "$new_pid" = "$old_pid" ] || return 0 ;; esac + attempt=$((attempt+1)) + done + return 1 +} +recover_stopped_xray() { + local state running heartbeat enabled + enabled=$(uci -q get owrtremote.main.enabled || true) + case "$enabled" in 1|yes|true|on|enabled) ;; *) return 0 ;; esac + state=$(ubus call service list '{"name":"owrt-remote"}') || return 1 + running=$(printf '%s' "$state" | jsonfilter -e '@["owrt-remote"].instances.xray.running' || true) + heartbeat=$(printf '%s' "$state" | jsonfilter -e '@["owrt-remote"].instances.heartbeat.running' || true) + [ "$running" != true ] && [ "$heartbeat" = true ] || return 0 + ubus call service add '{"name":"owrt-remote","instances":{"xray":{"command":["/usr/sbin/owrt-remote","run"],"env":{"OWRT_REMOTE_SERVICE_LOG":"1"},"respawn":["3600","5","5"],"stdout":true,"stderr":true}}}' >/dev/null +} +cleanup() { + code=$? + trap - EXIT + if [ "$code" -ne 0 ]; then + printf 'Failed during %s (rc=%s).\n' "$phase" "$code" >&2 + if [ "$changed" = 1 ]; then + echo 'Restoring the agent from this attempt. Working Xray/configuration retained.' >&2 + if cp -p "$stage/previous" "$target.new-__UPLOAD_NAME__" && mv -f "$target.new-__UPLOAD_NAME__" "$target"; then + refresh_heartbeat || echo 'Heartbeat reload failed; retained backup remains available.' >&2 + fi + fi + fi + rm -f "$target.new-__UPLOAD_NAME__" + rm -rf "$stage" + exit "$code" +} +trap cleanup EXIT +trap 'exit 1' INT TERM +test -s "$target" +command -v ubus >/dev/null +command -v jsonfilter >/dev/null +heartbeat_pid >/dev/null +if [ '__ACTION__' = Install ]; then + test -s "$stage/agent" + sh -n "$stage/agent" + grep -Fq 'xray_cache_restore()' "$stage/agent" + grep -Fq 'xray_bootstrap_lock()' "$stage/agent" + command -v gzip >/dev/null + command -v sha256sum >/dev/null + if [ ! -e "$backup_dir" ]; then + mkdir -p "$stage/retained" + chmod 700 "$stage/retained" + cp -p "$target" "$stage/retained/agent" + : >"$stage/retained/complete" + mv "$stage/retained" "$backup_dir" + fi + test -f "$backup_dir/complete" && test -s "$backup_dir/agent" || { echo 'Incomplete backup. Nothing changed.' >&2; exit 1; } + source_file=$stage/agent +else + test -f "$backup_dir/complete" && test -s "$backup_dir/agent" || { echo "No complete backup: $backup_dir. Nothing changed." >&2; exit 1; } + sh -n "$backup_dir/agent" + source_file=$backup_dir/agent +fi +cp -p "$target" "$stage/previous" +phase=install +changed=1 +cp "$source_file" "$target.new-__UPLOAD_NAME__" +chmod 755 "$target.new-__UPLOAD_NAME__" +mv -f "$target.new-__UPLOAD_NAME__" "$target" +phase=verify +sh -n "$target" +cmp "$source_file" "$target" +if [ '__ACTION__' = Install ]; then + phase=prepare-xray + # Seed the boot cache now, while an existing RAM executable is still here. + # Never restart a healthy tunnel or replace the user's client JSON. + "$target" prepare-xray +fi +phase=heartbeat-reload +refresh_heartbeat +if [ '__ACTION__' = Install ]; then + phase=xray-recovery + recover_stopped_xray +fi +printf 'Backup: %s\n' "$backup_dir" +echo 'Agent installed. Tunnel readiness must be checked in the VPS card/logs.' +printf '\nXRAY_BOOT_ROUTER_%s_OK\n' '__ACTION__' +'@ +$RemoteScript = $RemoteScript.Replace('__UPLOAD_NAME__', $UploadName).Replace('__ACTION__', $Action) +try { + [System.IO.Directory]::CreateDirectory($StageRoot) | Out-Null + [System.IO.File]::WriteAllText((Join-Path $StageRoot 'run.sh'), $RemoteScript.Replace("`r`n", "`n") + "`n", $Utf8) + if ($Action -eq 'Install') { + $Content = [System.IO.File]::ReadAllText((Join-Path $RepoRoot 'files\usr\sbin\owrt-remote')).Replace("`r`n", "`n") + [System.IO.File]::WriteAllText((Join-Path $StageRoot 'agent'), $Content, $Utf8) + } + if ($PrepareOnly) { Write-Host "Prepared only: $StageRoot"; return } + & scp -O -r -- $StageRoot "${Router}:/tmp/" + if ($LASTEXITCODE -ne 0) { throw 'Upload failed. The installation has not started.' } + & ssh -T -o ConnectTimeout=10 $Router "sh /tmp/$UploadName/run.sh" + if ($LASTEXITCODE -ne 0) { throw "$Action failed. See the output above; success was not confirmed." } + Write-Host "Xray boot fix $Action finished successfully." +} finally { + if (-not $PrepareOnly) { + $Resolved = [System.IO.Path]::GetFullPath($StageRoot) + $Expected = [System.IO.Path]::GetFullPath((Join-Path ([System.IO.Path]::GetTempPath()) $UploadName)) + if ($Resolved -ne $Expected -or (Split-Path -Leaf $Resolved) -ne $UploadName) { throw 'Unsafe staging cleanup path.' } + if (Test-Path -LiteralPath $Resolved) { Remove-Item -LiteralPath $Resolved -Recurse -Force } + } +}