sycommon-python-lib 0.1.56b11__py3-none-any.whl → 0.1.56b12__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_client.py

@@ -1,9 +1,7 @@
-from aio_pika import Channel
-from typing import Optional
 import asyncio
 import json
-from typing import Callable, Coroutine, Dict, Any, Union
-from aio_pika import Message, DeliveryMode, ExchangeType
+from typing import Optional, Callable, Coroutine, Dict, Any, Union
+from aio_pika import Channel, Message, DeliveryMode, ExchangeType
 from aio_pika.abc import (
     AbstractExchange,
     AbstractQueue,
@@ -20,13 +18,7 @@ logger = SYLogger
 
 class RabbitMQClient:
     """
-    RabbitMQ 客户端（支持消息发布、消费、自动重连、异常重试）
-    核心特性：
-    1. 基于单通道连接池复用资源，性能优化
-    2. 依赖连接池原生自动重连，客户端仅重建自身资源
-    3. 消息发布支持重试+mandatory机制+超时控制，确保路由有效
-    4. 消费支持手动ACK/NACK
-    5. 兼容JSON/字符串/字典消息格式
+    RabbitMQ 客户端
     """
 
     def __init__(
@@ -42,12 +34,10 @@ class RabbitMQClient:
         create_if_not_exists: bool = True,
         **kwargs,
     ):
-        # 依赖注入：连接池（必须已初始化）
         self.connection_pool = connection_pool
         if not self.connection_pool._initialized:
             raise RuntimeError("连接池未初始化，请先调用 connection_pool.init_pools()")
 
-        # 交换机配置
         self.exchange_name = exchange_name.strip()
         try:
             self.exchange_type = ExchangeType(exchange_type.lower())
@@ -55,17 +45,16 @@ class RabbitMQClient:
             logger.warning(f"无效的exchange_type: {exchange_type}，默认使用'topic'")
             self.exchange_type = ExchangeType.TOPIC
 
-        # 队列配置
         self.queue_name = queue_name.strip() if queue_name else None
         self.routing_key = routing_key.strip() if routing_key else "#"
-        self.durable = durable  # 消息/队列持久化
-        self.auto_delete = auto_delete  # 无消费者时自动删除队列/交换机
-        self.auto_parse_json = auto_parse_json  # 自动解析JSON消息体
-        self.create_if_not_exists = create_if_not_exists  # 不存在则创建交换机/队列
+        self.durable = durable
+        self.auto_delete = auto_delete
+        self.auto_parse_json = auto_parse_json
+        self.create_if_not_exists = create_if_not_exists
 
-        # 内部状态（资源+连接）
+        # 资源状态
         self._channel: Optional[Channel] = None
-        self._channel_conn: Optional[AbstractRobustConnection] = None  # 通道所属连接
+        self._channel_conn: Optional[AbstractRobustConnection] = None
         self._exchange: Optional[AbstractExchange] = None
         self._queue: Optional[AbstractQueue] = None
         self._consumer_tag: Optional[ConsumerTag] = None
@@ -73,45 +62,38 @@ class RabbitMQClient:
             MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]]] = None
         self._closed = False
 
-        # 线程安全锁
+        # 并发控制
         self._consume_lock = asyncio.Lock()
         self._connect_lock = asyncio.Lock()
-        # 跟踪连接关闭回调（用于后续移除）
+
+        # 防止并发重连覆盖
+        self._connecting = False
+        self._connect_condition = asyncio.Condition()
+
         self._conn_close_callback: Optional[Callable] = None
-        # 控制重连频率的信号量（限制并发重连数）
         self._reconnect_semaphore = asyncio.Semaphore(1)
-        # 固定重连间隔15秒（全局统一）
-        self._RECONNECT_INTERVAL = 15
-        # 跟踪当前重连任务（避免重复创建）
         self._current_reconnect_task: Optional[asyncio.Task] = None
-        # 连接失败计数器（用于告警）
-        self._reconnect_fail_count = 0
-        # 连接失败告警阈值
-        self._reconnect_alert_threshold = 5
+        self._RECONNECT_INTERVAL = 15
 
     @property
     async def is_connected(self) -> bool:
-        """异步检查客户端连接状态（属性，不可调用）"""
         if self._closed:
             return False
         try:
-            # 单通道场景：校验通道+连接+核心资源都有效
             return (
                 self._channel and not self._channel.is_closed
                 and self._channel_conn and not self._channel_conn.is_closed
                 and self._exchange is not None
                 and (not self.queue_name or self._queue is not None)
             )
-        except Exception as e:
-            logger.warning(f"检查连接状态失败: {str(e)}")
+        except Exception:
             return False
 
     async def _rebuild_resources(self) -> None:
-        """重建交换机/队列等资源（依赖已有的通道）"""
         if not self._channel or self._channel.is_closed:
             raise RuntimeError("无有效通道，无法重建资源")
 
-        # 1. 声明交换机
+        # 声明交换机
         self._exchange = await self._channel.declare_exchange(
             name=self.exchange_name,
             type=self.exchange_type,
@@ -119,10 +101,9 @@ class RabbitMQClient:
             auto_delete=self.auto_delete,
             passive=not self.create_if_not_exists,
         )
-        logger.info(
-            f"交换机重建成功: {self.exchange_name}（类型: {self.exchange_type.value}）")
+        logger.info(f"交换机重建成功: {self.exchange_name}")
 
-        # 2. 声明队列（如果配置了队列名）
+        # 声明队列
         if self.queue_name:
             self._queue = await self._channel.declare_queue(
                 name=self.queue_name,
@@ -130,100 +111,134 @@ class RabbitMQClient:
                 auto_delete=self.auto_delete,
                 passive=not self.create_if_not_exists,
             )
-            # 绑定队列到交换机
-            await self._queue.bind(
-                exchange=self._exchange,
-                routing_key=self.routing_key,
-            )
-            logger.info(
-                f"队列重建成功: {self.queue_name} "
-                f"（绑定交换机: {self.exchange_name}, routing_key: {self.routing_key}）"
-            )
+            await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+            logger.info(f"队列重建成功: {self.queue_name}")
 
     async def connect(self) -> None:
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
+        # 1. 并发控制：使用 _connect_lock 保证只有一个协程在执行连接流程
         async with self._connect_lock:
-            # 1. 清理旧连接回调（防止内存泄漏）
-            if self._channel_conn and self._conn_close_callback:
+            # 如果已经在连了，等待其完成
+            if self._connecting:
+                logger.debug("连接正在进行中，等待现有连接完成...")
                 try:
-                    self._channel_conn.close_callbacks.discard(
-                        self._conn_close_callback)
-                except Exception:
-                    pass
+                    # 等待条件变量，超时设为 60 秒防止死等
+                    await asyncio.wait_for(
+                        self._connect_condition.wait_for(
+                            lambda: not self._connecting),
+                        timeout=60.0
+                    )
+                except asyncio.TimeoutError:
+                    raise RuntimeError("等待连接超时")
 
-            # 2. 清理状态
-            self._channel = None
-            self._channel_conn = None
-            self._exchange = None
-            self._queue = None
-            self._conn_close_callback = None
+                # 等待结束后，再次检查状态
+                if not await self.is_connected:
+                    raise RuntimeError("等待重连后，连接状态依然无效")
+                return
 
-            try:
-                # 3. 获取新通道
-                self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
-
-                # 4. 设置新连接回调（使用 weakref）
-                def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
-                    # 注意：这里需要访问外部的 self，使用闭包或 weakref
-                    # 简单起见，这里用闭包，但务必在 self.close 或 self.connect 时清理回调
-                    logger.warning(f"检测到连接关闭: {exc}")
-                    if not self._closed:
-                        asyncio.create_task(self._safe_reconnect())
-
-                self._conn_close_callback = on_conn_closed
-                if self._channel_conn:
-                    self._channel_conn.close_callbacks.add(
-                        self._conn_close_callback)
+            # 标记开始连接
+            self._connecting = True
 
-                # 5. 重建资源
-                await self._rebuild_resources()
+        # 释放 _connect_lock，允许其他协程读取状态，但在连接完成前阻止新的连接请求
+        # 注意：这里释放了 _connect_lock，但 self._connecting = True 阻止了新的连接流程
+
+        try:
+            # --- 阶段1: 清理旧资源 ---
+            # 重新获取锁进行资源清理
+            async with self._connect_lock:
+                was_consuming = self._consumer_tag is not None
 
-                # 重置计数
-                self._reconnect_fail_count = 0
-                logger.info("客户端连接初始化完成")
-            except Exception as e:
-                logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
-                # 失败时也要清理可能产生的残留引用
                 if self._channel_conn and self._conn_close_callback:
                     try:
                         self._channel_conn.close_callbacks.discard(
                             self._conn_close_callback)
                     except Exception:
                         pass
-                # 清空状态
+
                 self._channel = None
                 self._channel_conn = None
+                self._exchange = None
+                self._queue = None
                 self._conn_close_callback = None
 
-                # 触发重连
-                if not self._closed:
+            # --- 阶段2: 获取新连接 (耗时IO) ---
+            self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
+
+            # 设置回调
+            def on_conn_closed(conn, exc):
+                logger.warning(f"检测到连接关闭: {exc}")
+                if not self._closed and not self._connecting:
                     asyncio.create_task(self._safe_reconnect())
-                raise
+
+            self._conn_close_callback = on_conn_closed
+            if self._channel_conn:
+                self._channel_conn.close_callbacks.add(
+                    self._conn_close_callback)
+
+            # 重建资源
+            await self._rebuild_resources()
+
+            # --- 阶段3: 恢复消费 ---
+            if was_consuming and self._message_handler and self.queue_name:
+                logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复...")
+                try:
+                    self._queue = await self._channel.declare_queue(
+                        name=self.queue_name,
+                        durable=self.durable,
+                        auto_delete=self.auto_delete,
+                        passive=False,
+                    )
+                    await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+                    self._consumer_tag = await self._queue.consume(self._process_message_callback)
+                    logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
+                except Exception as e:
+                    logger.error(f"❌ 自动恢复消费失败: {e}")
+                    self._consumer_tag = None
+            else:
+                self._consumer_tag = None
+
+            logger.info("客户端连接初始化完成")
+
+        except Exception as e:
+            logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
+
+            # 异常时清理资源
+            async with self._connect_lock:
+                if self._channel_conn and self._conn_close_callback:
+                    self._channel_conn.close_callbacks.discard(
+                        self._conn_close_callback)
+                self._channel = None
+                self._channel_conn = None
+                self._consumer_tag = None
+
+            raise
+
+        finally:
+            # 【关键修复】必须在持有 Condition 内部锁的情况下调用 notify_all
+            # 这里使用 async with self._connect_condition: 自动完成 acquire() ... notify_all() ... release()
+            async with self._connect_condition:
+                self._connecting = False
+                self._connect_condition.notify_all()
 
     async def _safe_reconnect(self):
-        """安全重连：信号量控制并发+固定15秒间隔"""
+        """安全重连任务（仅用于被动监听连接关闭）"""
         async with self._reconnect_semaphore:
-            # 检查是否已有重连任务在运行
-            if self._current_reconnect_task and not self._current_reconnect_task.done():
-                logger.debug("已有重连任务在运行，跳过重复触发")
+            if self._closed:
                 return
 
-            if self._closed or await self.is_connected:
-                logger.debug("客户端已关闭或已连接，取消重连")
+            # 如果已经在重连，直接忽略
+            if self._connecting:
                 return
 
-            # 固定15秒重连间隔
             logger.info(f"将在{self._RECONNECT_INTERVAL}秒后尝试重连...")
             await asyncio.sleep(self._RECONNECT_INTERVAL)
 
             if self._closed or await self.is_connected:
-                logger.debug("重连等待期间客户端状态变化，取消重连")
                 return
 
             try:
-                logger.info("开始重连RabbitMQ客户端...")
                 self._current_reconnect_task = asyncio.create_task(
                     self.connect())
                 await self._current_reconnect_task
@@ -232,163 +247,112 @@ class RabbitMQClient:
             finally:
                 self._current_reconnect_task = None
 
-    async def set_message_handler(
-        self,
-        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]],
-    ) -> None:
-        """设置消息处理器（必须是协程函数）"""
+    async def set_message_handler(self, handler: Callable[..., Coroutine]) -> None:
         if not asyncio.iscoroutinefunction(handler):
-            raise TypeError("消息处理器必须是协程函数（使用 async def 定义）")
-
+            raise TypeError("消息处理器必须是协程函数")
         async with self._consume_lock:
             self._message_handler = handler
-            logger.info("消息处理器设置成功")
+
+    async def _process_message_callback(self, message: AbstractIncomingMessage):
+        try:
+            msg_obj: MQMsgModel
+            if self.auto_parse_json:
+                try:
+                    body_dict = json.loads(message.body.decode("utf-8"))
+                    msg_obj = MQMsgModel(**body_dict)
+                except json.JSONDecodeError as e:
+                    logger.error(f"JSON解析失败: {e}")
+                    await message.nack(requeue=False)
+                    return
+            else:
+                msg_obj = MQMsgModel(
+                    body=message.body.decode("utf-8"),
+                    routing_key=message.routing_key,
+                    delivery_tag=message.delivery_tag,
+                    traceId=message.headers.get("trace-id"),
+                    headers=message.headers
+                )
+
+            SYLogger.set_trace_id(msg_obj.traceId)
+
+            if self._message_handler:
+                await self._message_handler(msg_obj, message)
+
+            await message.ack()
+
+        except Exception as e:
+            logger.error(f"消息处理异常: {e}", exc_info=True)
+            headers = dict(message.headers) if message.headers else {}
+            current_retry = int(headers.get("x-retry-count", 0))
+
+            if current_retry >= 3:
+                logger.warning(f"重试次数超限，丢弃消息: {message.delivery_tag}")
+                await message.reject(requeue=False)
+            else:
+                headers["x-retry-count"] = current_retry + 1
+                try:
+                    new_msg = Message(
+                        body=message.body,
+                        headers=headers,
+                        content_type=message.content_type,
+                        delivery_mode=message.delivery_mode
+                    )
+                    # 这里的 publish 如果失败，会触发重连机制
+                    # 但注意，当前是在回调线程中，建议做好异常捕获
+                    await self._exchange.publish(new_msg, routing_key=message.routing_key)
+                    await message.ack()
+                except Exception as pub_err:
+                    logger.error(f"重试发布失败: {pub_err}")
+                    await message.reject(requeue=False)
 
     async def start_consuming(self) -> Optional[ConsumerTag]:
-        """启动消息消费（支持自动重连 + Header 重试计数限制）"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法启动消费")
 
         async with self._consume_lock:
-            # 1. 校验前置条件
             if not self._message_handler:
-                raise RuntimeError("未设置消息处理器，请先调用 set_message_handler()")
+                raise RuntimeError("未设置消息处理器")
+
             if not await self.is_connected:
                 await self.connect()
-            if not self._queue:
-                raise RuntimeError("未配置队列名或队列未创建，无法启动消费")
-
-            # 2. 定义消费回调
-            async def consume_callback(message: AbstractIncomingMessage):
-                try:
-                    # 解析消息体
-                    msg_obj: MQMsgModel
-                    if self.auto_parse_json:
-                        try:
-                            body_dict = json.loads(
-                                message.body.decode("utf-8"))
-                            msg_obj = MQMsgModel(**body_dict)
-                        except json.JSONDecodeError as e:
-                            logger.error(
-                                f"JSON消息解析失败: {str(e)}，消息体: {message.body[:100]}...")
-                            # 解析失败通常无法重试，直接丢弃
-                            await message.nack(requeue=False)
-                            return
-                    else:
-                        msg_obj = MQMsgModel(
-                            body=message.body.decode("utf-8"),
-                            routing_key=message.routing_key,
-                            delivery_tag=message.delivery_tag,
-                            traceId=message.headers.get("trace-id", None),
-                            headers=message.headers
-                        )
-
-                    # 统一追踪ID
-                    SYLogger.set_trace_id(
-                        message.headers.get("trace-id", None))
-
-                    # 调用消息处理器
-                    await self._message_handler(msg_obj, message)
-
-                    # 处理成功，手动ACK
-                    await message.ack()
-                    logger.debug(
-                        f"消息处理成功，delivery_tag: {message.delivery_tag}")
 
-                except Exception as e:
-                    logger.error(
-                        f"消息处理失败，delivery_tag: {message.delivery_tag}",
-                        exc_info=True
-                    )
-
-                    # 1. 获取当前重试次数，默认为 0
-                    current_retry_count = 0
-                    if message.headers:
-                        current_retry_count = int(
-                            message.headers.get("x-retry-count", 0))
-
-                    # 2. 检查是否超过最大重试次数 (3次)
-                    MAX_RETRY = 3
-                    if current_retry_count >= MAX_RETRY:
-                        logger.warning(
-                            f"消息重试次数已达上限({MAX_RETRY})，丢弃消息。"
-                            f"delivery_tag: {message.delivery_tag}, routing_key: {message.routing_key}"
-                        )
-                        # 丢弃消息（不重新入队）
-                        await message.reject(requeue=False)
-                        return
-
-                    # 3. 次数未满，准备重入队
-                    # 注意：AbstractIncomingMessage.headers 是只读的 (frozendict)，
-                    # 不能直接 message.headers["x-retry-count"] = ...
-                    # 必须重新构造 headers 字典。
-                    new_headers = dict(
-                        message.headers) if message.headers else {}
-                    new_headers["x-retry-count"] = current_retry_count + 1
-
-                    logger.warning(
-                        f"消息处理失败，准备第 {current_retry_count + 1} 次重入队。"
-                        f"delivery_tag: {message.delivery_tag}"
+            if not self._queue:
+                if self.queue_name:
+                    self._queue = await self._channel.declare_queue(
+                        name=self.queue_name,
+                        durable=self.durable,
+                        auto_delete=self.auto_delete,
+                        passive=not self.create_if_not_exists,
                     )
+                    await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+                else:
+                    raise RuntimeError("未配置队列名")
 
-                    try:
-                        new_msg = Message(
-                            body=message.body,
-                            headers=new_headers,
-                            content_type=message.content_type,
-                            delivery_mode=message.delivery_mode
-                        )
-
-                        # 发布到原 Exchange 和 RoutingKey
-                        # 注意：这里可能会抛出异常，如果抛异常，消息可能会丢失（因为已经 Nack 掉了）
-                        await self._exchange.publish(
-                            new_msg,
-                            routing_key=message.routing_key
-                        )
-
-                        # 发布成功后，Ack 掉旧消息
-                        await message.ack()
-                        logger.info(
-                            f"消息已重新发布 (重试次数: {new_headers['x-retry-count']})")
-
-                    except Exception as publish_err:
-                        logger.error(f"重新发布消息失败(消息丢失): {publish_err}")
-                        # 重新发布失败，只能丢弃或者 Nack(False)
-                        await message.reject(requeue=False)
-
-            # 3. 启动消费（单通道消费，避免阻塞发布需确保业务回调非阻塞）
-            self._consumer_tag = await self._queue.consume(consume_callback)
+            self._consumer_tag = await self._queue.consume(self._process_message_callback)
             logger.info(
-                f"开始消费队列: {self._queue.name}，consumer_tag: {self._consumer_tag}"
-            )
+                f"开始消费队列: {self._queue.name}，tag: {self._consumer_tag}")
             return self._consumer_tag
 
     async def stop_consuming(self) -> None:
-        """停止消息消费（适配 RobustChannel）"""
         async with self._consume_lock:
-            try:
-                # 校验核心条件：消费标签、队列、通道均有效
-                if self._consumer_tag and self._queue and self._channel and not self._channel.is_closed:
-                    # 使用队列的 cancel 方法（适配 RobustChannel）
+            if self._consumer_tag and self._queue and self._channel:
+                try:
                     await self._queue.cancel(self._consumer_tag)
-                    logger.info(
-                        f"停止消费成功，consumer_tag: {self._consumer_tag}，队列: {self._queue.name}"
-                    )
-                elif self._consumer_tag:
-                    # 部分资源无效时的日志提示
-                    if not self._queue:
-                        logger.warning(
-                            f"消费标签存在但队列为空，无法取消消费（consumer_tag: {self._consumer_tag}）")
-                    elif not self._channel or self._channel.is_closed:
-                        logger.warning(
-                            f"通道已关闭，消费已自动停止（consumer_tag: {self._consumer_tag}，队列: {self._queue.name if self._queue else '未知'}）"
-                        )
-            except Exception as e:
-                logger.error(
-                    f"停止消费者 '{self._queue.name if self._queue else '未知队列'}' 时出错: {str(e)}", exc_info=True
-                )
-            finally:
-                self._consumer_tag = None  # 无论成败，清理消费标签
+                    logger.info(f"停止消费成功: {self._consumer_tag}")
+                except Exception as e:
+                    logger.warning(f"停止消费异常: {e}")
+            self._consumer_tag = None
+
+    async def _handle_publish_failure(self):
+        try:
+            logger.info("检测到发布异常，强制连接池切换节点...")
+            await self.connection_pool.force_reconnect()
+            # 连接池切换后，必须刷新客户端资源
+            await self.connect()
+            logger.info("故障转移完成，资源已刷新")
+        except Exception as e:
+            logger.error(f"故障转移失败: {e}")
+            raise
 
     async def publish(
         self,
@@ -398,18 +362,9 @@ class RabbitMQClient:
         delivery_mode: DeliveryMode = DeliveryMode.PERSISTENT,
         retry_count: int = 3,
     ) -> None:
-        """
-        发布消息（支持自动重试、mandatory路由校验、5秒超时控制）
-        :param message_body: 消息体（字符串/字典/MQMsgModel）
-        :param headers: 消息头（可选）
-        :param content_type: 内容类型（默认application/json）
-        :param delivery_mode: 投递模式（PERSISTENT=持久化，TRANSIENT=非持久化）
-        :param retry_count: 重试次数（默认3次）
-        """
         if self._closed:
             raise RuntimeError("客户端已关闭，无法发布消息")
 
-        # 处理消息体序列化
         try:
             if isinstance(message_body, MQMsgModel):
                 body = json.dumps(message_body.to_dict(),
@@ -422,93 +377,72 @@ class RabbitMQClient:
             else:
                 raise TypeError(f"不支持的消息体类型: {type(message_body)}")
         except Exception as e:
-            logger.error(f"消息体序列化失败: {str(e)}", exc_info=True)
+            logger.error(f"消息体序列化失败: {e}")
             raise
 
-        # 构建消息对象
-        message = Message(
-            body=body,
-            headers=headers or {},
-            content_type=content_type,
-            delivery_mode=delivery_mode,
-        )
+        message = Message(body=body, headers=headers or {},
+                          content_type=content_type, delivery_mode=delivery_mode)
+        last_exception = None
 
-        # 发布重试逻辑
         for retry in range(retry_count):
             try:
-                # 确保连接有效
                 if not await self.is_connected:
-                    logger.warning(f"发布消息前连接失效，触发重连（retry: {retry}）")
                     await self.connect()
 
-                # 核心：发布消息（mandatory=True 确保路由有效，timeout=5s 避免阻塞）
-                publish_result = await self._exchange.publish(
+                result = await self._exchange.publish(
                     message=message,
                     routing_key=self.routing_key or self.queue_name or "#",
                     mandatory=True,
                     timeout=5.0
                 )
 
-                # 处理 mandatory 未路由场景
-                if publish_result is None:
-                    raise RuntimeError(
-                        f"消息未找到匹配的队列（routing_key: {self.routing_key}），mandatory=True 触发失败"
-                    )
+                if result is None:
+                    raise RuntimeError(f"消息未找到匹配的队列: {self.routing_key}")
 
-                logger.info(
-                    f"消息发布成功（retry: {retry}），routing_key: {self.routing_key}，"
-                    f"delivery_mode: {delivery_mode.value}，mandatory: True，timeout: 5.0s"
-                )
+                logger.info(f"发布成功: {self.routing_key}")
                 return
-            except asyncio.TimeoutError:
-                logger.error(
-                    f"消息发布超时（retry: {retry}/{retry_count-1}），超时时间: 5.0s"
-                )
+
             except RuntimeError as e:
-                logger.error(
-                    f"消息发布业务失败（retry: {retry}/{retry_count-1}）: {str(e)}"
-                )
+                if "未找到匹配的队列" in str(e):
+                    raise
+                last_exception = str(e)
+                await self._handle_publish_failure()
+
             except Exception as e:
-                logger.error(
-                    f"消息发布失败（retry: {retry}/{retry_count-1}）: {str(e)}",
-                    exc_info=True
-                )
-                # 清理失效状态，下次重试重连
-                self._exchange = None
-            # 指数退避重试间隔
-            await asyncio.sleep(0.5 * (2 ** retry))
+                last_exception = str(e)
+                logger.error(f"发布异常: {e}")
+                await self._handle_publish_failure()
 
-        # 所有重试失败
-        raise RuntimeError(
-            f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}，"
-            f"mandatory: True，timeout: 5.0s"
-        )
+            await asyncio.sleep(5)
+
+        raise RuntimeError(f"消息发布最终失败: {last_exception}")
 
     async def close(self) -> None:
-        """关闭客户端（移除回调+释放资源）"""
         self._closed = True
         logger.info("开始关闭RabbitMQ客户端...")
 
-        # 停止重连任务
         if self._current_reconnect_task and not self._current_reconnect_task.done():
             self._current_reconnect_task.cancel()
             try:
                 await self._current_reconnect_task
             except asyncio.CancelledError:
-                logger.debug("重连任务已取消")
+                pass
 
-        # 1. 停止消费
         await self.stop_consuming()
 
-        # 2. 清理回调+状态（单通道无需归还，连接池统一管理）
         async with self._connect_lock:
             if self._conn_close_callback and self._channel_conn:
                 self._channel_conn.close_callbacks.discard(
                     self._conn_close_callback)
+
             self._channel = None
             self._channel_conn = None
             self._exchange = None
             self._queue = None
             self._message_handler = None
 
-        logger.info("RabbitMQ客户端已完全关闭")
+            # 确保唤醒可能正在等待 connect 的任务
+            self._connecting = False
+            self._connect_condition.notify_all()
+
+        logger.info("客户端已关闭")

sycommon/rabbitmq/rabbitmq_pool.py

@@ -19,12 +19,11 @@ class AsyncProperty:
     def __get__(self, obj, objtype=None):
         if obj is None:
             return self
-        # 关键：当访问 obj.attr 时，直接返回协程对象，而不是方法本身
         return self.method(obj)
 
 
 class RabbitMQConnectionPool:
-    """单连接单通道RabbitMQ客户端 (增强版日志)"""
+    """单连接单通道RabbitMQ客户端 (严格执行“先清理后连接”策略)"""
 
     def __init__(
         self,
@@ -33,9 +32,9 @@ class RabbitMQConnectionPool:
         username: str,
         password: str,
         virtualhost: str = "/",
-        heartbeat: int = 30,
+        heartbeat: int = 15,
         app_name: str = "",
-        connection_timeout: int = 30,
+        connection_timeout: int = 15,
         reconnect_interval: int = 5,
         prefetch_count: int = 2,
     ):
@@ -68,174 +67,231 @@ class RabbitMQConnectionPool:
 
     @AsyncProperty
     async def is_alive(self) -> bool:
-        """对外暴露的连接存活状态（原子化判断）"""
+        """对外暴露的连接存活状态"""
         async with self._lock:
             if self._is_shutdown:
                 return False
-
             if not self._initialized:
                 return False
-
             if self._connection is None or self._connection.is_closed:
                 return False
-
-            # 可选：检查主通道是否存活
             if self._channel is None or self._channel.is_closed:
-                # 如果你认为通道断了连接也算死，就保留这行；否则删除
                 return False
-
             return True
 
-    async def _create_connection_impl(self) -> AbstractRobustConnection:
+    async def _cleanup_resources(self):
         """
-        连接创建入口
+        彻底清理旧资源
+        必须在持有 self._lock 的情况下调用
         """
+        logger.info("🧹 [CLEANUP] 开始清理旧资源...")
+
+        # 1. 清理所有消费者通道
+        if self._consumer_channels:
+            channels_to_close = list(self._consumer_channels.values())
+            self._consumer_channels.clear()
+
+            for ch in channels_to_close:
+                try:
+                    if not ch.is_closed:
+                        await ch.close()
+                except Exception as e:
+                    logger.warning(f"⚠️ [CLEANUP_CH] 关闭消费者通道失败: {e}")
+
+        # 2. 关闭主通道
+        if self._channel:
+            try:
+                if not self._channel.is_closed:
+                    await self._channel.close()
+            except Exception as e:
+                logger.warning(f"⚠️ [CLEANUP_MAIN_CH] 关闭主通道失败: {e}")
+            finally:
+                self._channel = None
+
+        # 3. 关闭连接
+        if self._connection:
+            try:
+                if not self._connection.is_closed:
+                    # close() 可能是同步的，也可能是异步的，aio_pika 中通常是异步的
+                    await self._connection.close()
+            except Exception as e:
+                logger.warning(f"⚠️ [CLEANUP_CONN] 关闭连接失败: {e}")
+            finally:
+                self._connection = None
+
+        logger.info("✅ [CLEANUP] 资源清理完成")
+
+    async def _create_connection_impl(self, host: str) -> AbstractRobustConnection:
         conn_url = (
-            f"amqp://{self.username}:{self.password}@{self._current_host}:{self.port}/"
+            f"amqp://{self.username}:{self.password}@{host}:{self.port}/"
             f"{self.virtualhost}?name={self.app_name}&heartbeat={self.heartbeat}"
             f"&reconnect_interval={self.reconnect_interval}&fail_fast=1"
         )
-        logger.info(
-            f"🔌 [CONNECT_START] 尝试创建连接 -> {self._current_host}:{self.port}")
+        logger.info(f"🔌 [CONNECT] 尝试连接节点: {host}")
         try:
-            conn = await connect_robust(conn_url, timeout=self.connection_timeout)
-            # 注意：connect_robust 返回时，底层 TCP 可能还在握手，但对象已创建
-            logger.info(f"✅ [CONNECT_OK] 连接对象创建成功: {id(conn)}")
+            conn = await asyncio.wait_for(
+                connect_robust(conn_url),
+                timeout=self.connection_timeout + 5
+            )
+            logger.info(f"✅ [CONNECT_OK] 节点连接成功: {host}")
             return conn
         except Exception as e:
-            logger.error(f"❌ [CONNECT_FAIL] 连接创建失败: {str(e)}")
-            raise ConnectionError(f"无法连接RabbitMQ {self._current_host}") from e
-
-    async def _create_channel_impl(self, connection: AbstractRobustConnection) -> RobustChannel:
-        """创建通道"""
-        try:
-            channel = await connection.channel()
-            await channel.set_qos(prefetch_count=self.prefetch_count)
-            logger.debug(f"✅ [CHANNEL_OK] 通道创建成功: {id(channel)}")
-            return channel
-        except Exception as e:
-            logger.error(f"❌ [CHANNEL_FAIL] 通道创建失败: {str(e)}")
-            raise
+            logger.error(f"❌ [CONNECT_FAIL] 节点 {host} 连接失败: {str(e)}")
+            raise ConnectionError(f"无法连接RabbitMQ {host}") from e
 
     async def _ensure_main_channel(self) -> RobustChannel:
-        """确保主通道有效 (原子操作 + 自动轮询重试 + 失败清理)"""
+        """
+        确保主通道有效
+        逻辑：
+        1. 检查连接状态
+        2. 如果断开 -> 清理 -> 轮询重试
+        3. 如果连接在但通道断开 -> 仅重建通道
+        """
         async with self._lock:
             if self._is_shutdown:
                 raise RuntimeError("客户端已关闭")
 
-            # 如果连接对象不存在或已关闭，进入重连流程
+            # --- 阶段A：连接恢复逻辑 (如果连接断了) ---
             if self._connection is None or self._connection.is_closed:
-                retry_hosts = self.hosts.copy()  # 复制一份列表用于重试
+
+                # 1. 【强制】先彻底清理所有旧资源
+                await self._cleanup_resources()
+
+                retry_hosts = self.hosts.copy()
+                random.shuffle(retry_hosts)
                 last_error = None
-                temp_conn = None  # 临时变量，用于引用本次尝试创建的连接
+                max_attempts = min(len(retry_hosts), 3)
 
-                # 轮询尝试列表中的每一个 Host
-                while retry_hosts:
-                    host = random.choice(retry_hosts)
-                    retry_hosts.remove(host)  # 从待尝试列表中移除
+                # 2. 轮询尝试新连接
+                for _ in range(max_attempts):
+                    if not retry_hosts:
+                        break
 
-                    logger.info(f"⚠️ [RECONNECT] 尝试连接节点: {host}")
+                    host = retry_hosts.pop()
                     self._current_host = host
-                    temp_conn = None  # 重置临时引用
+                    temp_conn = None
 
                     try:
-                        conn_url = (
-                            f"amqp://{self.username}:{self.password}@{host}:{self.port}/"
-                            f"{self.virtualhost}?name={self.app_name}&heartbeat={self.heartbeat}"
-                            f"&reconnect_interval={self.reconnect_interval}&fail_fast=1"
-                        )
-
-                        # 尝试连接
-                        temp_conn = await connect_robust(conn_url, timeout=self.connection_timeout)
+                        temp_conn = await self._create_connection_impl(host)
 
-                        # --- 关键点：连接成功 ---
+                        # 3. 只有在连接成功后，才更新 self._connection
                         self._connection = temp_conn
-                        temp_conn = None  # 清空临时引用，因为所有权已经移交给 self._connection
-
-                        logger.info(f"🔗 [RECONNECT_OK] 成功连接到节点: {host}")
+                        temp_conn = None  # 转移所有权
+                        self._initialized = True
                         last_error = None
-                        break  # 成功，跳出循环
+                        logger.info(f"🔗 [RECONNECT_OK] 切换到节点: {host}")
+                        break
 
                     except Exception as e:
-                        logger.warning(
-                            f"❌ [RECONNECT_FAIL] 节点 {host} 不可用: {str(e)}")
-
-                        # 【核心修复】清理失败的连接对象
+                        logger.warning(f"⚠️ [RECONNECT_RETRY] 节点 {host} 不可用")
                         if temp_conn is not None:
+                            # 尝试连接失败了，必须把这个“半成品”连接关掉
                             try:
-                                logger.debug(
-                                    f"🧹 [CLEANUP] 正在关闭失败的连接对象: {id(temp_conn)}")
-                                # 即使连接对象处于异常状态，close() 通常也是安全的
                                 await temp_conn.close()
-                                logger.debug(f"✅ [CLEANUP] 失败连接已关闭")
-                            except Exception as close_err:
-                                logger.warning(
-                                    f"⚠️ [CLEANUP_ERR] 关闭失败连接时出错: {str(close_err)}")
-
+                            except Exception:
+                                pass
                         last_error = e
-                        asyncio.sleep(self.reconnect_interval)
-                        continue  # 继续试下一个
+                        await asyncio.sleep(self.reconnect_interval)
 
-                # 如果所有节点都试完了还是失败
+                # 4. 如果所有尝试都失败
                 if last_error:
-                    logger.error("💥 [RECONNECT_FATAL] 所有 RabbitMQ 节点均不可用")
+                    # 确保状态是干净的
+                    self._connection = None
+                    self._initialized = False
+                    logger.error("💥 [RECONNECT_FATAL] 所有节点重试失败")
                     raise ConnectionError("所有 RabbitMQ 节点连接失败") from last_error
 
-            # 2. 确保主通道存在
+            # --- 阶段B：通道恢复逻辑 (如果连接在但通道断了) ---
+            # 注意：这里不需要清理连接，只重置通道
             if self._channel is None or self._channel.is_closed:
-                logger.info("⚠️ [RECOVER_CHANNEL] 检测到主通道不存在或已关闭，开始恢复...")
-                self._channel = await self._create_channel_impl(self._connection)
+                try:
+                    self._channel = await self._connection.channel()
+                    await self._channel.set_qos(prefetch_count=self.prefetch_count)
+                    logger.info(f"✅ [CHANNEL_OK] 主通道已恢复")
+                except Exception as e:
+                    # 如果连通道都创建不了，说明这个连接也是坏的，回滚到阶段A
+                    logger.error(f"❌ [CHANNEL_FAIL] 通道创建失败，标记连接无效: {e}")
+                    # 强制清理连接，触发下一次进入阶段A
+                    await self._cleanup_resources()
+                    raise
 
             return self._channel
 
     async def init_pools(self):
-        """
-        初始化入口与异常处理 (修复泄漏的关键)
-        """
+        """初始化入口"""
         async with self._lock:
             if self._is_shutdown:
                 raise RuntimeError("客户端已关闭")
             if self._initialized:
                 return
 
+        # 在 try 之前声明变量，确保 except 块能访问
         conn_created_in_this_try = None
+
         try:
-            # 步骤 A: 创建连接 (在锁外进行，避免阻塞其他操作)
-            conn = await self._create_connection_impl()
-            conn_created_in_this_try = conn  # 记录本次创建的对象，用于失败回滚
+            # 锁外创建连接，减少锁持有时间
+            init_host = random.choice(self.hosts)
+            conn = await self._create_connection_impl(init_host)
+
+            # 记录本次创建的连接
+            conn_created_in_this_try = conn
 
-            # 步骤 B: 更新状态和初始化通道 (在锁内进行，保证原子性)
             async with self._lock:
                 if self._is_shutdown:
-                    # 如果在创建连接期间，外部调用了 close，则必须立即清理刚创建的连接
-                    logger.warning("⚠️ [ABORT] 检测到关闭信号，放弃初始化并清理资源")
                     raise RuntimeError("客户端已关闭")
 
+                # 提交新资源
                 self._connection = conn
-                self._channel = await self._create_channel_impl(conn)
+                self._channel = await self._connection.channel()
+                await self._channel.set_qos(prefetch_count=self.prefetch_count)
                 self._initialized = True
-                logger.info(
-                    f"🚀 [INIT_SUCCESS] 客户端初始化完成. ConnID: {id(self._connection)}")
+
+                # 所有权转移成功，清空临时引用，防止 finally 重复关闭
+                conn_created_in_this_try = None
+
+                logger.info(f"🚀 [INIT_OK] 连接池初始化完成: {init_host}")
 
         except Exception as e:
-            logger.error(f"💥 [INIT_ERROR] 初始化流程异常: {str(e)}", exc_info=True)
-            # 如果步骤A成功但步骤B失败（例如通道创建失败），或者步骤B中出错，
-            # 必须显式关闭在步骤A中创建的连接，否则它会变成“游离连接”。
-            if conn_created_in_this_try:
-                logger.warning(
-                    f"🧹 [LEAK_PREVENTION] 检测到初始化失败，正在显式关闭刚创建的连接: {id(conn_created_in_this_try)}")
+            logger.error(f"💥 [INIT_FAIL] 初始化异常: {str(e)}")
+
+            # 这里现在可以合法访问 conn_created_in_this_try
+            if conn_created_in_this_try is not None:
                 try:
                     await conn_created_in_this_try.close()
-                    logger.info(
-                        f"✅ [CLOSE_OK] 泄漏连接已关闭: {id(conn_created_in_this_try)}")
-                except Exception as close_err:
-                    logger.error(f"❌ [CLOSE_ERR] 关闭泄漏连接时出错: {str(close_err)}")
+                except Exception:
+                    pass
 
-            # 如果是因为中途关闭导致的错误，不需要再次调用全局 close，否则调用
             if not self._is_shutdown:
                 await self.close()
             raise
 
+    async def force_reconnect(self):
+        """
+        强制重连
+        严格执行：清理所有资源 -> 尝试建立新资源
+        """
+        async with self._lock:
+            if self._is_shutdown:
+                return
+
+            logger.warning("🔄 [FORCE_RECONNECT] 开始强制重连...")
+
+            # 1. 【关键】标记未初始化，迫使 _ensure_main_channel 走清理流程
+            self._initialized = False
+
+            # 2. 【关键】立即清理旧资源 (在锁内)
+            await self._cleanup_resources()
+
+            # 此时 self._connection 和 self._channel 均为 None
+
+        # 3. 锁外触发恢复 (避免阻塞锁太久)
+        try:
+            await self.acquire_channel()
+            logger.info("✅ [FORCE_RECONNECT_OK] 强制重连成功")
+        except Exception as e:
+            logger.error(f"❌ [FORCE_RECONNECT_FAIL] 强制重连失败: {e}")
+            raise
+
     async def acquire_channel(self) -> Tuple[RobustChannel, AbstractRobustConnection]:
         """获取主通道"""
         if not self._initialized and not self._is_shutdown:
@@ -243,22 +299,20 @@ class RabbitMQConnectionPool:
         return await self._ensure_main_channel(), self._connection
 
     async def publish_message(self, routing_key: str, message_body: bytes, exchange_name: str = "", **kwargs):
-        """发布消息"""
         channel, _ = await self.acquire_channel()
         try:
             exchange = channel.default_exchange if not exchange_name else await channel.get_exchange(exchange_name)
             message = Message(body=message_body, **kwargs)
             await exchange.publish(message, routing_key=routing_key)
-            logger.debug(f"📤 [PUBLISH] 消息发布成功 - RK: {routing_key}")
         except Exception as e:
             logger.error(f"❌ [PUBLISH_FAIL] 发布失败: {str(e)}")
             raise
 
     async def consume_queue(self, queue_name: str, callback: Callable[[AbstractMessage], asyncio.Future], auto_ack: bool = False, **kwargs):
-        """消费队列"""
         if not self._initialized:
             await self.init_pools()
 
+        # 检查是否已存在
         async with self._lock:
             if self._is_shutdown:
                 raise RuntimeError("客户端已关闭")
@@ -268,20 +322,26 @@ class RabbitMQConnectionPool:
             if not self._connection or self._connection.is_closed:
                 raise RuntimeError("连接不可用，无法启动消费")
 
+        # 声明队列 (使用主通道)
         await self.declare_queue(queue_name, **kwargs)
 
         try:
-            # 获取原始连接对象创建新通道
-            conn = self._connection
+            # 获取最新连接
+            _, conn = await self.acquire_channel()
+
+            # 创建消费者通道
             consumer_channel = await conn.channel()
             await consumer_channel.set_qos(prefetch_count=self.prefetch_count)
-            logger.info(
-                f"✅ [CONSUMER_CHANNEL_OK] 消费者通道创建: {id(consumer_channel)}")
 
             async with self._lock:
+                # 再次检查，防止并发创建
                 if self._is_shutdown:
                     await consumer_channel.close()
                     return
+                if queue_name in self._consumer_channels:
+                    await consumer_channel.close()  # 其他协程已经创建了
+                    return
+
                 self._consumer_channels[queue_name] = consumer_channel
 
             async def consume_callback_wrapper(message: AbstractMessage):
@@ -290,77 +350,45 @@ class RabbitMQConnectionPool:
                     if not auto_ack:
                         await message.ack()
                 except Exception as e:
-                    logger.error(
-                        f"❌ [CALLBACK_ERR] 消费回调异常 {queue_name}: {str(e)}")
+                    logger.error(f"❌ [CALLBACK_ERR] {queue_name}: {e}")
                     if not auto_ack:
                         await message.nack(requeue=True)
 
             await consumer_channel.basic_consume(
-                queue_name, consumer_callback=consume_callback_wrapper, auto_ack=auto_ack, **kwargs
+                queue_name, consumer_callback=consume_callback_wrapper, auto_ack=auto_ack
             )
-            logger.info(f"🎧 [CONSUME_START] 开始消费队列: {queue_name}")
+            logger.info(f"🎧 [CONSUME_START] {queue_name}")
 
         except Exception as e:
-            logger.error(f"💥 [CONSUME_ERR] 启动消费失败 {queue_name}: {str(e)}")
+            logger.error(f"💥 [CONSUME_ERR] {queue_name}: {e}")
+            # 失败时清理字典
             async with self._lock:
                 if queue_name in self._consumer_channels:
-                    del self._consumer_channels[queue_name]
+                    # 注意：这里清理的是字典里的引用，通道本身应该在 try 块里被关闭了吗？
+                    # 如果 consumer_channel 创建成功但 basic_consume 失败，需要手动关闭
+                    ch = self._consumer_channels.pop(queue_name, None)
+                    if ch:
+                        try:
+                            await ch.close()
+                        except:
+                            pass
             raise
 
     async def close(self):
-        """
-        资源销毁入口
-        """
+        """资源销毁"""
         async with self._lock:
             if self._is_shutdown:
                 return
             self._is_shutdown = True
             self._initialized = False
-            # 记录即将关闭的连接ID
-            conn_to_close_id = id(
-                self._connection) if self._connection else None
-
-        logger.info(f"🛑 [CLOSE_START] 开始关闭客户端... (准备关闭连接: {conn_to_close_id})")
 
-        # 1. 关闭消费者通道
-        channels_to_close = []
-        async with self._lock:
-            channels_to_close = list(self._consumer_channels.values())
-            self._consumer_channels.clear()
-
-        for ch in channels_to_close:
-            try:
-                if not ch.is_closed:
-                    await ch.close()
-                    logger.debug(f"✅ [CLOSE_CHANNEL] 消费者通道已关闭")
-            except Exception as e:
-                logger.warning(f"❌ [CLOSE_CHANNEL_ERR] 关闭消费者通道失败: {str(e)}")
+        logger.info("🛑 [CLOSE] 开始关闭连接池...")
 
-        # 2. 关闭主通道
-        if self._channel:
-            try:
-                if not self._channel.is_closed:
-                    await self._channel.close()
-                    logger.info(f"✅ [CLOSE_CHANNEL] 主通道已关闭")
-            except Exception:
-                pass
-            self._channel = None
-
-        # 3. 关闭连接
-        # 确保在 finally 或显式 close 中调用 connection.close()
-        if self._connection:
-            try:
-                # 打印关闭操作
-                logger.info(f"🔌 [CLOSE_CONN] 正在关闭连接: {id(self._connection)}")
-                await self._connection.close()
-                logger.info(f"✅ [CLOSE_OK] 连接已成功关闭: {id(self._connection)}")
-            except Exception as e:
-                logger.warning(f"❌ [CLOSE_ERR] 关闭连接失败: {str(e)}")
-            self._connection = None
+        # 1. 清理所有资源
+        await self._cleanup_resources()
 
-        logger.info("🏁 [CLOSE_DONE] RabbitMQ客户端已完全关闭")
+        logger.info("🏁 [CLOSE] 连接池已关闭")
 
-    # --- 辅助方法省略 (declare_queue 等) ---
     async def declare_queue(self, queue_name: str, **kwargs) -> AbstractQueue:
         channel, _ = await self.acquire_channel()
         return await channel.declare_queue(queue_name, **kwargs)

sycommon/rabbitmq/rabbitmq_service_core.py

@@ -70,8 +70,8 @@ class RabbitMQCoreService:
                 virtualhost=cls._config.get('virtual-host', "/"),
                 app_name=cls._config.get("APP_NAME", ""),
                 prefetch_count=global_prefetch_count,
-                heartbeat=cls._config.get('heartbeat', 30),
-                connection_timeout=cls._config.get('connection_timeout', 30),
+                heartbeat=cls._config.get('heartbeat', 15),
+                connection_timeout=cls._config.get('connection_timeout', 15),
                 reconnect_interval=cls._config.get('reconnect_interval', 5),
             )
 

{sycommon_python_lib-0.1.56b11.dist-info → sycommon_python_lib-0.1.56b12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.56b11
+Version: 0.1.56b12
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.1.56b11.dist-info → sycommon_python_lib-0.1.56b12.dist-info}/RECORD

@@ -47,13 +47,13 @@ sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
 sycommon/notice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/notice/uvicorn_monitor.py,sha256=VryQYcAtjijJuGDBimbVurgwxlsLaLtkNnABPDY5Tao,7332
-sycommon/rabbitmq/rabbitmq_client.py,sha256=jClUm9Ao9vZ2IZg7IXIEaDbYYnV8qtmtm77vdmwpKE4,22599
-sycommon/rabbitmq/rabbitmq_pool.py,sha256=5ruFVViSCKA7ToZmR2dZIkP0zT0ZcfsnkSGbrdkg0Tk,16141
+sycommon/rabbitmq/rabbitmq_client.py,sha256=JZ73fc0Z8iMnayvRhRsnkEkBfzKF3wbxDKTE98RwVIA,17809
+sycommon/rabbitmq/rabbitmq_pool.py,sha256=BiFQgZPzSAFR-n5XhyIafoeWQXETF_31nFRDhMbe6aU,15577
 sycommon/rabbitmq/rabbitmq_service.py,sha256=XSHo9HuIJ_lq-vizRh4xJVdZr_2zLqeLhot09qb0euA,2025
 sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=MM4r8Pa2rjAmzy_NpHFb4thGznr6AYk6m__IC8IIxEM,7852
 sycommon/rabbitmq/rabbitmq_service_connection_monitor.py,sha256=uvoMuJDzJ9i63uVRq1NKFV10CvkbGnTMyEoq2rgjQx8,3013
 sycommon/rabbitmq/rabbitmq_service_consumer_manager.py,sha256=489r1RKd5WrTNMAcWCxUZpt9yWGrNunZlLCCp-M_rzM,11497
-sycommon/rabbitmq/rabbitmq_service_core.py,sha256=_9gqc7BOhrzfeYS557yIOfyCAraAKh-3ClMpKHn9ufY,4753
+sycommon/rabbitmq/rabbitmq_service_core.py,sha256=6RMvIf78DmEOZmN8dA0duA9oy4ieNswdGrOeyJdD6tU,4753
 sycommon/rabbitmq/rabbitmq_service_producer_manager.py,sha256=TJrLbvsjF55P9lwr7aCm9uRIRuC3z4EZNx74KEVKBtU,10190
 sycommon/sentry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/sentry/sy_sentry.py,sha256=e5Fbt9Gi2gIb048z0nuKbuhp3uCAEqYH2xXbF6qrZq4,1471
@@ -78,8 +78,8 @@ sycommon/tools/env.py,sha256=Ah-tBwG2C0_hwLGFebVQgKdWWXCjTzBuF23gCkLHYy4,2437
 sycommon/tools/merge_headers.py,sha256=HV_i52Q-9se3SP8qh7ZGYl8bP7Fxtal4CGVkyMwEdM8,4373
 sycommon/tools/snowflake.py,sha256=lVEe5mNCOgz5OqGQpf5_nXaGnRJlI2STX2s-ppTtanA,11947
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.56b11.dist-info/METADATA,sha256=uWU5EW2z6Tsw_iwPxxy5AkDK84Jq6UfPsNg23_j2GD8,7270
-sycommon_python_lib-0.1.56b11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.56b11.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.56b11.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.56b11.dist-info/RECORD,,
+sycommon_python_lib-0.1.56b12.dist-info/METADATA,sha256=dkuadRkMxJOl31ynqjcEezKtvoQ7On9qeGyGSnxCUZ0,7270
+sycommon_python_lib-0.1.56b12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.56b12.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.56b12.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.56b12.dist-info/RECORD,,