Fix Xray recovery after reboot with persistent boot cache
This commit is contained in:
1 parent
e738d6fa69
commit
d61c99cdbc
6 files changed
+1004
-45
No files matched your search
+305
-43
@@ -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 </proc/self/stat || return 1
|
||||
XRAY_SELF_BIRTH="$(xray_process_start "$XRAY_SELF_PID")"
|
||||
[ -n "$XRAY_SELF_BIRTH" ]
|
||||
}
|
||||
xray_bootstrap_lock() {
|
||||
local owner attempt current saved
|
||||
XRAY_LOCK="$(xray_runtime_dir)/bootstrap-lock"
|
||||
mkdir -p "$(xray_runtime_dir)" || return 1
|
||||
xray_process_identity || return 1
|
||||
attempt=0
|
||||
while ! mkdir "$XRAY_LOCK" 2>/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 <<EOF
|
||||
$(xray_cache_mount /overlay)
|
||||
EOF
|
||||
if [ "$mount" = /overlay ]; then
|
||||
candidate=/overlay/owrt-remote/xray-cache
|
||||
else
|
||||
read -r mount fs flags <<EOF
|
||||
$(xray_cache_mount /)
|
||||
EOF
|
||||
candidate=/etc/owrt-remote/xray-cache
|
||||
fi
|
||||
case "$fs" in ubifs|jffs2|ext4|ext3|ext2|f2fs|btrfs) ;; *) return 1 ;; esac
|
||||
case ",$flags," in *,rw,*) ;; *) return 1 ;; esac
|
||||
# Existing symlinks or a nested tmpfs must not redirect this cache into RAM.
|
||||
read -r mount fs flags <<EOF
|
||||
$(xray_cache_mount "$candidate")
|
||||
EOF
|
||||
case "$fs" in ubifs|jffs2|ext4|ext3|ext2|f2fs|btrfs) ;; *) return 1 ;; esac
|
||||
case ",$flags," in *,rw,*) ;; *) return 1 ;; esac
|
||||
printf '%s' "$candidate"
|
||||
}
|
||||
xray_digest() {
|
||||
local digest
|
||||
digest="$(sha256sum "$1" 2>/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
|
||||
;;
|
||||
|
||||
+2
-2
@@ -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
|
||||
|
||||
@@ -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 после настоящей перезагрузки ещё необходима.
|
||||
@@ -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()
|
||||
@@ -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 </proc/self/stat
|
||||
echo "$pid" >>"$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()
|
||||
@@ -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 }
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user