diff --git a/network/v11/ws_reverse.py b/network/v11/ws_reverse.py index 3b22d8b..d7aa47f 100644 --- a/network/v11/ws_reverse.py +++ b/network/v11/ws_reverse.py @@ -32,16 +32,14 @@ def __init__(self, config: dict) -> None: if not self.config["use_universal_client"]: self.config["api_url"] = self.config["api_url"] or self.config["url"] self.config["event_url"] = self.config["event_url"] or self.config["url"] - self.connect_task: asyncio.Task | None = None + # 重连必须串行:并发的 reconnect() 若各自建立连接,会让下游服务器同时保留多条连接。 + self.reconnect_lock = asyncio.Lock() self.role: Literal["API", "Universal", "Event"] - self.ws: websockets.client.WebSocketClientProtocol + self.ws: websockets.client.WebSocketClientProtocol | None = None def is_ready(self) -> bool: - try: - return self.ws.open - except AttributeError: - return False + return self.ws is not None and self.ws.open def get_url(self) -> str: return ( @@ -64,19 +62,6 @@ async def create_connection(self) -> None: extra_headers=self.get_headers(), ) - async def reconnect(self) -> None: - # 先关闭旧连接,避免下游服务器保留旧连接拒绝新连接 - if hasattr(self, "ws"): - try: - await self.ws.close() - except Exception: - pass # 忽略关闭时的错误 - self.ws = None - - if not self.connect_task: - self.connect_task = asyncio.create_task(self.connect()) - await self.connect_task - async def connect(self) -> None: while True: try: @@ -91,7 +76,25 @@ async def connect(self) -> None: ) await asyncio.sleep(self.config["reconnect_interval"] / 1000) logger.info(f"成功连接到反向 WebSocket {self.role} 服务器: {self.get_url()}") - self.connect_task = None + + async def reconnect(self) -> None: + # 同一时间只允许一个重连流程,避免多个任务各自建立连接(重复连接)。 + async with self.reconnect_lock: + # 等锁期间可能已经有别的任务重连成功,直接复用。 + if self.is_ready(): + return + + # 先关闭旧连接,避免下游服务器保留旧连接拒绝新连接。 + # 旧连接关闭后 self.ws 才会被 connect() 重新赋值。 + old_ws = self.ws + self.ws = None + if old_ws is not None: + try: + await old_ws.close() + except Exception: + pass # 忽略关闭时的错误 + + await self.connect() async def send(self, data: dict) -> None: try: @@ -177,13 +180,13 @@ async def init_websocket_reverse_connection(config: dict) -> Callable: config = BASE_CONFIG | config if config["use_universal_client"]: client = UniversalClient(config) - client.connect_task = asyncio.create_task(client.connect()) + asyncio.create_task(client.reconnect()) asyncio.create_task(client.handle_api_requests()) return client.push_event else: api_client = APIClient(config) - api_client.connect_task = asyncio.create_task(api_client.connect()) + asyncio.create_task(api_client.reconnect()) asyncio.create_task(api_client.handle_api_requests()) event_client = EventClient(config) - event_client.connect_task = asyncio.create_task(event_client.connect()) + asyncio.create_task(event_client.reconnect()) return event_client.push_event diff --git a/tests/test_on_ready_once.py b/tests/test_on_ready_once.py new file mode 100644 index 0000000..661c6b4 --- /dev/null +++ b/tests/test_on_ready_once.py @@ -0,0 +1,42 @@ +"""on_ready 重复触发时不得重复初始化(避免反向 WS 重复连接、重复心跳任务)""" +from types import SimpleNamespace +from unittest.mock import AsyncMock, Mock + +import pytest + +import utils.event.discord_event as discord_event + + +@pytest.fixture +def patched_on_ready(monkeypatch): + monkeypatch.setattr(discord_event, "_initialized", False, raising=False) + monkeypatch.setattr( + discord_event, "client", SimpleNamespace(user=SimpleNamespace(name="bot")) + ) + monkeypatch.setattr(discord_event, "tree", SimpleNamespace(sync=AsyncMock())) + + init_connections = AsyncMock() + monkeypatch.setattr(discord_event, "init_connections", init_connections) + monkeypatch.setattr( + discord_event.heartbeat_event, "setup_heartbeat_event", AsyncMock() + ) + monkeypatch.setattr( + discord_event, "get_status", AsyncMock(return_value={"data": {}}) + ) + monkeypatch.setattr(discord_event, "init_database", AsyncMock()) + monkeypatch.setattr(discord_event, "start_cleanup_loop", AsyncMock()) + monkeypatch.setattr(discord_event.event, "new_event", Mock()) + return SimpleNamespace( + init_connections=init_connections, + init_database=discord_event.init_database, + ) + + +async def test_on_ready_runs_initialization_only_once(patched_on_ready): + await discord_event.on_ready() + # discord.py 在 RESUME 失败后会重新派发 READY,on_ready 会再次触发 + await discord_event.on_ready() + await discord_event.on_ready() + + patched_on_ready.init_connections.assert_awaited_once() + patched_on_ready.init_database.assert_awaited_once() diff --git a/tests/test_ws_reverse_reconnect.py b/tests/test_ws_reverse_reconnect.py new file mode 100644 index 0000000..c95ee6c --- /dev/null +++ b/tests/test_ws_reverse_reconnect.py @@ -0,0 +1,97 @@ +"""OneBot V11 反向 WebSocket 重连:并发重连时不得重复建立连接""" +import asyncio +from types import SimpleNamespace + +import pytest + +import network.v11.ws_reverse as ws_reverse +from websockets.legacy.server import serve + + +@pytest.fixture(autouse=True) +def stub_discord_client(monkeypatch): + # 未登录时 discord.Client.user 为 None,构造 X-Self-ID 头会失败 + monkeypatch.setattr( + ws_reverse, "client", SimpleNamespace(user=SimpleNamespace(id=1)) + ) + + +@pytest.fixture +async def reverse_ws_server(): + active = set() + + async def handler(websocket): + active.add(websocket) + try: + async for _ in websocket: + pass + except Exception: + pass + finally: + active.discard(websocket) + + server = await serve(handler, "127.0.0.1", 0) + port = server.sockets[0].getsockname()[1] + try: + yield f"ws://127.0.0.1:{port}", active + finally: + for websocket in list(active): + await websocket.close() + server.close() + await server.wait_closed() + + +async def wait_for(predicate, timeout: float = 2.0, interval: float = 0.01) -> None: + deadline = asyncio.get_running_loop().time() + timeout + while not predicate(): + if asyncio.get_running_loop().time() > deadline: + raise AssertionError("等待条件超时") + await asyncio.sleep(interval) + + +async def drop_connection(active: set) -> None: + for websocket in list(active): + await websocket.close() + await wait_for(lambda: not active) + + +async def test_single_reconnect_keeps_one_connection(reverse_ws_server): + url, active = reverse_ws_server + client = ws_reverse.EventClient({"url": url, "reconnect_interval": 20}) + + await client.reconnect() + await wait_for(lambda: len(active) == 1) + + await drop_connection(active) + await wait_for(lambda: not client.is_ready()) + + await client.reconnect() + await wait_for(lambda: len(active) == 1) + assert len(active) == 1 + + +async def test_concurrent_reconnect_keeps_one_connection(reverse_ws_server): + url, active = reverse_ws_server + client = ws_reverse.EventClient({"url": url, "reconnect_interval": 20}) + + await client.reconnect() + await wait_for(lambda: len(active) == 1) + + await drop_connection(active) + await wait_for(lambda: not client.is_ready()) + + # 模拟 close() 因 close_timeout 卡住、且各调用完成时间不同: + # 旧实现会把等待 close 的任务错开成多次 connect(),每次各建一条连接。 + original_close = client.ws.close + delays = [0.0, 0.05, 0.1, 0.15] + + async def slow_close(*args, **kwargs): + await asyncio.sleep(delays.pop(0) if delays else 0.2) + return await original_close(*args, **kwargs) + + client.ws.close = slow_close + + await asyncio.gather(*(client.reconnect() for _ in range(4))) + await asyncio.sleep(0.1) + + assert len(active) == 1 diff --git a/utils/event/discord_event.py b/utils/event/discord_event.py index f695e7b..91d7857 100644 --- a/utils/event/discord_event.py +++ b/utils/event/discord_event.py @@ -17,14 +17,25 @@ logger = get_logger() +_initialized = False + @client.event async def on_ready() -> None: + global _initialized logger.info(f"成功登陆到 {client.user}") + if _initialized: + # discord.py 在 RESUME 失败等原因重新 IDENTIFY 后会再次派发 READY, + # on_ready 会被重复调用。此时反向 WebSocket、心跳、缓存清理等任务仍在运行, + # 重复初始化会让每条反向 WebSocket 再建立一条连接(表现为重复连接)。 + logger.info("检测到 on_ready 重复触发,跳过重复初始化") + return for guild in config["system"].get("sync_guilds", []): await tree.sync(guild=Object(id=int(guild))) if config["system"].get("sync_globally", False): await tree.sync() + # 从创建连接开始就不能再来一遍:重复执行会让每条反向 WebSocket 各多一条连接 + _initialized = True await init_connections(config["servers"]) asyncio.create_task( heartbeat_event.setup_heartbeat_event(config["system"].get("heartbeat", {}))