sycommon-python-lib 0.1.43__py3-none-any.whl → 0.1.45__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_client.py

@@ -9,16 +9,13 @@ from aio_pika.abc import (
     AbstractQueue,
     AbstractIncomingMessage,
     ConsumerTag,
-    AbstractRobustConnection
+    AbstractRobustConnection,
 )
 from sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.models.mqmsg_model import MQMsgModel
 
 
-# 最大重试次数限制
-MAX_RETRY_COUNT = 3
-
 logger = SYLogger
 
 
@@ -27,10 +24,10 @@ class RabbitMQClient:
     RabbitMQ 客户端（支持消息发布、消费、自动重连、异常重试）
     核心特性：
     1. 基于连接池复用资源，性能优化
-    2. 连接/通道失效时自动重建，高可用
-    3. 消息发布支持重试，消费支持手动ACK/NACK
-    4. 兼容JSON/字符串/字典消息格式
-    5. 严格的协程调用规范，避免"未等待"警告
+    2. 连接/通道失效时自动重建，高可用（限制并发重连）
+    3. 消息发布支持重试+mandatory机制+超时控制，确保路由有效
+    4. 消费支持手动ACK/NACK
+    5. 兼容JSON/字符串/字典消息格式
     """
 
     def __init__(
@@ -45,7 +42,6 @@ class RabbitMQClient:
         auto_parse_json: bool = True,
         create_if_not_exists: bool = True,
         prefetch_count: int = 2,
-        # 兼容旧代码参数（无需使用）
         **kwargs,
     ):
         # 依赖注入：连接池（必须已初始化）
@@ -87,10 +83,8 @@ class RabbitMQClient:
         self._connect_lock = asyncio.Lock()
         # 跟踪连接关闭回调（用于后续移除）
         self._conn_close_callback: Optional[Callable] = None
-        # 控制重连频率的信号量（避免短时间内大量重连任务）
+        # 控制重连频率的信号量（限制并发重连数，默认1个）
         self._reconnect_semaphore = asyncio.Semaphore(1)
-        # 重连冷却时间（秒）
-        self._reconnect_cooldown = 3
         # 固定重连间隔15秒（全局统一）
         self._RECONNECT_INTERVAL = 15
         # 重连任务锁（确保同一时间只有一个重连任务）
@@ -140,7 +134,7 @@ class RabbitMQClient:
             self._conn_close_callback = None
 
             try:
-                # 从连接池获取通道+连接（连接池已控制连接数）
+                # 从连接池获取通道+连接（连接池返回的是 RobustChannel）
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
                 def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
@@ -164,7 +158,11 @@ class RabbitMQClient:
                 await self._channel.set_qos(prefetch_count=self.prefetch_count)
                 SYLogger.debug(f"设置预取计数: {self.prefetch_count}")
 
-                # 3. 声明交换机
+                # 3. 低版本 RobustChannel 说明：默认启用异步发布确认，无显式确认方法
+                SYLogger.debug(
+                    "基于 RobustChannel 异步发布确认（低版本 aio-pika 不支持显式确认方法）")
+
+                # 4. 声明交换机
                 self._exchange = await self._channel.declare_exchange(
                     name=self.exchange_name,
                     type=self.exchange_type,
@@ -175,7 +173,7 @@ class RabbitMQClient:
                 SYLogger.info(
                     f"交换机初始化成功: {self.exchange_name}（类型: {self.exchange_type.value}）")
 
-                # 4. 声明队列（如果配置了队列名）
+                # 5. 声明队列（如果配置了队列名）
                 if self.queue_name:
                     self._queue = await self._channel.declare_queue(
                         name=self.queue_name,
@@ -215,33 +213,38 @@ class RabbitMQClient:
                 raise
 
     async def _safe_reconnect(self):
-        """安全重连：固定15秒间隔，避免重复任务"""
-        # 检查是否已有重连任务在运行
-        if self._current_reconnect_task and not self._current_reconnect_task.done():
-            SYLogger.debug("已有重连任务在运行，跳过重复触发")
-            return
-
-        async with self._reconnect_task_lock:
-            if self._closed or await self.is_connected:
+        """安全重连：信号量控制并发+固定15秒间隔，避免短时间大量重连"""
+        # 1. 信号量控制：限制同时进行的重连任务数（默认1个）
+        async with self._reconnect_semaphore:
+            # 2. 检查是否已有重连任务在运行（双重保障）
+            if self._current_reconnect_task and not self._current_reconnect_task.done():
+                SYLogger.debug("已有重连任务在运行，跳过重复触发")
                 return
 
-            # 固定15秒重连间隔
-            SYLogger.info(f"将在15秒后尝试重连...")
-            await asyncio.sleep(self._RECONNECT_INTERVAL)
+            async with self._reconnect_task_lock:
+                if self._closed or await self.is_connected:
+                    SYLogger.debug("客户端已关闭或已连接，取消重连")
+                    return
 
-            if self._closed or await self.is_connected:
-                return
+                # 3. 固定15秒重连间隔（避免频繁重试）
+                SYLogger.info(f"将在15秒后尝试重连...")
+                await asyncio.sleep(self._RECONNECT_INTERVAL)
 
-            try:
-                self._current_reconnect_task = asyncio.create_task(
-                    self.connect())
-                await self._current_reconnect_task
-            except Exception as e:
-                SYLogger.warning(f"重连失败: {str(e)}")
-                # 重连失败后，继续触发下一次重连（仍保持15秒间隔）
-                asyncio.create_task(self._safe_reconnect())
-            finally:
-                self._current_reconnect_task = None
+                if self._closed or await self.is_connected:
+                    SYLogger.debug("重连等待期间客户端状态变化，取消重连")
+                    return
+
+                try:
+                    # 4. 执行重连
+                    SYLogger.info("开始重连RabbitMQ客户端...")
+                    self._current_reconnect_task = asyncio.create_task(
+                        self.connect())
+                    await self._current_reconnect_task
+                except Exception as e:
+                    SYLogger.warning(f"重连失败: {str(e)}")
+                    # 重连失败后，不主动触发下一次（等待连接关闭回调再次触发，避免死循环）
+                finally:
+                    self._current_reconnect_task = None
 
     async def set_message_handler(
         self,
@@ -315,7 +318,7 @@ class RabbitMQClient:
                     # 检查连接状态，失效则触发重连
                     if not await self.is_connected:
                         SYLogger.warning("连接已失效，触发客户端重连")
-                        asyncio.create_task(self.connect())
+                        asyncio.create_task(self._safe_reconnect())
 
             # 3. 启动消费
             self._consumer_tag = await self._queue.consume(consume_callback)
@@ -345,7 +348,7 @@ class RabbitMQClient:
         retry_count: int = 3,
     ) -> None:
         """
-        发布消息（支持自动重试、JSON序列化）
+        发布消息（支持自动重试、mandatory路由校验、5秒超时控制）
         :param message_body: 消息体（字符串/字典/MQMsgModel）
         :param headers: 消息头（可选）
         :param content_type: 内容类型（默认application/json）
@@ -387,33 +390,53 @@ class RabbitMQClient:
                     SYLogger.warning(f"发布消息前连接失效，触发重连（retry: {retry}）")
                     await self.connect()
 
-                # 发布消息
-                await self._exchange.publish(
+                # 核心：发布消息（添加 mandatory=True 和 timeout=5.0）
+                publish_result = await self._exchange.publish(
                     message=message,
                     routing_key=self.routing_key or self.queue_name or "#",
+                    mandatory=True,  # 强制路由到至少一个队列，否则返回None
+                    timeout=5.0      # 5秒超时控制，避免无限阻塞
                 )
+
+                # 处理 mandatory=True 结果：未路由到队列返回 None，直接抛出异常
+                if publish_result is None:
+                    raise RuntimeError(
+                        f"消息未找到匹配的队列（routing_key: {self.routing_key}），mandatory=True 触发失败"
+                    )
+
+                # 低版本 RobustChannel 异步确认，无需显式等待，仅日志说明
                 SYLogger.info(
                     f"消息发布成功（retry: {retry}），routing_key: {self.routing_key}，"
-                    f"delivery_mode: {delivery_mode.value}"
+                    f"delivery_mode: {delivery_mode.value}，mandatory: True，timeout: 5.0s"
                 )
                 return
+            except asyncio.TimeoutError:
+                SYLogger.error(
+                    f"消息发布超时（retry: {retry}/{retry_count-1}），超时时间: 5.0s"
+                )
+            except RuntimeError as e:
+                # 捕获 mandatory 未路由等业务异常
+                SYLogger.error(
+                    f"消息发布业务失败（retry: {retry}/{retry_count-1}）: {str(e)}"
+                )
             except Exception as e:
                 SYLogger.error(
                     f"消息发布失败（retry: {retry}/{retry_count-1}）: {str(e)}",
                     exc_info=True
                 )
-                # 清理失效状态，下次重试时重连
+                # 清理失效状态，下次重试重连
                 self._exchange = None
-                # 重试间隔（指数退避）
-                await asyncio.sleep(0.5 * (2 ** retry))
+            # 指数退避重试间隔（0.5s, 1s, 2s...）
+            await asyncio.sleep(0.5 * (2 ** retry))
 
-        # 所有重试失败，抛出异常
+        # 所有重试失败，抛出最终异常
         raise RuntimeError(
-            f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}"
+            f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}，"
+            f"mandatory: True，timeout: 5.0s"
         )
 
     async def close(self) -> None:
-        """关闭客户端（移除回调）"""
+        """关闭客户端（移除回调+释放资源）"""
         self._closed = True
         SYLogger.info("开始关闭RabbitMQ客户端...")