feat: 实现 Python 与 Java SDK 连接收发及其余接口
This commit is contained in:
Nixevol
@@ -0,0 +1,988 @@
|
||||
"""NixMsg 同步客户端。"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import random
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from collections import OrderedDict
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Any, Optional
|
||||
|
||||
from .errors import ClosedError, NixMsgError, NotConnectedError
|
||||
from .protocol import dumps, down_topic, loads, normalize_mqtt_ws_url, register_url_from_connect, up_topic
|
||||
from .transport import ConnectParams, FakeTransport, PahoTransport, Transport
|
||||
from .types import (
|
||||
BACKOFF_INITIAL_S,
|
||||
BACKOFF_JITTER,
|
||||
BACKOFF_MAX_S,
|
||||
CLIENT_NAME,
|
||||
CONNECT_TIMEOUT_S,
|
||||
DEDUP_CAPACITY,
|
||||
DEFAULT_MAX_BODY,
|
||||
DEFAULT_MAX_FRAME,
|
||||
DEFAULT_MAX_META,
|
||||
INFLIGHT_LIMIT,
|
||||
MIN_MAX_RECEIVE,
|
||||
SEND_QUEUE_LIMIT,
|
||||
STABLE_RESET_S,
|
||||
Body,
|
||||
ConnectionEvent,
|
||||
ConnectionHandler,
|
||||
ConnectionState,
|
||||
GroupEvent,
|
||||
GroupEventHandler,
|
||||
HelloLimits,
|
||||
IncomingMessage,
|
||||
MessageHandler,
|
||||
PresenceEvent,
|
||||
PresenceHandler,
|
||||
Receipt,
|
||||
ReceiptHandler,
|
||||
RegisterOptions,
|
||||
RegisterResult,
|
||||
RecallResult,
|
||||
RevokedEvent,
|
||||
RevokedHandler,
|
||||
SendOptions,
|
||||
SendResult,
|
||||
SessionHandler,
|
||||
Target,
|
||||
)
|
||||
from .uuid7 import new_uuid7
|
||||
|
||||
log = logging.getLogger("nixmsg")
|
||||
|
||||
|
||||
@dataclass
|
||||
class _PendingReq:
|
||||
rid: str
|
||||
frame: dict[str, Any]
|
||||
event: threading.Event = field(default_factory=threading.Event)
|
||||
response: Optional[dict[str, Any]] = None
|
||||
error: Optional[BaseException] = None
|
||||
is_send: bool = False
|
||||
message_id: str = ""
|
||||
|
||||
|
||||
@dataclass
|
||||
class _SendItem:
|
||||
message_id: str
|
||||
frame: dict[str, Any] # 已含 send_at_ms，重交不改
|
||||
pending: _PendingReq
|
||||
|
||||
|
||||
class _DedupState:
|
||||
DELIVERED = "delivered" # 已交应用未确认
|
||||
ACKED = "acked"
|
||||
|
||||
|
||||
class Client:
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
transport: Optional[Transport] = None,
|
||||
auto_ack: bool = True,
|
||||
max_receive_bytes: int = DEFAULT_MAX_FRAME,
|
||||
client_name: str = CLIENT_NAME,
|
||||
connect_timeout_s: float = CONNECT_TIMEOUT_S,
|
||||
) -> None:
|
||||
self._transport: Transport = transport or PahoTransport()
|
||||
self._auto_ack = auto_ack
|
||||
self._max_receive_bytes = max(MIN_MAX_RECEIVE, max_receive_bytes)
|
||||
self._client_name = client_name
|
||||
self._connect_timeout_s = connect_timeout_s
|
||||
|
||||
self._session_handler: Optional[SessionHandler] = None
|
||||
self._message_handler: Optional[MessageHandler] = None
|
||||
self._receipt_handler: Optional[ReceiptHandler] = None
|
||||
self._revoked_handler: Optional[RevokedHandler] = None
|
||||
self._presence_handler: Optional[PresenceHandler] = None
|
||||
self._group_handler: Optional[GroupEventHandler] = None
|
||||
self._connection_handler: Optional[ConnectionHandler] = None
|
||||
|
||||
self._lock = threading.RLock()
|
||||
self._cb_lock = threading.Lock() # 回调串行
|
||||
self._state = ConnectionState.OFFLINE
|
||||
self._stop_reconnect = False
|
||||
self._closed = False
|
||||
self._user_close = False
|
||||
self._url = ""
|
||||
self._endpoint_id = ""
|
||||
self._password: Optional[str] = None
|
||||
self._session_token: Optional[str] = None
|
||||
self._use_token = False
|
||||
self._use_tcp = False
|
||||
self._limits = HelloLimits()
|
||||
self._clock_skew_ms = 0
|
||||
self._online_since = 0.0
|
||||
self._backoff_s = BACKOFF_INITIAL_S
|
||||
self._rid_seq = 0
|
||||
self._pending: dict[str, _PendingReq] = {}
|
||||
self._send_queue: list[_SendItem] = []
|
||||
self._inflight_sends = 0
|
||||
self._dedup: OrderedDict[str, str] = OrderedDict()
|
||||
self._receipt_seen: OrderedDict[str, bool] = OrderedDict()
|
||||
self._watch_ids: Optional[list[str]] = None
|
||||
self._watch_all = False
|
||||
self._conn_event = threading.Event()
|
||||
self._handshake_error: Optional[BaseException] = None
|
||||
self._worker: Optional[threading.Thread] = None
|
||||
self._wake = threading.Event()
|
||||
self._want_connected = False
|
||||
|
||||
self._transport.set_handlers(self._on_transport_connected, self._on_transport_disconnected, self._on_down)
|
||||
|
||||
# ---- 回调注册 ----
|
||||
def on_session(self, handler: SessionHandler) -> None:
|
||||
self._session_handler = handler
|
||||
|
||||
def on_message(self, handler: MessageHandler) -> None:
|
||||
self._message_handler = handler
|
||||
|
||||
def on_receipt(self, handler: ReceiptHandler) -> None:
|
||||
self._receipt_handler = handler
|
||||
|
||||
def on_revoked(self, handler: RevokedHandler) -> None:
|
||||
self._revoked_handler = handler
|
||||
|
||||
def on_presence(self, handler: PresenceHandler) -> None:
|
||||
self._presence_handler = handler
|
||||
|
||||
def on_group_event(self, handler: GroupEventHandler) -> None:
|
||||
self._group_handler = handler
|
||||
|
||||
def on_connection(self, handler: ConnectionHandler) -> None:
|
||||
self._connection_handler = handler
|
||||
|
||||
# ---- 连接 ----
|
||||
def connect(
|
||||
self,
|
||||
url: str,
|
||||
endpoint_id: str,
|
||||
*,
|
||||
password: Optional[str] = None,
|
||||
session_token: Optional[str] = None,
|
||||
use_tcp: bool = False,
|
||||
wait: bool = True,
|
||||
) -> None:
|
||||
if password is None and session_token is None:
|
||||
raise ValueError("需要 password 或 session_token")
|
||||
with self._lock:
|
||||
if self._closed:
|
||||
raise ClosedError()
|
||||
self._url = normalize_mqtt_ws_url(url) if not use_tcp else url
|
||||
self._endpoint_id = endpoint_id
|
||||
self._password = password
|
||||
self._session_token = session_token
|
||||
self._use_token = session_token is not None and password is None
|
||||
self._use_tcp = use_tcp
|
||||
self._stop_reconnect = False
|
||||
self._user_close = False
|
||||
self._want_connected = True
|
||||
self._handshake_error = None
|
||||
self._conn_event.clear()
|
||||
self._set_state(ConnectionState.CONNECTING)
|
||||
if self._worker is None or not self._worker.is_alive():
|
||||
self._worker = threading.Thread(target=self._run_loop, name="nixmsg-client", daemon=True)
|
||||
self._worker.start()
|
||||
self._wake.set()
|
||||
if wait:
|
||||
if not self._conn_event.wait(self._connect_timeout_s + 5):
|
||||
raise NixMsgError("busy", "连接超时")
|
||||
err = self._handshake_error
|
||||
if err:
|
||||
raise err
|
||||
if self._state not in (ConnectionState.ONLINE,):
|
||||
if self._state == ConnectionState.AUTH_FAILED:
|
||||
raise NixMsgError(
|
||||
getattr(self, "_auth_reason", "bad_credentials"),
|
||||
"认证失败",
|
||||
)
|
||||
if self._state == ConnectionState.KICKED:
|
||||
raise NixMsgError("taken_over", "会话被接管")
|
||||
raise NixMsgError("busy", f"连接未成功: {self._state.value}")
|
||||
|
||||
def close(self) -> None:
|
||||
with self._lock:
|
||||
self._user_close = True
|
||||
self._want_connected = False
|
||||
self._stop_reconnect = True
|
||||
self._closed = True
|
||||
self._fail_all_pending(ClosedError())
|
||||
self._set_state(ConnectionState.OFFLINE)
|
||||
try:
|
||||
self._transport.disconnect()
|
||||
except Exception:
|
||||
pass
|
||||
self._wake.set()
|
||||
|
||||
def logout(self) -> None:
|
||||
try:
|
||||
self._request({"type": "self.logout"}, wait=True)
|
||||
except Exception:
|
||||
pass
|
||||
with self._lock:
|
||||
self._stop_reconnect = True
|
||||
self._want_connected = False
|
||||
self._session_token = None
|
||||
self._fail_all_pending(NixMsgError("auth_failed", "已退出登录"))
|
||||
try:
|
||||
self._transport.disconnect()
|
||||
except Exception:
|
||||
pass
|
||||
self._set_state(ConnectionState.OFFLINE)
|
||||
self._wake.set()
|
||||
|
||||
# ---- 发送 / 确认 ----
|
||||
def send(self, to: Target, body: Body | str | bytes, options: Optional[SendOptions] = None) -> SendResult:
|
||||
options = options or SendOptions()
|
||||
if isinstance(body, str):
|
||||
body = Body(data=body)
|
||||
elif isinstance(body, bytes):
|
||||
import base64
|
||||
|
||||
body = Body(data=base64.b64encode(body).decode("ascii"), enc="base64")
|
||||
if options.content_type:
|
||||
body.content_type = options.content_type
|
||||
|
||||
with self._lock:
|
||||
if self._closed:
|
||||
raise ClosedError()
|
||||
if len(self._send_queue) >= SEND_QUEUE_LIMIT:
|
||||
raise NixMsgError("quota_exceeded", "发送队列已满")
|
||||
|
||||
max_body = self._limits.max_body_bytes or DEFAULT_MAX_BODY
|
||||
max_meta = self._limits.max_meta_bytes or DEFAULT_MAX_META
|
||||
max_frame = self._limits.max_frame_bytes or DEFAULT_MAX_FRAME
|
||||
|
||||
if body.decoded_size() > max_body:
|
||||
raise NixMsgError("body_too_large", "正文超限")
|
||||
|
||||
meta = options.meta or {}
|
||||
meta_bytes = dumps({"meta": meta}) # 近似；真正检查序列化后 meta 对象
|
||||
# 精确：meta 单独序列化
|
||||
meta_raw = dumps(meta) if meta else b"{}"
|
||||
if len(meta_raw) > max_meta:
|
||||
raise NixMsgError("meta_too_large", "自定义字段超限")
|
||||
|
||||
msg_id = options.message_id or new_uuid7()
|
||||
frame: dict[str, Any] = {
|
||||
"v": 1,
|
||||
"type": "send",
|
||||
"id": msg_id,
|
||||
"to": to.to_dict(),
|
||||
"body": body.to_dict(),
|
||||
}
|
||||
if meta:
|
||||
frame["meta"] = meta
|
||||
|
||||
# send_at_ms 在入队时固定，重交不重算
|
||||
if options.send_at_ms is not None:
|
||||
frame["send_at_ms"] = int(options.send_at_ms)
|
||||
elif options.send_at is not None:
|
||||
# 本机语义时间 + 偏差
|
||||
local_ms = int(options.send_at * 1000) if options.send_at < 1e12 else int(options.send_at)
|
||||
frame["send_at_ms"] = local_ms + self._clock_skew_ms
|
||||
elif options.delay_ms is not None:
|
||||
frame["delay_ms"] = int(options.delay_ms)
|
||||
|
||||
if options.keep:
|
||||
offline: dict[str, Any] = {"keep": True}
|
||||
if options.ttl_seconds is not None:
|
||||
offline["ttl_seconds"] = int(options.ttl_seconds)
|
||||
frame["offline"] = offline
|
||||
if not options.receipt:
|
||||
frame["receipt"] = False
|
||||
if options.talk_password:
|
||||
frame["talk_password"] = options.talk_password
|
||||
|
||||
# 帧大小本地检查（含 rid 占位）
|
||||
probe = dict(frame)
|
||||
probe["rid"] = "0" * 8
|
||||
raw = dumps(probe)
|
||||
if len(raw) > max_frame:
|
||||
raise NixMsgError("frame_too_large", "整帧超限")
|
||||
|
||||
pending = _PendingReq(rid="", frame=frame, is_send=True, message_id=msg_id)
|
||||
item = _SendItem(message_id=msg_id, frame=frame, pending=pending)
|
||||
self._send_queue.append(item)
|
||||
self._wake.set()
|
||||
|
||||
if not pending.event.wait(timeout=None if self._state == ConnectionState.ONLINE else 3600):
|
||||
raise NixMsgError("busy", "发送等待中断")
|
||||
if pending.error:
|
||||
raise pending.error
|
||||
assert pending.response is not None
|
||||
data = pending.response.get("data") or {}
|
||||
return SendResult(id=data.get("id", msg_id), send_at_ms=int(data.get("send_at_ms", 0)), state=str(data.get("state", "")))
|
||||
|
||||
def ack(self, message: IncomingMessage) -> None:
|
||||
self._send_ack(message.from_id, message.id, mark_acked=True)
|
||||
|
||||
# ---- 其余接口 ----
|
||||
def recall(self, message_id: str) -> RecallResult:
|
||||
resp = self._request({"type": "recall", "id": message_id})
|
||||
data = resp.get("data") or {}
|
||||
return RecallResult(
|
||||
result=str(data.get("result", "")),
|
||||
recalled=int(data.get("recalled", 0)),
|
||||
accepted=int(data.get("accepted", 0)),
|
||||
other=int(data.get("other", 0)),
|
||||
)
|
||||
|
||||
def status(self, message_id: str, cursor: str = "", limit: int = 100) -> dict[str, Any]:
|
||||
return self._request({"type": "status", "id": message_id, "cursor": cursor, "limit": limit})
|
||||
|
||||
def unlock(self, endpoint_id: str, talk_password: str) -> dict[str, Any]:
|
||||
return self._request({"type": "unlock", "endpoint_id": endpoint_id, "talk_password": talk_password})
|
||||
|
||||
def presence(self, ids: list[str]) -> dict[str, Any]:
|
||||
return self._request({"type": "presence.get", "ids": ids})
|
||||
|
||||
def directory(self, cursor: str = "", query: str = "", limit: int = 100) -> dict[str, Any]:
|
||||
return self._request({"type": "directory.list", "cursor": cursor, "limit": limit, "query": query})
|
||||
|
||||
def watch_presence(self, ids: Optional[list[str]] = None, *, all: bool = False) -> dict[str, Any]:
|
||||
with self._lock:
|
||||
self._watch_ids = list(ids) if ids is not None else None
|
||||
self._watch_all = all
|
||||
frame: dict[str, Any] = {"type": "presence.watch", "all": all}
|
||||
if ids is not None:
|
||||
frame["ids"] = ids
|
||||
return self._request(frame)
|
||||
|
||||
def get_self(self) -> dict[str, Any]:
|
||||
return self._request({"type": "self.get"})
|
||||
|
||||
def update_self(self, *, name: Optional[str] = None, default_delay_ms: Optional[int] = None) -> dict[str, Any]:
|
||||
frame: dict[str, Any] = {"type": "self.update"}
|
||||
if name is not None:
|
||||
frame["name"] = name
|
||||
if default_delay_ms is not None:
|
||||
frame["default_delay_ms"] = default_delay_ms
|
||||
return self._request(frame)
|
||||
|
||||
def set_talk_password(self, talk_password: str) -> dict[str, Any]:
|
||||
return self._request({"type": "self.talk_password", "talk_password": talk_password})
|
||||
|
||||
def change_login_password(self, old_password: str, new_password: str) -> dict[str, Any]:
|
||||
resp = self._request({"type": "self.login_password", "old_password": old_password, "new_password": new_password})
|
||||
data = resp.get("data") or {}
|
||||
token = data.get("session_token")
|
||||
if token:
|
||||
with self._lock:
|
||||
self._session_token = token
|
||||
self._use_token = True
|
||||
self._fire_session(token)
|
||||
return resp
|
||||
|
||||
def group_create(self, name: str, members: list[dict[str, str]], group_id: str = "") -> dict[str, Any]:
|
||||
frame: dict[str, Any] = {"type": "group.create", "name": name, "members": members}
|
||||
if group_id:
|
||||
frame["id"] = group_id
|
||||
else:
|
||||
frame["id"] = ""
|
||||
return self._request(frame)
|
||||
|
||||
def group_add(self, group_id: str, members: list[dict[str, str]]) -> dict[str, Any]:
|
||||
return self._request({"type": "group.add", "group_id": group_id, "members": members})
|
||||
|
||||
def group_remove(self, group_id: str, endpoint_id: str) -> dict[str, Any]:
|
||||
return self._request({"type": "group.remove", "group_id": group_id, "endpoint_id": endpoint_id})
|
||||
|
||||
def group_leave(self, group_id: str) -> dict[str, Any]:
|
||||
return self._request({"type": "group.leave", "group_id": group_id})
|
||||
|
||||
def group_transfer(self, group_id: str, endpoint_id: str) -> dict[str, Any]:
|
||||
return self._request({"type": "group.transfer", "group_id": group_id, "endpoint_id": endpoint_id})
|
||||
|
||||
def group_rename(self, group_id: str, name: str) -> dict[str, Any]:
|
||||
return self._request({"type": "group.rename", "group_id": group_id, "name": name})
|
||||
|
||||
def group_dissolve(self, group_id: str) -> dict[str, Any]:
|
||||
return self._request({"type": "group.dissolve", "group_id": group_id})
|
||||
|
||||
def group_list(self, cursor: str = "", limit: int = 100) -> dict[str, Any]:
|
||||
return self._request({"type": "group.list", "cursor": cursor, "limit": limit})
|
||||
|
||||
def group_get(self, group_id: str, cursor: str = "", limit: int = 100) -> dict[str, Any]:
|
||||
return self._request({"type": "group.get", "group_id": group_id, "cursor": cursor, "limit": limit})
|
||||
|
||||
@staticmethod
|
||||
def register(url: str, registration_code: str, options: Optional[RegisterOptions] = None) -> RegisterResult:
|
||||
options = options or RegisterOptions()
|
||||
reg_url = register_url_from_connect(url)
|
||||
body = {
|
||||
"registration_code": registration_code,
|
||||
"id": options.id or "",
|
||||
"login_password": options.login_password or "",
|
||||
"name": options.name or "",
|
||||
"talk_password": options.talk_password or "",
|
||||
}
|
||||
raw = dumps(body)
|
||||
req = urllib.request.Request(
|
||||
reg_url,
|
||||
data=raw,
|
||||
headers={"Content-Type": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=30) as resp:
|
||||
data = loads(resp.read())
|
||||
except urllib.error.HTTPError as e:
|
||||
try:
|
||||
data = loads(e.read())
|
||||
except Exception:
|
||||
raise NixMsgError("bad_request", f"HTTP {e.code}") from e
|
||||
err = data.get("error") or {}
|
||||
raise NixMsgError(str(err.get("code", "bad_request")), str(err.get("message", ""))) from e
|
||||
if not data.get("ok"):
|
||||
err = data.get("error") or {}
|
||||
raise NixMsgError(str(err.get("code", "bad_request")), str(err.get("message", "")))
|
||||
d = data.get("data") or {}
|
||||
return RegisterResult(id=str(d.get("id", "")), login_password=d.get("login_password"))
|
||||
|
||||
# ---- 内部：连接循环 ----
|
||||
def _run_loop(self) -> None:
|
||||
while True:
|
||||
with self._lock:
|
||||
if self._closed and not self._want_connected:
|
||||
return
|
||||
want = self._want_connected and not self._stop_reconnect
|
||||
state = self._state
|
||||
if not want:
|
||||
self._wake.wait(0.5)
|
||||
self._wake.clear()
|
||||
continue
|
||||
if state == ConnectionState.ONLINE:
|
||||
self._pump_sends()
|
||||
# 稳定 60 秒后恢复退避
|
||||
if self._online_since and time.monotonic() - self._online_since >= STABLE_RESET_S:
|
||||
self._backoff_s = BACKOFF_INITIAL_S
|
||||
self._wake.wait(0.2)
|
||||
self._wake.clear()
|
||||
continue
|
||||
# 尝试连接
|
||||
try:
|
||||
self._attempt_connect()
|
||||
except Exception as e:
|
||||
log.debug("connect attempt failed: %s", e)
|
||||
with self._lock:
|
||||
if self._state == ConnectionState.ONLINE:
|
||||
continue
|
||||
if self._stop_reconnect or not self._want_connected:
|
||||
continue
|
||||
delay = self._jitter(self._backoff_s)
|
||||
self._backoff_s = min(BACKOFF_MAX_S, self._backoff_s * 2)
|
||||
self._set_state(ConnectionState.RECONNECTING)
|
||||
self._wake.wait(delay)
|
||||
self._wake.clear()
|
||||
|
||||
def _attempt_connect(self) -> None:
|
||||
with self._lock:
|
||||
if self._stop_reconnect or not self._want_connected:
|
||||
return
|
||||
self._set_state(ConnectionState.CONNECTING if self._state == ConnectionState.OFFLINE else ConnectionState.RECONNECTING)
|
||||
self._handshake_error = None
|
||||
url = self._url
|
||||
eid = self._endpoint_id
|
||||
if self._session_token:
|
||||
cred = self._session_token
|
||||
using_token = True
|
||||
else:
|
||||
cred = self._password or ""
|
||||
using_token = False
|
||||
self._connecting_with_token = using_token
|
||||
use_tcp = self._use_tcp
|
||||
timeout = self._connect_timeout_s
|
||||
|
||||
self._conn_event.clear()
|
||||
params = ConnectParams(
|
||||
url=url,
|
||||
client_id=eid,
|
||||
username=eid,
|
||||
password=cred,
|
||||
clean_start=True,
|
||||
session_expiry=0,
|
||||
timeout_s=timeout,
|
||||
use_tcp=use_tcp,
|
||||
)
|
||||
self._transport.connect(params)
|
||||
# 等待握手完成或失败
|
||||
ok = self._conn_event.wait(timeout)
|
||||
if not ok:
|
||||
try:
|
||||
self._transport.disconnect()
|
||||
except Exception:
|
||||
pass
|
||||
with self._lock:
|
||||
self._handshake_error = NixMsgError("busy", "连接超时")
|
||||
return
|
||||
|
||||
def _on_transport_connected(self) -> None:
|
||||
try:
|
||||
topic = down_topic(self._endpoint_id)
|
||||
self._transport.subscribe(topic)
|
||||
rid = self._next_rid()
|
||||
hello = {
|
||||
"v": 1,
|
||||
"type": "hello",
|
||||
"rid": rid,
|
||||
"max_receive_bytes": self._max_receive_bytes,
|
||||
"client": self._client_name,
|
||||
}
|
||||
t0 = time.time()
|
||||
pending = _PendingReq(rid=rid, frame=hello)
|
||||
with self._lock:
|
||||
self._pending[rid] = pending
|
||||
self._transport.publish(up_topic(self._endpoint_id), dumps(hello))
|
||||
if not pending.event.wait(self._connect_timeout_s):
|
||||
raise NixMsgError("busy", "握手超时")
|
||||
if pending.error:
|
||||
raise pending.error
|
||||
assert pending.response is not None
|
||||
if not pending.response.get("ok"):
|
||||
err = (pending.response.get("error") or {})
|
||||
raise NixMsgError(str(err.get("code", "bad_request")), str(err.get("message", "")))
|
||||
t1 = time.time()
|
||||
data = pending.response.get("data") or {}
|
||||
limits = HelloLimits(
|
||||
server_time_ms=int(data.get("server_time_ms", 0)),
|
||||
server_version=str(data.get("server_version", "")),
|
||||
max_body_bytes=int(data.get("max_body_bytes", DEFAULT_MAX_BODY)),
|
||||
max_meta_bytes=int(data.get("max_meta_bytes", DEFAULT_MAX_META)),
|
||||
max_frame_bytes=int(data.get("max_frame_bytes", DEFAULT_MAX_FRAME)),
|
||||
max_ttl_seconds=int(data.get("max_ttl_seconds", 2592000)),
|
||||
max_schedule_seconds=int(data.get("max_schedule_seconds", 31536000)),
|
||||
ack_timeout_seconds=int(data.get("ack_timeout_seconds", 300)),
|
||||
session_token=str(data.get("session_token", "")),
|
||||
)
|
||||
skew = limits.server_time_ms - int(((t0 + t1) / 2) * 1000)
|
||||
with self._lock:
|
||||
self._limits = limits
|
||||
self._clock_skew_ms = skew
|
||||
self._online_since = time.monotonic()
|
||||
self._handshake_error = None
|
||||
self._set_state(ConnectionState.ONLINE)
|
||||
token = limits.session_token
|
||||
if token:
|
||||
with self._lock:
|
||||
self._session_token = token
|
||||
self._use_token = True
|
||||
self._fire_session(token)
|
||||
# 重连后恢复 presence.watch
|
||||
if self._watch_all or self._watch_ids is not None:
|
||||
try:
|
||||
frame: dict[str, Any] = {"type": "presence.watch", "all": self._watch_all}
|
||||
if self._watch_ids is not None:
|
||||
frame["ids"] = self._watch_ids
|
||||
self._request(frame, wait=False)
|
||||
except Exception:
|
||||
pass
|
||||
self._conn_event.set()
|
||||
self._wake.set()
|
||||
except Exception as e:
|
||||
with self._lock:
|
||||
self._handshake_error = e
|
||||
try:
|
||||
self._transport.disconnect()
|
||||
except Exception:
|
||||
pass
|
||||
self._conn_event.set()
|
||||
|
||||
def _on_transport_disconnected(self, reason: Optional[str], stop: bool) -> None:
|
||||
with self._lock:
|
||||
was_online = self._state == ConnectionState.ONLINE
|
||||
using_token = getattr(self, "_connecting_with_token", self._use_token)
|
||||
if reason == "taken_over":
|
||||
self._stop_reconnect = True
|
||||
self._want_connected = False
|
||||
self._fail_all_pending(NixMsgError("taken_over", "会话被接管"))
|
||||
self._set_state(ConnectionState.KICKED, "taken_over")
|
||||
self._conn_event.set()
|
||||
return
|
||||
if stop or reason in ("session_invalid", "bad_credentials", "banned"):
|
||||
# 令牌被拒 -> session_invalid；密码被拒 -> bad_credentials
|
||||
if reason in ("bad_credentials", "session_invalid", "banned") or stop:
|
||||
auth_reason = reason or "bad_credentials"
|
||||
if auth_reason == "bad_credentials" and using_token:
|
||||
auth_reason = "session_invalid"
|
||||
if auth_reason == "banned":
|
||||
auth_reason = "session_invalid" if using_token else "bad_credentials"
|
||||
self._auth_reason = auth_reason
|
||||
self._stop_reconnect = True
|
||||
self._want_connected = False
|
||||
self._fail_all_pending(NixMsgError(auth_reason, "认证失败"))
|
||||
self._handshake_error = NixMsgError(auth_reason, "认证失败")
|
||||
self._set_state(ConnectionState.AUTH_FAILED, auth_reason)
|
||||
self._conn_event.set()
|
||||
return
|
||||
# 网络 / busy：继续重连
|
||||
if self._user_close or self._closed:
|
||||
self._set_state(ConnectionState.OFFLINE)
|
||||
self._conn_event.set()
|
||||
return
|
||||
if was_online or self._state in (ConnectionState.CONNECTING, ConnectionState.RECONNECTING):
|
||||
self._set_state(ConnectionState.RECONNECTING, reason or "network")
|
||||
self._conn_event.set()
|
||||
self._wake.set()
|
||||
|
||||
def _on_down(self, payload: bytes) -> None:
|
||||
try:
|
||||
frame = loads(payload)
|
||||
except Exception:
|
||||
return
|
||||
ftype = frame.get("type")
|
||||
if ftype == "resp":
|
||||
rid = str(frame.get("rid", ""))
|
||||
with self._lock:
|
||||
pending = self._pending.pop(rid, None)
|
||||
if pending:
|
||||
pending.response = frame
|
||||
if pending.is_send:
|
||||
with self._lock:
|
||||
self._inflight_sends = max(0, self._inflight_sends - 1)
|
||||
# rate_limited 重交：清状态后不 set event
|
||||
err = (frame.get("error") or {}) if not frame.get("ok") else {}
|
||||
if not frame.get("ok") and str(err.get("code")) == "rate_limited":
|
||||
with self._lock:
|
||||
pending.rid = ""
|
||||
pending.response = None
|
||||
pending.error = None
|
||||
pending.event.clear()
|
||||
self._wake.set()
|
||||
return
|
||||
# 从发送队列移除
|
||||
with self._lock:
|
||||
self._send_queue = [it for it in self._send_queue if it.pending is not pending]
|
||||
if not frame.get("ok"):
|
||||
pending.error = NixMsgError(str(err.get("code", "bad_request")), str(err.get("message", "")))
|
||||
pending.event.set()
|
||||
self._wake.set()
|
||||
else:
|
||||
pending.event.set()
|
||||
return
|
||||
if ftype == "msg":
|
||||
self._handle_msg(frame)
|
||||
return
|
||||
if ftype == "receipt":
|
||||
self._handle_receipt(frame)
|
||||
return
|
||||
if ftype == "revoked":
|
||||
self._handle_revoked(frame)
|
||||
return
|
||||
if ftype == "presence":
|
||||
self._fire_presence(
|
||||
PresenceEvent(id=str(frame.get("id", "")), online=bool(frame.get("online")), at_ms=int(frame.get("at_ms", 0)))
|
||||
)
|
||||
return
|
||||
if ftype == "group_event":
|
||||
self._fire_group(
|
||||
GroupEvent(
|
||||
group_id=str(frame.get("group_id", "")),
|
||||
event=str(frame.get("event", "")),
|
||||
endpoint_id=str(frame.get("endpoint_id", "")),
|
||||
at_ms=int(frame.get("at_ms", 0)),
|
||||
)
|
||||
)
|
||||
return
|
||||
if ftype == "fatal":
|
||||
reason = str(frame.get("reason", "protocol"))
|
||||
with self._lock:
|
||||
self._stop_reconnect = True
|
||||
self._want_connected = False
|
||||
self._fail_all_pending(NixMsgError("fatal", reason))
|
||||
self._set_state(ConnectionState.AUTH_FAILED, reason)
|
||||
try:
|
||||
self._transport.disconnect()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def _handle_msg(self, frame: dict[str, Any]) -> None:
|
||||
mid = str(frame.get("id", ""))
|
||||
from_id = str(frame.get("from", ""))
|
||||
key = f"{from_id}\0{mid}"
|
||||
with self._lock:
|
||||
st = self._dedup.get(key)
|
||||
if st == _DedupState.ACKED:
|
||||
# 已确认再到达：再 ack，不交应用
|
||||
pass
|
||||
elif st == _DedupState.DELIVERED:
|
||||
# 已交未确认：忽略
|
||||
return
|
||||
else:
|
||||
st = None
|
||||
if st == _DedupState.ACKED:
|
||||
self._send_ack(from_id, mid, mark_acked=True)
|
||||
return
|
||||
|
||||
to_raw = frame.get("to") or {}
|
||||
msg = IncomingMessage(
|
||||
id=mid,
|
||||
from_id=from_id,
|
||||
to=Target(kind=str(to_raw.get("kind", "endpoint")), id=str(to_raw.get("id", ""))),
|
||||
body=Body(
|
||||
data=str((frame.get("body") or {}).get("data", "")),
|
||||
enc=str((frame.get("body") or {}).get("enc", "utf8")),
|
||||
content_type=(frame.get("body") or {}).get("content_type"),
|
||||
),
|
||||
send_at_ms=int(frame.get("send_at_ms", 0)),
|
||||
meta=dict(frame.get("meta") or {}),
|
||||
)
|
||||
with self._lock:
|
||||
self._dedup_put(key, _DedupState.DELIVERED)
|
||||
|
||||
if not self._message_handler:
|
||||
if self._auto_ack:
|
||||
self._send_ack(from_id, mid, mark_acked=True)
|
||||
return
|
||||
|
||||
try:
|
||||
with self._cb_lock:
|
||||
self._message_handler(msg)
|
||||
except Exception:
|
||||
log.exception("on_message 回调错误，等待重推")
|
||||
with self._lock:
|
||||
self._dedup.pop(key, None)
|
||||
return
|
||||
|
||||
if self._auto_ack:
|
||||
self._send_ack(from_id, mid, mark_acked=True)
|
||||
|
||||
def _handle_receipt(self, frame: dict[str, Any]) -> None:
|
||||
rid = str(frame.get("receipt_id", ""))
|
||||
with self._lock:
|
||||
if rid in self._receipt_seen:
|
||||
return
|
||||
self._receipt_seen[rid] = True
|
||||
while len(self._receipt_seen) > DEDUP_CAPACITY:
|
||||
self._receipt_seen.popitem(last=False)
|
||||
receipt = Receipt(
|
||||
receipt_id=rid,
|
||||
id=str(frame.get("id", "")),
|
||||
endpoint_id=str(frame.get("endpoint_id", "")),
|
||||
state=str(frame.get("state", "")),
|
||||
reason=str(frame.get("reason", "")),
|
||||
at_ms=int(frame.get("at_ms", 0)),
|
||||
)
|
||||
self._fire_receipt(receipt)
|
||||
# 自动 receipt_ack
|
||||
try:
|
||||
self._request({"type": "receipt_ack", "receipt_id": rid}, wait=False)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def _handle_revoked(self, frame: dict[str, Any]) -> None:
|
||||
mid = str(frame.get("id", ""))
|
||||
from_id = str(frame.get("from", ""))
|
||||
key = f"{from_id}\0{mid}"
|
||||
with self._lock:
|
||||
st = self._dedup.get(key)
|
||||
if st == _DedupState.ACKED:
|
||||
return
|
||||
if st is None:
|
||||
# 还没交给应用：直接丢弃
|
||||
return
|
||||
# 已交未确认：发撤回事件并不再确认
|
||||
self._dedup.pop(key, None)
|
||||
self._fire_revoked(RevokedEvent(id=mid, from_id=from_id, reason=str(frame.get("reason", ""))))
|
||||
|
||||
def _send_ack(self, from_id: str, message_id: str, *, mark_acked: bool) -> None:
|
||||
try:
|
||||
resp = self._request({"type": "ack", "from": from_id, "id": message_id})
|
||||
except Exception:
|
||||
return
|
||||
key = f"{from_id}\0{message_id}"
|
||||
data = resp.get("data") or {}
|
||||
result = data.get("result", "accepted")
|
||||
if result != "accepted":
|
||||
with self._lock:
|
||||
self._dedup.pop(key, None)
|
||||
self._fire_revoked(RevokedEvent(id=message_id, from_id=from_id, reason=str(result)))
|
||||
return
|
||||
if mark_acked:
|
||||
with self._lock:
|
||||
self._dedup_put(key, _DedupState.ACKED)
|
||||
|
||||
def _pump_sends(self) -> None:
|
||||
while True:
|
||||
with self._lock:
|
||||
if self._state != ConnectionState.ONLINE:
|
||||
return
|
||||
if self._inflight_sends >= INFLIGHT_LIMIT:
|
||||
return
|
||||
item = None
|
||||
for it in self._send_queue:
|
||||
if it.pending.rid == "" and it.pending.response is None and it.pending.error is None:
|
||||
item = it
|
||||
break
|
||||
if item is None:
|
||||
return
|
||||
rid = self._next_rid_locked()
|
||||
item.pending.rid = rid
|
||||
frame = dict(item.frame)
|
||||
frame["rid"] = rid
|
||||
self._pending[rid] = item.pending
|
||||
self._inflight_sends += 1
|
||||
topic = up_topic(self._endpoint_id)
|
||||
try:
|
||||
self._transport.publish(topic, dumps(frame))
|
||||
except Exception as e:
|
||||
with self._lock:
|
||||
self._pending.pop(rid, None)
|
||||
item.pending.rid = ""
|
||||
self._inflight_sends = max(0, self._inflight_sends - 1)
|
||||
item.pending.error = e
|
||||
item.pending.event.set()
|
||||
self._send_queue = [it for it in self._send_queue if it is not item]
|
||||
continue
|
||||
|
||||
def _request(self, frame: dict[str, Any], *, wait: bool = True) -> dict[str, Any]:
|
||||
with self._lock:
|
||||
if self._closed:
|
||||
raise ClosedError()
|
||||
if self._state != ConnectionState.ONLINE:
|
||||
raise NotConnectedError()
|
||||
rid = self._next_rid_locked()
|
||||
body = dict(frame)
|
||||
body["v"] = 1
|
||||
body["rid"] = rid
|
||||
pending = _PendingReq(rid=rid, frame=body)
|
||||
self._pending[rid] = pending
|
||||
topic = up_topic(self._endpoint_id)
|
||||
self._transport.publish(topic, dumps(body))
|
||||
if not wait:
|
||||
# 仍等一小会拿结果；后台请求也尽量同步完成
|
||||
pending.event.wait(timeout=30)
|
||||
with self._lock:
|
||||
self._pending.pop(rid, None)
|
||||
if pending.error:
|
||||
raise pending.error
|
||||
if pending.response is None:
|
||||
return {}
|
||||
if not pending.response.get("ok"):
|
||||
err = pending.response.get("error") or {}
|
||||
raise NixMsgError(str(err.get("code", "bad_request")), str(err.get("message", "")))
|
||||
return pending.response
|
||||
if not pending.event.wait(timeout=60):
|
||||
with self._lock:
|
||||
self._pending.pop(rid, None)
|
||||
raise NixMsgError("busy", "请求超时")
|
||||
if pending.error:
|
||||
raise pending.error
|
||||
assert pending.response is not None
|
||||
if not pending.response.get("ok"):
|
||||
err = pending.response.get("error") or {}
|
||||
raise NixMsgError(str(err.get("code", "bad_request")), str(err.get("message", "")))
|
||||
return pending.response
|
||||
|
||||
def _next_rid(self) -> str:
|
||||
with self._lock:
|
||||
return self._next_rid_locked()
|
||||
|
||||
def _next_rid_locked(self) -> str:
|
||||
self._rid_seq += 1
|
||||
return str(self._rid_seq)
|
||||
|
||||
def _dedup_put(self, key: str, state: str) -> None:
|
||||
if key in self._dedup:
|
||||
self._dedup.move_to_end(key)
|
||||
self._dedup[key] = state
|
||||
while len(self._dedup) > DEDUP_CAPACITY:
|
||||
self._dedup.popitem(last=False)
|
||||
|
||||
def _fail_all_pending(self, err: BaseException) -> None:
|
||||
for p in list(self._pending.values()):
|
||||
p.error = err
|
||||
p.event.set()
|
||||
self._pending.clear()
|
||||
for it in list(self._send_queue):
|
||||
it.pending.error = err
|
||||
it.pending.event.set()
|
||||
self._send_queue.clear()
|
||||
self._inflight_sends = 0
|
||||
|
||||
def _set_state(self, state: ConnectionState, reason: str = "") -> None:
|
||||
self._state = state
|
||||
h = self._connection_handler
|
||||
if h:
|
||||
try:
|
||||
with self._cb_lock:
|
||||
h(ConnectionEvent(state=state, reason=reason))
|
||||
except Exception:
|
||||
log.exception("on_connection 回调错误")
|
||||
|
||||
def _fire_session(self, token: str) -> None:
|
||||
h = self._session_handler
|
||||
if h:
|
||||
try:
|
||||
with self._cb_lock:
|
||||
h(token)
|
||||
except Exception:
|
||||
log.exception("on_session 回调错误")
|
||||
|
||||
def _fire_receipt(self, receipt: Receipt) -> None:
|
||||
h = self._receipt_handler
|
||||
if h:
|
||||
try:
|
||||
with self._cb_lock:
|
||||
h(receipt)
|
||||
except Exception:
|
||||
log.exception("on_receipt 回调错误")
|
||||
|
||||
def _fire_revoked(self, ev: RevokedEvent) -> None:
|
||||
h = self._revoked_handler
|
||||
if h:
|
||||
try:
|
||||
with self._cb_lock:
|
||||
h(ev)
|
||||
except Exception:
|
||||
log.exception("on_revoked 回调错误")
|
||||
|
||||
def _fire_presence(self, ev: PresenceEvent) -> None:
|
||||
h = self._presence_handler
|
||||
if h:
|
||||
try:
|
||||
with self._cb_lock:
|
||||
h(ev)
|
||||
except Exception:
|
||||
log.exception("on_presence 回调错误")
|
||||
|
||||
def _fire_group(self, ev: GroupEvent) -> None:
|
||||
h = self._group_handler
|
||||
if h:
|
||||
try:
|
||||
with self._cb_lock:
|
||||
h(ev)
|
||||
except Exception:
|
||||
log.exception("on_group_event 回调错误")
|
||||
|
||||
@staticmethod
|
||||
def _jitter(base: float) -> float:
|
||||
return max(0.0, base * (1.0 + random.uniform(-BACKOFF_JITTER, BACKOFF_JITTER)))
|
||||
|
||||
# 测试辅助
|
||||
@property
|
||||
def state(self) -> ConnectionState:
|
||||
return self._state
|
||||
|
||||
@property
|
||||
def limits(self) -> HelloLimits:
|
||||
return self._limits
|
||||
|
||||
@property
|
||||
def clock_skew_ms(self) -> int:
|
||||
return self._clock_skew_ms
|
||||
|
||||
@property
|
||||
def session_token(self) -> Optional[str]:
|
||||
return self._session_token
|
||||
|
||||
|
||||
def _auto_hello_responder(client: Client, transport: FakeTransport, *, session_token: str = "nst_test") -> None:
|
||||
"""测试辅助：对 hello 自动回成功（由测试自行调用更清晰）。"""
|
||||
_ = (client, transport, session_token)
|
||||
Reference in New Issue
Block a user