mqttxx 2.0.3__py3-none-any.whl → 3.2.1__py3-none-any.whl

mqttxx/rpc.py

@@ -1,7 +1,6 @@
 # MQTT RPC 模块 - 基于 aiomqtt 的双向对等 RPC 调用
 
 import asyncio
-import json
 import uuid
 from typing import Any, Callable, Optional
 from loguru import logger
@@ -14,8 +13,13 @@ from .exceptions import (
     TooManyConcurrentCallsError,
     MQTTXError,
     ErrorCode,
+    MessageError,
+)
+from .protocol import (
+    RPCRequest,
+    RPCResponse,
+    parse_message_from_bytes,
 )
-from .protocol import RPCRequest, RPCResponse
 
 
 # 权限检查回调类型
@@ -74,6 +78,7 @@ class RPCManager:
     def __init__(
         self,
         client: MQTTClient,
+        my_topic: Optional[str] = None,
         config: Optional[RPCConfig] = None,
         auth_callback: Optional[AuthCallback] = None,
     ):
@@ -81,36 +86,83 @@ class RPCManager:
 
         Args:
             client: MQTTClient 实例（用于底层消息收发）
+            my_topic: 本节点的响应主题（可选，提供后自动订阅并注入到 reply_to）
             config: RPC 配置（可选，默认使用标准配置）
             auth_callback: 权限检查回调函数（可选）
                 签名：async def auth_callback(caller_id: str, method: str, request: RPCRequest) -> bool
                 返回：True = 允许，False = 拒绝
+            codec: 编解码器（默认 JSONCodec）
 
         使用示例：
             client = MQTTClient(...)
             await client.connect()
 
-            # 基础用法（无权限控制）
+            # 约定式用法（推荐）
+            rpc = RPCManager(client, my_topic="edge/device_123")
+            # 自动订阅 edge/device_123，调用时自动注入 reply_to
+
+            # 手动设置响应主题
             rpc = RPCManager(client)
+            rpc.setup("my/rpc/responses")
 
             # 带权限控制
             async def auth_check(caller_id, method, request):
                 return caller_id in ALLOWED_CLIENTS
 
-            rpc = RPCManager(client, auth_callback=auth_check)
+            rpc = RPCManager(client, my_topic="server/node", auth_callback=auth_check)
         """
         self._client = client
+        self._my_topic = my_topic
         self.config = config or RPCConfig()
         self._auth_callback = auth_callback
 
         # RPC 状态
         self._pending_calls: dict[str, asyncio.Future] = {}  # request_id → Future
         self._handlers: dict[str, Callable] = {}  # method_name → handler
-        self._pending_calls_lock = (
-            asyncio.Lock()
-        )  # 修复 P0-1：保护 _pending_calls 并发访问
+        self._pending_calls_lock = asyncio.Lock()  # 保护 _pending_calls 并发访问
+
+        # 如果提供了 my_topic，自动订阅
+        if my_topic:
+            self.setup(my_topic)
+
+    @property
+    def my_topic(self) -> Optional[str]:
+        """获取本节点的响应主题"""
+        return self._my_topic
+
+    def setup(self, reply_topic: str):
+        """设置 RPC 响应主题并自动订阅
 
-        logger.info("RPCManager 已初始化")
+        这个方法会：
+        1. 订阅 reply_topic（接收 RPC 响应）
+        2. 注册消息处理器（自动解码 + 分发）
+
+        Args:
+            reply_topic: 响应主题（例如：server/rpc_responses）
+
+        示例：
+            rpc = RPCManager(client)
+            rpc.setup("my/rpc/responses")
+        """
+
+        async def handle_bytes(topic: str, payload: bytes):
+            """bytes → RPC message → handle"""
+            try:
+                # 解码
+                message = parse_message_from_bytes(payload)
+
+                # 路由
+                if isinstance(message, RPCRequest):
+                    await self._handle_request(topic, message)
+                elif isinstance(message, RPCResponse):
+                    await self._handle_response(topic, message)
+            except MessageError as e:
+                logger.debug(f"非 RPC 消息 - topic: {topic}, reason: {e}")
+            except Exception as e:
+                logger.exception(f"RPC 消息处理失败: {e}")
+
+        # 订阅 raw bytes
+        self._client.subscribe(reply_topic, handle_bytes)
 
     def register(self, method_name: str):
         """装饰器：注册本地 RPC 方法供远程调用
@@ -188,52 +240,57 @@ class RPCManager:
         method: str,
         params: Any = None,
         timeout: Optional[float] = None,
-        reply_to: str = None,
+        reply_to: Optional[str] = None,
     ) -> Any:
         """远程调用 RPC 方法
 
         修复点：
         - ✅ 新增并发限制检查
+        - ✅ 自动注入 reply_to（如果初始化时提供了 my_topic）
 
         Args:
             topic: 目标 MQTT 主题（例如：bots/456）
             method: 远程方法名
             params: 方法参数（可选）
             timeout: 超时时间（秒，None 则使用配置的默认值）
-            reply_to: 响应主题（必需，例如：server/device_123）
+            reply_to: 响应主题（可选，默认使用初始化时的 my_topic）
 
         Returns:
             远程方法的返回值
 
         Raises:
             MQTTXError: 客户端未连接
-            ValueError: reply_to 参数缺失
+            ValueError: reply_to 参数缺失且初始化时未提供 my_topic
             TooManyConcurrentCallsError: 并发调用超限
             RPCTimeoutError: 调用超时
             RPCRemoteError: 远程执行失败
 
         使用示例：
-            # 基础调用
-            result = await rpc.call(
-                topic="bots/456",
-                method="get_status",
-                reply_to="server/device_123"
-            )
+            # 约定式用法（推荐）
+            rpc = RPCManager(client, my_topic="server/device_123")
+            result = await rpc.call("bots/456", "get_status")
+            # reply_to 自动注入为 "server/device_123"
 
-            # 带参数调用
+            # 手动指定 reply_to
             result = await rpc.call(
                 topic="bots/456",
                 method="process_command",
                 params={"command": "restart"},
-                reply_to="server/device_123",
+                reply_to="custom/reply/topic",
                 timeout=60.0
             )
         """
         if not self._client.is_connected:
             raise MQTTXError("MQTT 客户端未连接", ErrorCode.NOT_CONNECTED)
 
+        # 自动注入 reply_to
+        if reply_to is None:
+            reply_to = self._my_topic
+
         if reply_to is None:
-            raise ValueError("reply_to 参数是必需的，不能为 None")
+            raise ValueError(
+                "reply_to 参数是必需的，或在初始化时提供 my_topic"
+            )
 
         # 生成请求
         request_id = str(uuid.uuid4())
@@ -258,7 +315,8 @@ class RPCManager:
             self._pending_calls[request_id] = future
 
         # 发送请求
-        await self._client.publish(topic, json.dumps(request.to_dict()), qos=1)
+        payload = request.encode()
+        await self._client.raw.publish(topic, payload, qos=1)
         logger.debug(f"RPC 请求已发送 - method: {method}, request_id: {request_id[:8]}")
 
         try:
@@ -406,5 +464,6 @@ class RPCManager:
             topic: 响应主题
             response: RPC 响应消息
         """
-        await self._client.publish(topic, json.dumps(response.to_dict()), qos=1)
+        payload = response.encode()
+        await self._client.raw.publish(topic, payload, qos=1)
         logger.debug(f"RPC 响应已发送 - request_id: {response.request_id[:8]}")