Fix Xray recovery after reboot with persistent boot cache

This commit is contained in:
kzolotarev95 committed 2026-10-16 01:29:25 +04:00
1 parent e738d6fa69
commit d61c99cdbc
6 files changed
+1004 -45

No files matched your search

+95
View File
@@ -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 после настоящей перезагрузки ещё необходима.
+130
View File
@@ -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()
+334
View File
@@ -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()