zapret-kvn/tests/test_xray_single_node_fallback.py
loop-uh 5ae15730c3
Some checks failed
Windows project source guards / test (push) Has been cancelled
Xray: если управляющий порт ядра не отвечает, сайдкар запускается с пулом из одного выбранного сервера
Причина молчания порта API на части ПК не найдена (на Linux не воспроизводится). Пока xray api bo не
дозвонился после трёх повторов, запуск VLESS падал. Теперь ядро перезапускается с одним выбранным
сервером в пуле: балансировщик выбирает его без вызова xray api. Режим держится до выхода из
приложения, смена сервера в нём идёт перезапуском; отказ по-прежнему пишется в журнал.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 11:41:25 -05:00

137 lines
7.2 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""Аварийный режим Xray: управляющий порт молчит — ядро работает с пулом из одного сервера."""
from __future__ import annotations
from copy import deepcopy
from types import SimpleNamespace
from unittest import TestCase
from unittest.mock import Mock
from tests.step_fakes import bridge_controller, drive
from xray_fluent.application.controller import AppController
from xray_fluent.application.outbound_pool_service import (
XRAY_OUTBOUND_PREFIX,
single_node_xray_config,
xray_outbound_tag,
)
TAGS = [xray_outbound_tag(f"node-{index}") for index in range(4)]
SELECTED = TAGS[2]
def sidecar_config() -> dict:
return {
"inbounds": [{"tag": "__app_hybrid_relay_in", "port": 11808, "protocol": "socks"}],
"outbounds": [{"tag": tag, "protocol": "vless"} for tag in TAGS]
+ [{"tag": "direct", "protocol": "freedom"}, {"tag": "proxy", "protocol": "vless"}],
"routing": {"balancers": [{"tag": "__app_proxy_selector", "selector": [XRAY_OUTBOUND_PREFIX]}]},
"api": {"tag": "__app_sidecar_api", "services": ["RoutingService"]},
}
def make_plan(config: dict, selected: str = SELECTED) -> SimpleNamespace:
sidecar = SimpleNamespace(
config=config, relay_port=11809, context=None, protect_port=11810, protect_password="", api_port=19085,
outbound_pool_tags={},
)
return SimpleNamespace(
amnezia_sidecar=None, provider_payload=None, hysteria_sidecar=None, xray_sidecar=sidecar,
used_selected_node=True, clash_api_port=0, is_hybrid=True, selected_outbound_tag=selected,
hybrid_relay_selected_tag="proxy", singbox_config={},
)
def make_controller(*, control_plane_ok: bool, single_node: bool = False) -> Mock:
controller = bridge_controller(Mock())
controller._transition_generation = 1
controller._desired_connected = True
controller._active_singbox_plan = None
controller._xray_single_node_pool = single_node
controller._rejected_xray_tags = lambda: []
controller._xray_single_node_fallback_steps = lambda plan: AppController._xray_single_node_fallback_steps(controller, plan)
controller.xray.start.return_value = True
# Дальше по цепочке запуск sing-box: он нарочно падает, чтобы разбор останавливался после Xray.
controller.singbox.start.return_value = False
controller._apply_core_outbound_tag.side_effect = lambda core, *_a, **_k: True if core != "xray" else control_plane_ok
return controller
class SingleNodeConfigTests(TestCase):
def test_only_the_selected_pool_outbound_survives_and_other_outbounds_are_kept(self) -> None:
original = sidecar_config()
reduced = single_node_xray_config(original, SELECTED)
tags = [item["tag"] for item in reduced["outbounds"]]
self.assertEqual(tags, [SELECTED, "direct", "proxy"])
self.assertEqual(reduced["routing"], original["routing"]) # балансировщик остаётся, в пуле один член
self.assertEqual(len(original["outbounds"]), 6, "исходный конфиг не меняется")
def test_unknown_selected_tag_or_bad_config_gives_none(self) -> None:
self.assertIsNone(single_node_xray_config(sidecar_config(), xray_outbound_tag("missing")))
self.assertIsNone(single_node_xray_config({"outbounds": "oops"}, SELECTED))
self.assertIsNone(single_node_xray_config({}, SELECTED))
class StartupFallbackTests(TestCase):
def run_start(self, controller: Mock, plan: SimpleNamespace) -> bool:
return drive(AppController._start_singbox_runtime_plan_steps(controller, plan))
def test_failed_control_plane_restarts_xray_with_a_single_node_pool(self) -> None:
controller = make_controller(control_plane_ok=False)
config = sidecar_config()
plan = make_plan(deepcopy(config))
self.run_start(controller, plan)
self.assertEqual(controller.xray.start.call_count, 2, "первый запуск и перезапуск")
first_config = controller.xray.start.call_args_list[0].args[1]
second_config = controller.xray.start.call_args_list[1].args[1]
self.assertEqual(len(first_config["outbounds"]), 6)
self.assertEqual([item["tag"] for item in second_config["outbounds"]], [SELECTED, "direct", "proxy"])
self.assertIs(controller._xray_single_node_pool, True)
controller.xray.stop.assert_called() # перед перезапуском
xray_calls = [call for call in controller._apply_core_outbound_tag.call_args_list if call.args[0] == "xray"]
self.assertEqual(len(xray_calls), 1, "управляющий порт спрошен один раз")
def test_in_single_node_mode_the_control_plane_is_not_called_at_all(self) -> None:
controller = make_controller(control_plane_ok=False, single_node=True)
plan = make_plan(sidecar_config())
self.run_start(controller, plan)
self.assertEqual(controller.xray.start.call_count, 1)
xray_calls = [call for call in controller._apply_core_outbound_tag.call_args_list if call.args[0] == "xray"]
self.assertEqual(xray_calls, [])
def test_a_healthy_control_plane_keeps_the_full_pool(self) -> None:
controller = make_controller(control_plane_ok=True)
plan = make_plan(sidecar_config())
self.run_start(controller, plan)
self.assertEqual(controller.xray.start.call_count, 1)
self.assertIsNot(controller._xray_single_node_pool, True)
def test_when_the_fallback_is_impossible_startup_fails_and_xray_is_stopped(self) -> None:
controller = make_controller(control_plane_ok=False)
plan = make_plan(sidecar_config(), selected=xray_outbound_tag("missing"))
self.assertFalse(self.run_start(controller, plan))
self.assertEqual(controller.xray.start.call_count, 1)
controller.xray.stop.assert_called()
self.assertIsNot(controller._xray_single_node_pool, True)
def test_a_failed_restart_does_not_leave_the_mode_on(self) -> None:
controller = make_controller(control_plane_ok=False)
controller.xray.start.side_effect = [True, False]
plan = make_plan(sidecar_config())
self.assertFalse(self.run_start(controller, plan))
self.assertIsNot(controller._xray_single_node_pool, True)
class ModeGuardsTests(TestCase):
def test_pool_candidates_shrink_to_the_selected_node_in_the_mode(self) -> None:
selected = SimpleNamespace(id="a")
controller = SimpleNamespace(
_xray_single_node_pool=True, state=SimpleNamespace(nodes=[selected, SimpleNamespace(id="b")]),
_xray_pool_quarantine_reasons=lambda: {},
)
self.assertEqual(AppController._pool_candidate_nodes(controller, selected), [selected])
controller._xray_single_node_pool = False
self.assertEqual(len(AppController._pool_candidate_nodes(controller, selected)), 2)
def test_hot_switch_goes_through_a_restart_in_the_mode(self) -> None:
controller = SimpleNamespace(_xray_single_node_pool=True, _log=Mock())
self.assertIsNone(AppController._hot_switch_precheck(controller))
controller._log.assert_not_called()