Fix HTTPS heartbeat retries and WAN IPv4 DNS fallback

This commit is contained in:
kzolotarev95 committed 2026-10-15 12:55:35 +04:00
1 parent 4a398c96b1
commit 5f65a3d811
13 files changed
+1547 -69

No files matched your search

+120
View File
@@ -0,0 +1,120 @@
# Heartbeat: HTTPS, авторизация и диагностика (v116)
## Разбор сбоя 15.10.2026
В прежнем клиенте после первой ошибки HTTPS сразу проверялся следующий
адрес, в том числе автоматически сформированный HTTP. Повторной попытки
того же HTTPS до переключения не было. Настроенный Hub URL при этом
не обязательно менялся: перебор адресов происходил внутри одного цикла.
Bearer-заголовок в исходном запросе формировался одинаково для всех адресов.
Однако curl с `--location` снимает Authorization при смене origin, включая
HTTP → HTTPS. `--post301` сохраняет POST, но не авторизацию. Это объясняет
цепочку HTTP 301 → HTTPS 401 при правильном токене. Механизм воспроизведён
на локальных HTTP/HTTPS-серверах с настоящим curl и проверкой сертификата.
Заголовки реального nginx в момент исходного сбоя не захватывались, поэтому
совпадение с конкретным историческим запросом остаётся предположением.
Один `rc=28` и нулевое тело ответа не определяют, на каком этапе был тайм-аут.
Текущие быстрые ответы `/health` не доказывают причину прошедшего сбоя.
HTTP 401 на `/api/heartbeat` без авторизации ожидаем. Интервал примерно
32 секунды совместим с прежним циклом: время запроса плюс пауза 30 секунд.
Официальное описание curl: https://curl.se/docs/manpage.html
## Поведение после исправления
- При временной ошибке HTTPS выполняется одна повторная попытка того же
адреса через секунду: максимум две попытки по 10 секунд на адрес.
- Повторяются тайм-ауты, ошибки DNS/TCP, TLS handshake, обрывы соединения
и временные ответы сервера 408/429/500/502/503/504. Ошибка проверки
сертификата не повторяется автоматически.
- После исчерпания попыток можно перейти к следующему HTTPS-кандидату.
При настроенном HTTPS HTTP-кандидаты исключены, включая порт 8088.
Явно настроенные установки HTTP продолжают работать.
- HTTP 401/403 завершает цикл с `reason=auth_rejected`; перебор адресов
не используется для обхода отказа авторизации.
- curl больше не следует перенаправлениям автоматически. Разрешены
максимум три перехода в пределах origin либо HTTP → HTTPS на том же
хосте. Каждый разрешённый переход повторяет JSON POST с Bearer.
Смена хоста и HTTPS → HTTP отклоняются. Проверка TLS сохранена.
- При прямом WAN интерфейс и `--resolve` рассчитываются для каждого
разрешённого перехода, включая новый HTTPS-порт. Xray и правила
маршрутизации этим исправлением не переписываются.
## Диагностика и хранение
`owrt-remote heartbeat-diagnostics` показывает последний результат.
Он также добавлен к `owrt-remote network-diagnostics`.
Снимок атомарно заменяется в `/tmp/owrt-remote-heartbeat-last` — на OpenWrt
это RAM. Временные тела запросов/ответов находятся в приватных каталогах
`/tmp` и удаляются после запроса. Настройки UCI не меняются из-за замеров.
Поля результата: безопасный origin без пути, query и userinfo, номер
попытки, rc, HTTP, причина, общее время, DNS, TCP, TLS и время до первого
байта. В журнале ошибки содержат эти замеры, переключение — исходный
и следующий origin с причиной. Успешные записи остаются стабильными
для существующего подавления повторов; свежие замеры находятся в снимке.
Сырые stderr curl и тела ответов не записываются в журнал: сервер может
отразить туда секрет. Токен и Authorization в диагностике отсутствуют.
Все времена в миллисекундах:
- `DNS_ms` — время разрешения имени curl; при прямом WAN измеряется
отдельный запрос WAN DNS. `DNS_source=cache/pinned/literal` означает,
что DNS-запрос не требовался; `lookup` — запрос выполнялся.
- `TCP_ms` — `time_connect - time_namelookup`.
- `TLS_ms` — `time_appconnect - time_connect`; `incomplete` означает,
что этап не завершился. TCP тоже может быть `incomplete`.
- `TTFB_ms` — от начала запроса curl до первого байта, `total_ms` —
полное время curl. `elapsed_ms` включает подготовку запроса.
- `WAN_resolve_ms` — подготовка WAN-адреса и маршрута; это не чистое
время DNS. При `--resolve` системный DNS curl не используется.
- Для wget/uclient, у которых нет аналогичного write-out, этапы помечены
`n/a`, без выдуманных измерений.
## Установка и откат из Windows PowerShell
```powershell
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-heartbeat-transport-fix.ps1" -Router "root@192.168.2.1" -Action Install
```
Обновляются агент и WAN helper. Перезапускается только экземпляр Heartbeat
под procd; Xray и удалённый туннель скрипт не перезапускает. Остановленный
экземпляр остаётся остановленным. Резервная копия первых файлов сохраняется
в `/root/owrt-remote-backup-before-heartbeat-transport-v116`.
Маркер `HEARTBEAT_TRANSPORT_ROUTER_Install_OK` подтверждает установку кода,
а доступность Hub проверяется отдельно:
```powershell
ssh root@192.168.2.1 'owrt-remote heartbeat >/dev/null; echo HEARTBEAT_RC=$?; owrt-remote heartbeat-diagnostics; logread -e owrt-remote | tail -n 35'
```
`HEARTBEAT_RC=0`, `reason=ok` и `HTTP=200` подтверждают успешный запрос.
Для отката:
```powershell
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-heartbeat-transport-fix.ps1" -Router "root@192.168.2.1" -Action Rollback
```
При неполной/отсутствующей копии откат прекращается до изменения файлов.
При ошибке установки восстанавливаются оба файла текущей попытки.
## Локальные проверки
`test_heartbeat_transport.py` проверяет повтор HTTPS, запрет HTTP fallback,
401/403, безопасные поля и замеры DNS/TCP/TLS. Реальные HTTP/HTTPS-серверы
проверяют потерю Bearer в прежнем curl, исправленный переход, запрет чужого
хоста/понижения TLS, относительный redirect, предел redirect и прямой WAN.
Самоподписанный тестовый CA явно доверен только тестовому curl; `-k` нет.
`test_heartbeat_transport_deploy.py` проверяет повторную установку, исходную
резервную копию, откат, отказы до/после записи и адресный перезапуск только
Heartbeat. Дополнительно выполняются host policy, WAN failover, доставка
журналов, Xray apply и Xray validation.
Результат локальной проверки 15.10.2026: 14 тестов транспорта и 91 тест
регрессии прошли успешно, без пропусков. В проверках применения настроек
использовался настоящий Xray 26.3.27. PowerShell и POSIX-синтаксис проверены,
пакет подготовки содержит UTF-8 без BOM и окончания строк LF. На реальный
роутер этот локальный фикс автоматически не устанавливался.
+73
View File
@@ -0,0 +1,73 @@
# WAN IPv4 DNS fallback (local v116 fix)
`files/usr/lib/owrt-remote/wan.sh` now explicitly queries
`nslookup -type=A -timeout=3 -retry=1 "$host" "$dns"`.
BusyBox's default lookup sends both A and AAAA queries; explicit `-type=A`
and the timeout/retry options are supported by its internal resolver. See
[BusyBox 1.36 nslookup source](https://github.com/mirror/busybox/blob/1_36_stable/networking/nslookup.c)
and [OpenWrt 24.10 BusyBox options](https://github.com/openwrt/openwrt/blob/openwrt-24.10/package/utils/busybox/config/networking/Config.in).
The parser preserves the nslookup exit status and accepts only a valid IPv4
answer for the queried name or its CNAME chain after a successful query.
Resolver headers, unrelated names, malformed IPv4, IPv6 answers and
198.18.0.0/15 fake-IP addresses cannot populate the IPv4 cache. Existing
explicit IPv6 literals keep their prior behavior.
The original cache policy is retained: a successful IPv4 is reused for
5 minutes; on a failed refresh the last successful address remains usable
until its original timestamp is 1 hour old. Failed refreshes do not extend
that timestamp. Corrupt timestamps, future timestamps and invalid cached
addresses are rejected. The cache remains under `/tmp/owrt-remote-wan`.
Failure diagnostics distinguish `reason=timeout`, `reason=no_a_record`,
`reason=parse_error`, `reason=resolver_error` and `reason=rejected_address`.
They include the domain, selected resolver and original exit status, without
raw DNS output. A successful A answer emits no `WAN DNS unavailable` warning.
WAN/DNS selection, Podkop, Xray and route/policy-rule implementations are
unchanged by this fix.
## Verification
```powershell
$env:PYTHONPATH = 'tests'
python -m unittest test_wan_dns test_wan_dns_deploy -v
# Optional second run with actual BusyBox ash and built-in awk:
$env:OWRT_TEST_BUSYBOX = 'C:\path\to\busybox64.exe'
python -m unittest test_wan_dns test_wan_dns_deploy -v
```
22 tests cover A-only arguments for both reported resolvers, BusyBox answer
formats, CNAME chains, DNS errors, validation, cache bounds, syntax, repeated
installation, exact rollback and recovery after installation failures.
The BusyBox ash run uses busybox-w32 1.38.0-FRP-6075 and its built-in applets,
with fixture nslookup replies. The executable is obtained from the
[maintainer](https://frippery.org/busybox/) and checked against its SHA256SUM.
This is not a live OpenWrt DNS/network test; OpenWrt 24.10 option compatibility
is additionally checked against the linked BusyBox sources.
## Local installation and rollback
`vps/deploy-wan-dns-fix.ps1` extracts only the DNS functions from the local
source and replaces the corresponding block in the router's existing
`wan.sh`. Everything before and after that block is preserved, including
differences between the published agent and the previous local heartbeat
transport fix. The agent itself is not replaced.
```powershell
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-wan-dns-fix.ps1" -Router "root@192.168.2.1" -Action Install
```
The installer saves the first backup at
`/root/owrt-remote-backup-before-wan-dns-v116/wan.sh`, checks shell syntax and
reloads only the supervised heartbeat instance so it reads the new helper.
It does not restart Xray or regenerate configuration/routing. Installation
verification/reload failures restore the file from that attempt.
```powershell
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-wan-dns-fix.ps1" -Router "root@192.168.2.1" -Action Rollback
```
Rollback restores the entire saved `wan.sh`; use it before installing later
changes to that file. No service is started if heartbeat was already stopped.
All uploads use UTF-8 without BOM and LF. `-PrepareOnly` creates local payloads
for inspection without contacting the router.
+288
View File
@@ -0,0 +1,288 @@
"""HTTPS retry policy, origin-scoped auth, timings and real curl redirects."""
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import os
from pathlib import Path
import shutil
import ssl
import subprocess
import threading
import unittest
import test_host_policy as shell_tests
ROOT, SH = shell_tests.ROOT, shell_tests.SH
@unittest.skipUnless(SH, "POSIX shell required")
class HeartbeatTransportTests(unittest.TestCase):
setUp = shell_tests.RouterShellTests.setUp
config = shell_tests.RouterShellTests.config
run_shell = shell_tests.RouterShellTests.run_shell
def policy(self, commands, **env):
self.config(hub_url="https://primary.example", public_url="https://backup.example",
vps_host="192.0.2.7", hub_token="never-log-this-token")
self.directory.joinpath("calls").write_text("")
return self.run_shell(r'''
heartbeat_json() { printf '{"id":"test-router"}'; }
sleep() { printf 'sleep %s\n' "$*" >>"$TEST_ROOT/calls"; }
''' + commands, **env)
def test_one_timeout_retries_https_without_http_or_setting_changes(self):
result = self.policy(r'''
post_json() {
printf '%s\n' "$1" >>"$TEST_ROOT/calls"
if [ ! -f "$TEST_ROOT/tried" ]; then touch "$TEST_ROOT/tried"; return 28; fi
printf '{"ok":true}'
}
send_heartbeat >/dev/null
''')
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(self.directory.joinpath("calls").read_text().splitlines(),
["https://primary.example/api/heartbeat", "sleep 1", "https://primary.example/api/heartbeat"])
self.assertIn("retry HTTPS", result.stderr)
self.assertNotIn("fallback;", result.stderr)
self.assertNotIn("never-log-this-token", result.stderr)
self.assertFalse(self.directory.joinpath("commits").exists())
self.assertEqual(self.directory.joinpath("owrt-remote-heartbeat-last").read_text().split("reason=")[1].split(";")[0], "ok")
def test_exhausted_https_uses_secure_backup_and_explains_reason(self):
result = self.policy(r'''
post_json() {
printf '%s\n' "$1" >>"$TEST_ROOT/calls"
case "$1" in https://backup.example/*) printf '{"ok":true}' ;; *) return 28 ;; esac
}
send_heartbeat >/dev/null
''')
self.assertEqual(result.returncode, 0, result.stderr)
calls = self.directory.joinpath("calls").read_text()
self.assertEqual(calls.count("https://primary.example/api/heartbeat"), 2)
self.assertIn("https://backup.example/api/heartbeat", calls)
self.assertNotIn("http://", calls)
self.assertIn("fallback; from=https://primary.example:443; to=https://backup.example:443; reason=timeout", result.stderr)
def test_https_never_uses_plain_http_even_after_all_retries(self):
result = self.policy(r'''
post_json() { printf '%s\n' "$1" >>"$TEST_ROOT/calls"; return 28; }
send_heartbeat
''')
self.assertEqual(result.returncode, 1, result.stderr)
self.assertNotIn("http://", self.directory.joinpath("calls").read_text())
self.assertIn("reason=https_required", result.stderr)
def test_401_does_not_retry_or_change_endpoint_and_never_logs_echoed_secrets(self):
result = self.policy(r'''
post_json() {
printf '%s\n' "$1" >>"$TEST_ROOT/calls"
printf 'tool=curl HTTP=401 DNS_ms=1 TCP_ms=2 TLS_ms=3\n' >"$OWRT_REMOTE_HTTP_METRICS"
printf 'Authorization: Bearer never-log-this-token\n' >&2
printf '{"hub_token":"never-log-this-token"}'
return 22
}
send_heartbeat
''')
self.assertEqual(result.returncode, 1, result.stderr)
self.assertEqual(self.directory.joinpath("calls").read_text().splitlines(), ["https://primary.example/api/heartbeat"])
self.assertIn("reason=auth_rejected", result.stderr)
self.assertIn("HTTP=401", result.stderr)
self.assertNotIn("never-log-this-token", result.stdout + result.stderr)
def test_http_only_configuration_still_works_and_origin_removes_secrets(self):
self.config(hub_url="http://plain.example:8088", public_url="http://plain.example:8088", hub_token="test-token")
result = self.run_shell(r'''
heartbeat_json() { printf '{}'; }
post_json() { printf '{"ok":true}'; }
send_heartbeat >/dev/null
remote_url_origin 'https://hub.example/path?token=secret#secret'
''')
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout, "https://hub.example:443")
self.assertNotIn("secret", result.stderr)
def test_certificate_error_is_not_retried_and_never_uses_http(self):
result = self.policy(r'''
post_json() { printf '%s\n' "$1" >>"$TEST_ROOT/calls"; return 60; }
send_heartbeat
''')
self.assertEqual(result.returncode, 1, result.stderr)
calls = self.directory.joinpath("calls").read_text()
self.assertEqual(calls.count("https://primary.example/api/heartbeat"), 1)
self.assertNotIn("sleep", calls)
self.assertNotIn("http://", calls)
self.assertIn("reason=tls_verification_failed", result.stderr)
def test_timing_deltas_and_safe_fields_only(self):
self.directory.joinpath("stats").write_text("200 0.010 0.030 0.080 0.100 0.120 https://evil.example/?token=secret\n")
result = self.run_shell(r'''
OWRT_REMOTE_HTTP_METRICS="$TEST_ROOT/metrics"
remote_curl_metrics "$TEST_ROOT/stats" https 15 1
cat "$TEST_ROOT/metrics"
''')
self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("DNS_ms=10.0 TCP_ms=20.0 TLS_ms=50.0", result.stdout)
self.assertIn("WAN_resolve_ms=15 hop=1", result.stdout)
self.assertNotIn("secret", result.stdout)
self.assertNotIn("evil", result.stdout)
def test_wan_dns_timing_distinguishes_lookup_cache_and_pinned_host(self):
self.config(vps_host="hub.example", vps_host_mode="manual")
self.directory.joinpath("stats").write_text("200 0.000 0.030 0.080 0.100 0.120\n")
result = self.run_shell(r'''
OWRT_REMOTE_HTTP_METRICS="$TEST_ROOT/metrics"
OWRT_REMOTE_DNS_METRICS="$TEST_ROOT/dns-time"
wan_resolve_host hub.example >/dev/null || exit
read -r duration source <"$TEST_ROOT/dns-time"
[ "$source" = lookup ] || exit 81
wan_resolve_host hub.example >/dev/null || exit
read -r duration source <"$TEST_ROOT/dns-time"
[ "$duration $source" = '0 cache' ] || exit 82
remote_curl_metrics "$TEST_ROOT/stats" https 15 0 "$duration" "$source"
uci set owrtremote.main.vps_host=192.0.2.1
wan_endpoint_ip https://hub.example/api/heartbeat >/dev/null || exit
read -r duration source <"$TEST_ROOT/dns-time"
[ "$duration $source" = '0 pinned' ] || exit 83
remote_curl_metrics "$TEST_ROOT/stats" https 15 0 "$duration" "$source"
cat "$TEST_ROOT/metrics"
''')
self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("DNS_ms=0.0", result.stdout)
self.assertIn("DNS_source=cache", result.stdout)
self.assertIn("DNS_source=pinned", result.stdout)
@unittest.skipUnless(SH, "POSIX shell required")
class CurlRedirectTests(unittest.TestCase):
setUp = shell_tests.RouterShellTests.setUp
config = shell_tests.RouterShellTests.config
run_shell = shell_tests.RouterShellTests.run_shell
def prepare(self, secure_front=False):
if os.name == "nt":
bindir = Path(os.environ.get("ProgramFiles", "C:/Program Files")) / "Git/mingw64/bin"
self.curl = bindir / "curl.exe"
openssl = bindir / "openssl.exe"
else:
self.curl = Path(shutil.which("curl") or "/nonexistent")
openssl = Path(shutil.which("openssl") or "/nonexistent")
if not self.curl.exists() or not openssl.exists():
self.skipTest("real curl and OpenSSL required")
cert = self.directory / "cert.pem"
key = self.directory / "key.pem"
subprocess.run([str(openssl), "req", "-x509", "-newkey", "rsa:2048", "-nodes", "-days", "1",
"-subj", "/CN=localhost", "-addext", "subjectAltName=DNS:localhost,IP:127.0.0.1",
"-keyout", str(key), "-out", str(cert)], check=True, capture_output=True)
self.env.update(TEST_CURL=self.curl.as_posix(), TEST_CA_CERT=cert.as_posix())
self.directory.joinpath("payload").write_bytes(b'{"id":"test-router"}')
self.config(wan_direct="0")
self.records = []
owner = self
class Handler(BaseHTTPRequestHandler):
def log_message(self, *args):
pass
def do_POST(self):
body = self.rfile.read(int(self.headers.get("Content-Length", 0)))
owner.records.append((self.server.server_port, self.path, self.headers.get("Authorization"), body))
if self.server is owner.front and self.path == "/api/heartbeat":
self.send_response(owner.redirect_code)
self.send_header("Location", owner.destination)
response = b""
else:
self.send_response(200 if self.headers.get("Authorization") == "Bearer test-token" else 401)
response = b'{"ok":true}'
self.send_header("Content-Length", str(len(response)))
self.end_headers()
self.wfile.write(response)
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.load_cert_chain(cert, key)
self.back = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
self.back.socket = context.wrap_socket(self.back.socket, server_side=True)
self.front = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
if secure_front:
self.front.socket = context.wrap_socket(self.front.socket, server_side=True)
for server in (self.front, self.back):
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
self.addCleanup(server.server_close)
self.addCleanup(server.shutdown)
self.redirect_code = 301
self.destination = f"https://localhost:{self.back.server_port}/api/heartbeat"
self.url = f"{'https' if secure_front else 'http'}://localhost:{self.front.server_port}/api/heartbeat"
# shell_tests supplies a mock curl; replace only the executable binding.
self.real = r'''
curl() { "$TEST_CURL" -q --cacert "$TEST_CA_CERT" "$@"; }
OWRT_REMOTE_HTTP_METRICS="$TEST_ROOT/metrics"
export OWRT_REMOTE_HTTP_METRICS
'''
def test_real_curl_reproduces_401_then_upgrade_keeps_json_and_auth(self):
self.prepare()
old = subprocess.run([str(self.curl), "-q", "--cacert", self.env["TEST_CA_CERT"], "-fsSL", "--noproxy", "*", "--max-time", "5",
"--post301", "-H", "Authorization: Bearer test-token", "-H", "Content-Type: application/json",
"--data-binary", "@" + str(self.directory / "payload"), self.url],
env=self.env, capture_output=True)
self.assertEqual(old.returncode, 22, old.stderr)
self.assertEqual(self.records[-1][2], None, "curl drops auth across HTTP -> HTTPS")
self.records.clear()
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertTrue(json.loads(result.stdout)["ok"])
self.assertEqual([x[2] for x in self.records], ["Bearer test-token"] * 2)
self.assertTrue(all(x[3] == b'{"id":"test-router"}' for x in self.records))
self.assertEqual(len(self.directory.joinpath("metrics").read_text().splitlines()), 2)
self.assertFalse(list(self.directory.glob("owrt-remote-http.*")))
def test_rejects_cross_host_without_forwarding_token(self):
self.prepare()
self.destination = f"https://127.0.0.1:{self.back.server_port}/api/heartbeat?token=secret"
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
self.assertEqual(result.returncode, 47, result.stderr)
self.assertEqual(len(self.records), 1)
self.assertNotIn("secret", self.directory.joinpath("metrics").read_text())
def test_rejects_tls_downgrade_without_forwarding_token(self):
self.prepare(secure_front=True)
self.destination = self.url.replace("https://", "http://")
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
self.assertEqual(result.returncode, 47, result.stderr)
self.assertEqual(len(self.records), 1)
def test_same_origin_relative_redirect_preserves_auth_and_post(self):
self.prepare(secure_front=True)
self.destination = "/redirected"
self.redirect_code = 307
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertTrue(json.loads(result.stdout)["ok"])
self.assertEqual([x[1] for x in self.records], ["/api/heartbeat", "/redirected"])
self.assertEqual([x[2] for x in self.records], ["Bearer test-token"] * 2)
def test_repeated_redirects_are_bounded(self):
self.prepare()
self.destination = self.url
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
self.assertEqual(result.returncode, 47, result.stderr)
self.assertEqual(len(self.records), 4)
def test_wan_redirect_resolves_and_binds_both_hops(self):
self.prepare()
result = self.run_shell(self.real + r'''
wan_http_target() {
local port
printf '%s\n' "$1" >>"$TEST_ROOT/targets"
port="${1#*localhost:}"; port="${port%%/*}"
printf '127.0.0.1|localhost:%s:127.0.0.1' "$port"
}
wan_post_json "$TEST_URL" test-token "$TEST_ROOT/payload"
''', TEST_URL=self.url)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(self.directory.joinpath("targets").read_text().splitlines(), [self.url, self.destination])
self.assertEqual([x[2] for x in self.records], ["Bearer test-token"] * 2)
if __name__ == "__main__":
unittest.main()
+122
View File
@@ -0,0 +1,122 @@
"""Run installation and rollback in a sandbox, without SSH or services."""
import os
from pathlib import Path
import shlex
import subprocess
import tempfile
import unittest
from test_xray_mobile_deploy import SH, GIT_BIN, ROOT
@unittest.skipUnless(SH, "POSIX shell required")
class HeartbeatTransportDeploymentTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory(prefix="heartbeat-transport-deploy-")
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.targets = {"wan.sh": self.root / "wan.sh", "agent": self.root / "agent"}
for name, path in self.targets.items():
path.write_text("#!/bin/sh\necho previous-" + name + "\n", encoding="utf-8", newline="\n")
self.original = {name: path.read_bytes() for name, path in self.targets.items()}
self.backup = self.root / "backup"
self.env = dict(os.environ)
if os.name == "nt":
self.env["PATH"] = str(GIT_BIN) + os.pathsep + self.env["PATH"]
source = (ROOT / "vps/deploy-heartbeat-transport-fix.ps1").read_text(encoding="utf-8")
self.script = source.split("$RemoteScript = @'\n", 1)[1].split("\n'@", 1)[0]
self.script = self.script.replace("backup_dir=/root/owrt-remote-backup-before-heartbeat-transport-v116",
"backup_dir=" + shlex.quote(self.backup.as_posix()))
self.script = self.script.replace("printf /usr/lib/owrt-remote/wan.sh", "printf %s " + shlex.quote(self.targets["wan.sh"].as_posix()))
self.script = self.script.replace("printf /usr/sbin/owrt-remote", "printf %s " + shlex.quote(self.targets["agent"].as_posix()))
def deploy(self, action, bad_item=None, fail_verify=False, fail_signal=False, stopped=False):
stage = self.root / "stage"
stage.mkdir()
for item, source in {"wan.sh": "files/usr/lib/owrt-remote/wan.sh", "agent": "files/usr/sbin/owrt-remote"}.items():
text = (ROOT / source).read_text(encoding="utf-8")
if bad_item == item:
text = "#!/bin/sh\nif true; then\n"
stage.joinpath(item).write_text(text, encoding="utf-8", newline="\n")
script = self.script.replace("stage=/tmp/__UPLOAD_NAME__", "stage=" + shlex.quote(stage.as_posix()))
script = script.replace("__ACTION__", action).replace("__UPLOAD_NAME__", "sandbox")
if fail_verify:
script = script.replace('cmp "$source_dir/$item" "$path"', "false")
mocks = r'''
ubus() {
printf '%s\n' "$*" >>"$TEST_ROOT/ubus-calls"
if [ "$3" = signal ]; then
[ "${TEST_SIGNAL_FAIL:-0}" = 0 ] || return 1
printf 202 >"$TEST_ROOT/pid"
fi
printf '{}'
}
jsonfilter() { cat >/dev/null; cat "$TEST_ROOT/pid"; }
sleep() { :; }
'''
self.root.joinpath("pid").write_text("" if stopped else "101")
result = subprocess.run([SH], input=mocks + script, encoding="utf-8", capture_output=True,
env={**self.env, "TEST_ROOT": self.root.as_posix(), "TEST_SIGNAL_FAIL": "1" if fail_signal else "0"}, timeout=30)
self.assertFalse(stage.exists())
self.assertFalse(list(self.root.glob("*.new-sandbox")))
return result
def test_install_twice_then_rollback_preserves_first_backup(self):
for attempt in range(2):
result = self.deploy("Install")
self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("HEARTBEAT_TRANSPORT_ROUTER_Install_OK", result.stdout)
for item, path in self.targets.items():
self.assertNotEqual(path.read_bytes(), self.original[item])
self.assertEqual(self.backup.joinpath(item).read_bytes(), self.original[item])
result = self.deploy("Rollback")
self.assertEqual(result.returncode, 0, result.stderr)
for item, path in self.targets.items():
self.assertEqual(path.read_bytes(), self.original[item])
def test_bad_candidate_and_missing_backup_leave_paired_files_unchanged(self):
for item in ("agent", "wan.sh"):
result = self.deploy("Install", bad_item=item)
self.assertNotEqual(result.returncode, 0)
self.assertFalse(self.backup.exists())
for name, path in self.targets.items():
self.assertEqual(path.read_bytes(), self.original[name])
result = self.deploy("Rollback")
self.assertNotEqual(result.returncode, 0)
self.assertIn("No complete backup", result.stderr)
for name, path in self.targets.items():
self.assertEqual(path.read_bytes(), self.original[name])
def test_reloads_only_heartbeat_without_touching_xray(self):
result = self.deploy("Install")
self.assertEqual(result.returncode, 0, result.stderr)
calls = self.root.joinpath("ubus-calls").read_text()
self.assertIn('service signal {"name":"owrt-remote","instance":"heartbeat","signal":9}', calls)
self.assertNotIn('"instance":"xray"', calls)
self.assertIn('Heartbeat loop reloaded', result.stdout)
def test_stopped_loop_stays_stopped(self):
result = self.deploy("Install", stopped=True)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertNotIn('service signal', self.root.joinpath("ubus-calls").read_text())
self.assertIn('Heartbeat loop is stopped', result.stdout)
def test_failed_loop_reload_restores_paired_files_and_reports_failure(self):
result = self.deploy("Install", fail_signal=True)
self.assertNotEqual(result.returncode, 0)
self.assertIn('Failed during heartbeat-reload', result.stderr)
self.assertNotIn('HEARTBEAT_TRANSPORT_ROUTER_Install_OK', result.stdout)
for item, path in self.targets.items():
self.assertEqual(path.read_bytes(), self.original[item])
def test_verify_failure_restores_paired_files(self):
result = self.deploy("Install", fail_verify=True)
self.assertNotEqual(result.returncode, 0)
self.assertIn("Restoring the agent and WAN helper", result.stderr)
for item, path in self.targets.items():
self.assertEqual(path.read_bytes(), self.original[item])
if __name__ == "__main__":
unittest.main()
+11 -10
View File
@@ -310,12 +310,12 @@ printf '%s|%s|%s' "$(uci_get hub_url '')" "$(uci_get public_url '')" "$(uci_get
self.assertEqual(log.count("reason=https-downgrade"), 2, "repeated proposals must not flood the log")
def test_successful_fallback_heartbeat_does_not_replace_configured_hub_url(self):
self.config(hub_url="https://hub.example", hub_token="test-token", vps_host="193.233.82.38")
self.config(hub_url="https://hub.example", public_url="https://backup.example", hub_token="test-token", vps_host="193.233.82.38")
result = self.run_shell('''
heartbeat_json() { printf '{"id":"test-router"}'; }
post_json() {
case "$1" in
http://193.233.82.38:8088/api/heartbeat) printf '{"ok":true}' ;;
https://backup.example/api/heartbeat) printf '{"ok":true}' ;;
*) return 1 ;;
esac
}
@@ -428,11 +428,11 @@ printf '%s' "$(uci_get hub_url '')"
self.assertIn("<pppoe-wan>", args)
self.assertIn("<https://hub.example/api/heartbeat>", args)
self.assertNotIn("<-k>", args)
self.assertIn("<--max-time>\n<10>", args)
self.assertIn("<--location>", args)
self.assertIn("<--post301>", args)
self.assertIn("<--post302>", args)
self.assertIn("<--post303>", args)
self.assertIn("<--max-time>", args)
self.assertIn("<--resolve>", args)
self.assertIn("<--data-binary>", args)
self.assertNotIn("<--location-trusted>", args)
self.assertNotIn("<--location>", args)
def test_busybox_empty_table_is_confirmed_before_wan_start(self):
self.config(vps_host="193.233.82.38", hub_url="https://hub.example", wan_direct="1", vless_uuid="11111111-1111-4111-8111-111111111111")
@@ -487,7 +487,7 @@ wan_prepare
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(self.directory.joinpath("xray-called").read_text().strip(), 'run -config ' + config.as_posix())
def test_plain_http_heartbeat_accepts_json_after_redirect_follow(self):
def test_plain_http_heartbeat_uses_controlled_authenticated_posts(self):
self.config(vps_host="193.233.82.38", vps_host_mode="manual")
result = self.run_shell('''
curl() {
@@ -498,8 +498,9 @@ post_json http://hub.example/api/heartbeat test-token "$TEST_ROOT/payload"
''')
self.assertEqual(result.returncode, 0, result.stderr)
args = (self.directory / "curl").read_text()
self.assertIn("<--location>", args)
self.assertIn("<--post301>", args)
self.assertIn("<Authorization: Bearer test-token>", args)
self.assertIn("<--data-binary>", args)
self.assertNotIn("<--location>", args)
def test_literal_ip_fallback_is_not_rewritten_to_a_different_pin(self):
self.config(vps_host="193.233.82.38", vps_host_mode="manual")
+9 -5
View File
@@ -34,14 +34,18 @@ wan_prepare() { echo prepare >>"$TEST_ROOT/requests"; [ "${TEST_WAN_FAIL:-0}" !=
xray_running() { [ "${TEST_XRAY_RUNNING:-0}" = 1 ]; }
wan_post_json() { echo direct >>"$TEST_ROOT/requests"; fake_post "$1" "$3"; }
curl() {
local file arg next url
next=0; file=''
local file arg next url output
next=''; file=''; output=''
for arg in "$@"; do
[ "$next" != 1 ] || { file="${arg#@}"; next=0; }
[ "$arg" != --data-binary ] || next=1
case "$next" in
data) file="${arg#@}"; next=''; continue ;;
output) output="$arg"; next=''; continue ;;
esac
case "$arg" in --data-binary) next=data ;; -o) next=output ;; esac
url="$arg"
done
fake_post "$url" "$file"
fake_post "$url" "$file" >"$output" || return $?
printf '200 0.001 0.002 0.003 0.004 0.005\n'
}
fake_post() {
echo "$1" >>"$TEST_ROOT/requests"
+219
View File
@@ -0,0 +1,219 @@
"""WAN A-record parsing and bounded fallback; no router/network mutations.
Set OWRT_TEST_BUSYBOX to a BusyBox executable to run this exact suite in ash
with its built-in awk/grep/date applets (busybox-w32 is supported).
"""
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
BUSYBOX = os.environ.get("OWRT_TEST_BUSYBOX")
SH = shutil.which("sh")
if not SH and os.name == "nt":
candidate = Path(os.environ.get("ProgramFiles", "C:/Program Files")) / "Git/usr/bin/sh.exe"
SH = str(candidate) if candidate.exists() else None
HEADER = "Server:\t\t8.8.8.8\nAddress:\t8.8.8.8:53\n\n"
GOOD = HEADER + "Non-authoritative answer:\nName:\tbronsvn.developer.li\nAddress: 132.243.19.232\n"
MOCKS = r'''
safe_id() { printf '%s' "$1"; }
wan_dns_server() { printf '%s' "${TEST_DNS:-8.8.8.8}"; }
log() { printf '%s\n' "$*" >&2; }
date() { printf 1800000000; }
remote_clock_ms() { printf 1000; }
nslookup() {
printf '%s\n' "$*" >>"$TEST_ROOT/queries"
cat "$TEST_ROOT/reply"
cat "$TEST_ROOT/reply-stderr" >&2
return "${TEST_RC:-0}"
}
# Resolution must not change network state or use another resolver.
ip() { printf forbidden-ip >&2; exit 90; }
nft() { printf forbidden-nft >&2; exit 91; }
uci() { printf forbidden-uci >&2; exit 92; }
'''
@unittest.skipUnless(BUSYBOX or SH, "POSIX shell required")
class WanDnsTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory(prefix="wan-dns-")
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.state = self.root / "state"
self.state.mkdir()
self.cache = self.state / "resolve-bronsvn.developer.li-8.8.8.8"
self.source = (ROOT / "files/usr/lib/owrt-remote/wan.sh").read_text(encoding="utf-8")
def run_shell(self, reply=GOOD, rc=0, stderr="", commands="wan_resolve_host bronsvn.developer.li", **env):
self.root.joinpath("reply").write_text(reply, encoding="utf-8", newline="\n")
self.root.joinpath("reply-stderr").write_text(stderr, encoding="utf-8", newline="\n")
script = self.root / "run.sh"
script.write_text(self.source + '\nWAN_STATE="$TEST_ROOT/state"\n' + MOCKS + "\n" + commands + "\n",
encoding="utf-8", newline="\n")
args = [BUSYBOX, "ash"] if BUSYBOX else [SH]
process_env = dict(os.environ)
if not BUSYBOX and os.name == "nt":
process_env["PATH"] = str(Path(SH).parent) + os.pathsep + process_env["PATH"]
return subprocess.run(args + [script.as_posix()], capture_output=True, encoding="utf-8",
env={**process_env, "TEST_ROOT": self.root.as_posix(), "TEST_RC": str(rc), **env}, timeout=15)
def save_cache(self, timestamp=1799999699, ip="132.243.19.231"):
self.cache.write_text(f"{timestamp} {ip}\n", encoding="ascii", newline="\n")
def test_explicit_a_query_for_both_reported_resolvers_and_no_false_warning(self):
for dns in ("8.8.8.8", "8.8.4.4"):
with self.subTest(dns=dns):
result = self.run_shell(TEST_DNS=dns)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout, "132.243.19.232")
self.assertEqual(result.stderr, "")
self.assertEqual(self.root.joinpath("queries").read_text().splitlines(),
[f"-type=A -timeout=3 -retry=1 bronsvn.developer.li {dns}" for dns in ("8.8.8.8", "8.8.4.4")])
def test_busybox_and_numbered_address_formats(self):
for address in ("Address: 132.243.19.232", "Address 1: 132.243.19.232", "Address 1: 132.243.19.232 bronsvn.developer.li"):
with self.subTest(address=address):
self.cache.unlink(missing_ok=True)
result = self.run_shell(HEADER + "Name: bronsvn.developer.li\n" + address + "\n")
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout, "132.243.19.232")
def test_cname_chain_case_and_trailing_dot(self):
reply = HEADER + "BrOnSvN.Developer.Li. canonical name = edge.example.\nedge.example canonical name = origin.example.\nName: origin.example\nAddress: 132.243.19.232\n"
result = self.run_shell(reply)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout, "132.243.19.232")
def test_host_containing_diagnostic_words_is_not_an_error(self):
host = "timeout-servfail-refused.example"
result = self.run_shell(GOOD.replace("bronsvn.developer.li", host),
commands="wan_resolve_host " + host)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout, "132.243.19.232")
self.assertEqual(result.stderr, "")
def test_unrelated_name_and_unscoped_address_are_not_answers(self):
for reply in (HEADER + "Address: 132.243.19.232\n", HEADER + "Name: other.example\nAddress: 132.243.19.232\n"):
with self.subTest(reply=reply):
result = self.run_shell(reply)
self.assertNotEqual(result.returncode, 0)
self.assertEqual(result.stdout, "")
self.assertFalse(self.cache.exists())
def test_no_a_record_is_distinct_from_timeout_and_parse_error(self):
replies = ((HEADER, 0),
(HEADER + "Non-authoritative answer:\n", 0),
(HEADER + "*** Can't find bronsvn.developer.li: No answer\n", 0),
(HEADER + "** server can't find bronsvn.developer.li: NXDOMAIN\n", 1),
(HEADER + "Name: bronsvn.developer.li\nAddress: 2001:db8::1\n", 0))
for reply, rc in replies:
with self.subTest(reply=reply):
result = self.run_shell(reply, rc)
self.assertNotEqual(result.returncode, 0)
self.assertEqual(result.stdout, "")
self.assertIn("reason=no_a_record", result.stderr)
def test_dns_timeout_stderr_and_original_return_code_are_preserved(self):
result = self.run_shell("", 1, ";; connection timed out; no servers could be reached\n")
self.assertNotEqual(result.returncode, 0)
self.assertIn("reason=timeout rc=1", result.stderr)
def test_malformed_empty_and_invalid_ipv4_are_parse_errors(self):
for reply in ("", "unexpected output\n", HEADER + "*** Can't find bronsvn.developer.li: Parse error\n",
*(HEADER + f"Name: bronsvn.developer.li\nAddress: {ip}\n" for ip in
("999.243.19.232", "132.243.19", "132.243.19.232.evil", "0132.243.19.232", "", "-1.2.3.4"))):
with self.subTest(reply=reply):
result = self.run_shell(reply)
self.assertNotEqual(result.returncode, 0)
self.assertEqual(result.stdout, "")
self.assertIn("reason=parse_error", result.stderr)
def test_nonzero_nslookup_is_not_success_even_with_valid_looking_answer(self):
result = self.run_shell(GOOD, 1)
self.assertNotEqual(result.returncode, 0)
self.assertEqual(result.stdout, "")
self.assertIn("reason=resolver_error", result.stderr)
self.assertFalse(self.cache.exists())
def test_servfail_is_resolver_error(self):
result = self.run_shell(HEADER + "** server can't find bronsvn.developer.li: SERVFAIL\n", 1)
self.assertNotEqual(result.returncode, 0)
self.assertIn("reason=resolver_error", result.stderr)
def test_fake_ip_is_rejected_and_later_valid_a_is_used(self):
for ip in ("198.18.0.1", "198.19.255.255"):
result = self.run_shell(GOOD.replace("132.243.19.232", ip))
self.assertNotEqual(result.returncode, 0)
self.assertIn("reason=rejected_address", result.stderr)
result = self.run_shell(GOOD.replace("132.243.19.232", "198.18.0.1") + "Address: 132.243.19.232\n")
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout, "132.243.19.232")
self.assertEqual(result.stderr, "")
def test_success_refreshes_stale_cache_without_warning(self):
self.save_cache()
result = self.run_shell()
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stderr, "")
self.assertEqual(self.cache.read_text(), "1800000000 132.243.19.232\n")
def test_recent_valid_cache_skips_lookup(self):
self.save_cache(1799999701)
result = self.run_shell("", 1)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout, "132.243.19.231")
self.assertFalse(self.root.joinpath("queries").exists())
def test_last_success_fallback_preserves_age_and_logs_exact_failure(self):
for reply, rc, reason in ((";; connection timed out\n", 1, "timeout"),
(HEADER, 0, "no_a_record"), ("broken reply", 0, "parse_error")):
with self.subTest(reason=reason):
self.save_cache(1799996401)
before = self.cache.read_bytes()
result = self.run_shell(reply, rc)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(result.stdout, "132.243.19.231")
self.assertIn("WAN DNS unavailable", result.stderr)
self.assertIn("reason=" + reason, result.stderr)
self.assertEqual(self.cache.read_bytes(), before)
def test_expired_corrupt_future_and_ipv6_cache_are_never_fallback(self):
for timestamp, ip in ((1799996400, "132.243.19.231"), (1800000001, "132.243.19.231"),
("invalid", "132.243.19.231"), ("08", "132.243.19.231"),
("999999999999999999999999", "132.243.19.231"),
(1799999999, "2001:db8::1"), (1799999999, "999.1.1.1"),
(1799999999, "198.18.0.1"), (1799999999, "198.19.255.255")):
with self.subTest(timestamp=timestamp, ip=ip):
self.save_cache(timestamp, ip)
result = self.run_shell(HEADER, 0)
self.assertNotEqual(result.returncode, 0)
self.assertEqual(result.stdout, "")
self.assertIn("reason=no_a_record", result.stderr)
def test_cache_metrics_still_distinguish_actual_lookup(self):
result = self.run_shell(commands=r'''
OWRT_REMOTE_DNS_METRICS="$TEST_ROOT/metrics"
wan_resolve_host bronsvn.developer.li || exit
cat "$TEST_ROOT/metrics"
wan_resolve_host bronsvn.developer.li || exit
cat "$TEST_ROOT/metrics"
''')
self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("0 lookup", result.stdout)
self.assertIn("0 cache", result.stdout)
def test_shell_syntax(self):
script = self.root / "wan.sh"
script.write_text(self.source, encoding="utf-8", newline="\n")
args = [BUSYBOX, "ash"] if BUSYBOX else [SH]
result = subprocess.run(args + ["-n", script.as_posix()], capture_output=True, timeout=15)
self.assertEqual(result.returncode, 0, result.stderr)
if __name__ == "__main__":
unittest.main()
+129
View File
@@ -0,0 +1,129 @@
"""Install/rollback DNS functions while preserving every other WAN function."""
import os
from pathlib import Path
import shlex
import subprocess
import tempfile
import unittest
from test_wan_dns import ROOT, SH, BUSYBOX
# Stable legacy layout: keep testing an installation without wan_dns_metric
# after this fix becomes HEAD, and when tests run from a source archive.
LEGACY_DNS = '''wan_resolve_host() {
local host dns answer
host="$1"; dns="$(wan_dns_server)" || return 1
answer="$(nslookup -timeout=3 -retry=1 "$host" "$dns" 2>/dev/null)"
printf '%s' "$answer"
}
'''
@unittest.skipUnless(BUSYBOX or SH, "POSIX shell required")
class WanDnsDeploymentTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory(prefix="wan-dns-deploy-")
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
self.target = self.root / "wan.sh"
self.backup = self.root / "backup"
self.current = (ROOT / "files/usr/lib/owrt-remote/wan.sh").read_text(encoding="utf-8")
self.published = (self.current.split("wan_dns_metric() {", 1)[0] + LEGACY_DNS
+ "wan_endpoint_ip() {" + self.current.split("wan_endpoint_ip() {", 1)[1])
self.target.write_text(self.published, encoding="utf-8", newline="\n")
source = (ROOT / "vps/deploy-wan-dns-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/lib/owrt-remote/wan.sh", "target=" + shlex.quote(self.target.as_posix()))
self.script = self.script.replace("backup_dir=/root/owrt-remote-backup-before-wan-dns-v116",
"backup_dir=" + shlex.quote(self.backup.as_posix()))
def deploy(self, action="Install", bad=False, fail_verify=False, fail_signal=False):
stage = self.root / "stage"
stage.mkdir()
block = "wan_dns_metric() {" + self.current.split("wan_dns_metric() {", 1)[1].split("wan_endpoint_ip() {", 1)[0]
if bad:
block = "if true; then\n"
stage.joinpath("dns.sh").write_text(block, encoding="utf-8", newline="\n")
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() {
printf '%s\n' "$*" >>"$TEST_ROOT/ubus-calls"
if [ "$3" = signal ]; then
[ "${TEST_SIGNAL_FAIL:-0}" = 0 ] || return 1
printf 202 >"$TEST_ROOT/pid"
fi
printf '{}'
}
jsonfilter() { cat >/dev/null; cat "$TEST_ROOT/pid"; }
sleep() { :; }
'''
self.root.joinpath("pid").write_text("101")
run = self.root / "run.sh"
run.write_text(mocks + script, encoding="utf-8", newline="\n")
args = [BUSYBOX, "ash"] if BUSYBOX else [SH]
env = dict(os.environ)
if not BUSYBOX and os.name == "nt":
env["PATH"] = str(Path(SH).parent) + os.pathsep + env["PATH"]
result = subprocess.run(args + [run.as_posix()], capture_output=True, encoding="utf-8", timeout=20,
env={**env, "TEST_ROOT": self.root.as_posix(), "TEST_SIGNAL_FAIL": "1" if fail_signal else "0"})
self.assertFalse(stage.exists())
self.assertFalse(list(self.root.glob("*.new-sandbox")))
return result
def test_published_and_local_transport_versions_keep_all_non_dns_code(self):
for before in (self.published, self.current):
with self.subTest(version="local" if before == self.current else "published"):
self.target.write_text(before, encoding="utf-8", newline="\n")
result = self.deploy()
self.assertEqual(result.returncode, 0, result.stderr)
after = self.target.read_text(encoding="utf-8")
prefix = before.split("wan_dns_metric() {" if "wan_dns_metric() {" in before else "wan_resolve_host() {", 1)[0]
suffix = "wan_endpoint_ip() {" + before.split("wan_endpoint_ip() {", 1)[1]
self.assertTrue(after.startswith(prefix))
self.assertTrue(after.endswith(suffix))
self.assertIn("nslookup -type=A -timeout=3 -retry=1", after)
self.assertIn("WAN_DNS_ROUTER_Install_OK", result.stdout)
self.assertNotIn('"instance":"xray"', self.root.joinpath("ubus-calls").read_text())
def test_repeated_install_then_rollback_preserves_first_backup(self):
previous = self.target.read_bytes()
for attempt in range(2):
result = self.deploy()
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(self.backup.joinpath("wan.sh").read_bytes(), previous)
result = self.deploy("Rollback")
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(self.target.read_bytes(), previous)
def test_bad_candidate_and_missing_backup_leave_target_unchanged(self):
before = self.target.read_bytes()
for action, bad in (("Install", True), ("Rollback", False)):
result = self.deploy(action, bad)
self.assertNotEqual(result.returncode, 0)
self.assertEqual(self.target.read_bytes(), before)
self.assertFalse(self.backup.exists())
def test_unknown_target_structure_is_rejected_before_changes(self):
self.target.write_text("#!/bin/sh\necho unknown\n", encoding="utf-8", newline="\n")
before = self.target.read_bytes()
result = self.deploy()
self.assertNotEqual(result.returncode, 0)
self.assertEqual(self.target.read_bytes(), before)
self.assertFalse(self.backup.exists())
def test_verification_or_reload_failure_restores_previous_wan_helper(self):
before = self.target.read_bytes()
for kwargs in ({"fail_verify": True}, {"fail_signal": True}):
result = self.deploy(**kwargs)
self.assertNotEqual(result.returncode, 0)
self.assertIn("Restoring WAN helper", result.stderr)
self.assertEqual(self.target.read_bytes(), before)
self.assertNotIn("WAN_DNS_ROUTER_Install_OK", result.stdout)
if __name__ == "__main__":
unittest.main()
+3 -2
View File
@@ -84,7 +84,8 @@ render_page() { printf 'KIND=%s\nTITLE=%s\nBODY=%s\nDRAFT=%s\n' "$RESULT_KIND" "
env={**self.env, "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded",
"CONTENT_LENGTH": str(len(body))}, timeout=20)
self.assertEqual(result.returncode, 0, result.stderr.decode("utf-8", errors="replace"))
self.assertFalse(list(self.directory.glob("owrt-remote-*")), "CGI temporary files must be removed")
leftovers = [path for path in self.directory.glob("owrt-remote-*") if path.name != "owrt-remote-heartbeat-last"]
self.assertFalse(leftovers, "CGI temporary files must be removed")
return result.stdout.decode("utf-8")
def test_mobile_smart_quotes_reproduce_uci_255_and_are_repaired(self):
@@ -219,7 +220,7 @@ logger() { :; }
response = self.post(script.replace("\n", "\r\n"))
self.assertIn("KIND=bad", response)
self.assertIn("Ошибка отправки Heartbeat после применения настроек", response)
self.assertIn("Failed to allocate uclient context", response)
self.assertIn("reason=http_client_context_failed", response)
self.assertNotIn("каждая команда должна быть на отдельной строке", response)
self.assertTrue(self.directory.joinpath("restarted").exists())