Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
49 changes: 26 additions & 23 deletions network/v11/ws_reverse.py
Original file line number Diff line number Diff line change
Expand Up @@ -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 (
Expand All @@ -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:
Expand All @@ -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:
Expand Down Expand Up @@ -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
42 changes: 42 additions & 0 deletions tests/test_on_ready_once.py
Original file line number Diff line number Diff line change
@@ -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()
97 changes: 97 additions & 0 deletions tests/test_ws_reverse_reconnect.py
Original file line number Diff line number Diff line change
@@ -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
11 changes: 11 additions & 0 deletions utils/event/discord_event.py
Original file line number Diff line number Diff line change
Expand Up @@ -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", {}))
Expand Down
Loading