sycommon-python-lib 0.1.41__tar.gz → 0.1.43__tar.gz

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.43}/PKG-INFO

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

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.43}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.41"
+version = "0.1.43"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.43}/src/sycommon/middleware/traceid.py

@@ -79,7 +79,7 @@ def setup_trace_id_handler(app):
 
             content_type = response.headers.get("Content-Type", "")
 
-            # 处理 SSE 响应 - 关键修复点
+            # 处理 SSE 响应
             if "text/event-stream" in content_type:
                 # 流式响应不能有Content-Length，移除它
                 if "Content-Length" in response.headers:

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.43}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -85,6 +85,22 @@ class RabbitMQClient:
         # 线程安全锁
         self._consume_lock = asyncio.Lock()
         self._connect_lock = asyncio.Lock()
+        # 跟踪连接关闭回调（用于后续移除）
+        self._conn_close_callback: Optional[Callable] = None
+        # 控制重连频率的信号量（避免短时间内大量重连任务）
+        self._reconnect_semaphore = asyncio.Semaphore(1)
+        # 重连冷却时间（秒）
+        self._reconnect_cooldown = 3
+        # 固定重连间隔15秒（全局统一）
+        self._RECONNECT_INTERVAL = 15
+        # 重连任务锁（确保同一时间只有一个重连任务）
+        self._reconnect_task_lock = asyncio.Lock()
+        # 跟踪当前重连任务（避免重复创建）
+        self._current_reconnect_task: Optional[asyncio.Task] = None
+        # 连接失败计数器（用于告警）
+        self._reconnect_fail_count = 0
+        # 连接失败告警阈值
+        self._reconnect_alert_threshold = 5
 
     @property
     async def is_connected(self) -> bool:
@@ -104,14 +120,16 @@ class RabbitMQClient:
             return False
 
     async def connect(self) -> None:
-        """建立连接并初始化交换机/队列（支持重连）"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
         async with self._connect_lock:
-            # 释放旧的无效资源
+            # 释放旧资源（保留原有回调清理逻辑）
             if self._channel and self._channel_conn:
                 try:
+                    if self._conn_close_callback and self._channel_conn:
+                        self._channel_conn.close_callbacks.discard(
+                            self._conn_close_callback)
                     await self.connection_pool.release_channel(self._channel, self._channel_conn)
                 except Exception as e:
                     SYLogger.warning(f"释放旧通道失败: {str(e)}")
@@ -119,11 +137,29 @@ class RabbitMQClient:
             self._channel_conn = None
             self._exchange = None
             self._queue = None
+            self._conn_close_callback = None
 
             try:
-                # 1. 从连接池获取通道+连接
+                # 从连接池获取通道+连接（连接池已控制连接数）
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
+                def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
+                    """连接关闭回调：触发固定间隔重连"""
+                    SYLogger.warning(
+                        f"客户端连接关闭: {conn!r}，原因: {exc}", exc_info=exc)
+                    self._reconnect_fail_count += 1
+                    # 超过阈值告警
+                    if self._reconnect_fail_count >= self._reconnect_alert_threshold:
+                        SYLogger.error(
+                            f"连接失败次数已达阈值({self._reconnect_alert_threshold})，请检查MQ服务状态")
+                    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)
+
                 # 2. 设置预取计数（限流）
                 await self._channel.set_qos(prefetch_count=self.prefetch_count)
                 SYLogger.debug(f"设置预取计数: {self.prefetch_count}")
@@ -157,10 +193,15 @@ class RabbitMQClient:
                         f"（绑定交换机: {self.exchange_name}, routing_key: {self.routing_key}）"
                     )
 
+                # 重连成功，重置失败计数器
+                self._reconnect_fail_count = 0
                 SYLogger.info("客户端连接初始化完成")
             except Exception as e:
                 SYLogger.error(f"客户端连接失败: {str(e)}", exc_info=True)
                 # 清理异常状态
+                if self._conn_close_callback and self._channel_conn:
+                    self._channel_conn.close_callbacks.discard(
+                        self._conn_close_callback)
                 if self._channel and self._channel_conn:
                     try:
                         await self.connection_pool.release_channel(self._channel, self._channel_conn)
@@ -168,8 +209,40 @@ class RabbitMQClient:
                         pass
                 self._channel = None
                 self._channel_conn = None
+                # 触发重连（固定间隔）
+                if not self._closed:
+                    asyncio.create_task(self._safe_reconnect())
                 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:
+                return
+
+            # 固定15秒重连间隔
+            SYLogger.info(f"将在15秒后尝试重连...")
+            await asyncio.sleep(self._RECONNECT_INTERVAL)
+
+            if self._closed or await self.is_connected:
+                return
+
+            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
+
     async def set_message_handler(
         self,
         handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]],
@@ -340,14 +413,18 @@ class RabbitMQClient:
         )
 
     async def close(self) -> None:
-        """关闭客户端（释放资源）"""
-        if self._closed:
-            SYLogger.warning("客户端已关闭，无需重复操作")
-            return
-
+        """关闭客户端（移除回调）"""
         self._closed = True
         SYLogger.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:
+                SYLogger.debug("重连任务已取消")
+
         # 1. 停止消费
         await self.stop_consuming()
 
@@ -355,6 +432,10 @@ class RabbitMQClient:
         async with self._connect_lock:
             if self._channel and self._channel_conn:
                 try:
+                    # 移除连接关闭回调
+                    if self._conn_close_callback:
+                        self._channel_conn.close_callbacks.discard(
+                            self._conn_close_callback)
                     await self.connection_pool.release_channel(self._channel, self._channel_conn)
                     SYLogger.info("通道释放成功")
                 except Exception as e:

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.43}/src/sycommon/rabbitmq/rabbitmq_pool.py

@@ -19,11 +19,11 @@ class RabbitMQConnectionPool:
         password: str,
         virtualhost: str = "/",
         connection_pool_size: int = 2,
-        channel_pool_size: int = 10,
+        channel_pool_size: int = 5,
         heartbeat: int = 30,
         app_name: str = "",
-        reconnect_interval: int = 3,
-        connection_timeout: int = 30
+        reconnect_interval: int = 15,
+        connection_timeout: int = 10,
     ):
         self.hosts = [host.strip() for host in hosts if host.strip()]
         if not self.hosts:
@@ -55,6 +55,22 @@ class RabbitMQConnectionPool:
         # 连接状态
         self._initialized = False
         self._reconnect_task: Optional[asyncio.Task] = None
+        self._is_shutdown = False
+
+    @property
+    def is_alive(self) -> bool:
+        if not self._initialized:
+            return False
+        # 异步清理失效连接（不阻塞当前调用）
+        asyncio.create_task(self._check_connections())
+        # 同步校验存活连接（即使清理未完成，也能反映当前状态）
+        return any(not conn.is_closed for conn, _ in self._connections)
+
+    async def _check_connections(self):
+        """异步检查连接有效性（清理已关闭的连接）"""
+        async with self._conn_lock:
+            self._connections = [
+                (conn, ts) for conn, ts in self._connections if not conn.is_closed]
 
     async def init_pools(self):
         """初始化连接池+启动连接监控任务"""
@@ -96,17 +112,21 @@ class RabbitMQConnectionPool:
                 continue
 
     async def _create_single_connection(self) -> AbstractRobustConnection:
-        """创建单个RabbitMQ连接（支持集群轮询+失败重试）"""
         hosts = self.hosts.copy()
         retry_count = 0
-        max_retries = 3  # 最大重试3次
+        max_retries = 3  # 每个节点最多重试3次
 
-        while retry_count < max_retries:
+        while retry_count < max_retries and not self._is_shutdown:
             if not hosts:
-                hosts = self.hosts.copy()  # 所有节点尝试完毕，重新轮询
+                hosts = self.hosts.copy()
                 retry_count += 1
-                # 指数退避重试（1s, 2s, 4s）
-                await asyncio.sleep(self.reconnect_interval * (2 ** (retry_count - 1)))
+                if retry_count >= max_retries:
+                    logger.error(
+                        f"所有RabbitMQ节点（{self.hosts}）均连接失败，已重试{max_retries}次，将在15秒后再次尝试"
+                    )
+                    # 固定15秒间隔后退出，由监控任务触发下一次重试
+                    await asyncio.sleep(self.reconnect_interval)
+                    break
 
             host = hosts.pop(0)
             conn_url = (
@@ -120,18 +140,17 @@ class RabbitMQConnectionPool:
                     client_properties={
                         "connection_name": f"{self.app_name}@{host}"
                     },
-                    reconnect_interval=self.reconnect_interval,
+                    reconnect_interval=self.reconnect_interval,  # 客户端内置重连间隔也设为15秒
                 )
 
-                # 定义连接关闭回调函数（接收连接实例和异常信息）
+                # 连接关闭回调（固定间隔重连）
                 def on_connection_closed(conn_instance: AbstractConnection, exc: Optional[BaseException]):
-                    logger.error(
+                    logger.warning(
                         f"RabbitMQ连接关闭: {conn_instance!r}，原因: {exc}", exc_info=exc)
-                    # 异步触发连接重建（需用 asyncio.create_task 包装）
                     asyncio.create_task(
                         self._remove_invalid_connection(cast(AbstractRobustConnection, conn_instance)))
 
-                # 直接向 close_callbacks 添加回调（AbstractConnection 原生支持）
+                setattr(conn, '_pool_close_callback', on_connection_closed)
                 conn.close_callbacks.add(on_connection_closed)
 
                 logger.info(f"成功连接到RabbitMQ节点: {host}:{self.port}")
@@ -140,6 +159,8 @@ class RabbitMQConnectionPool:
                 logger.warning(
                     f"连接节点 {host}:{self.port} 失败（重试{retry_count}/{max_retries}）: {str(e)}"
                 )
+                # 每个节点连接失败后，固定等待15秒再尝试下一个节点
+                await asyncio.sleep(self.reconnect_interval)
 
         raise RuntimeError(
             f"所有RabbitMQ节点连接失败（已重试{max_retries}次），节点列表: {self.hosts}"
@@ -147,6 +168,14 @@ class RabbitMQConnectionPool:
 
     async def _remove_invalid_connection(self, invalid_conn: AbstractRobustConnection) -> None:
         """移除失效连接及关联通道"""
+        try:
+            # 关键修复：移除连接关闭回调
+            callback = getattr(invalid_conn, '_pool_close_callback', None)
+            if callback:
+                invalid_conn.close_callbacks.discard(callback)
+                delattr(invalid_conn, '_pool_close_callback', None)
+        except Exception as e:
+            logger.warning(f"移除连接回调失败: {str(e)}")
         # 1. 移除失效连接
         async with self._conn_lock:
             self._connections = [
@@ -164,8 +193,14 @@ class RabbitMQConnectionPool:
         asyncio.create_task(self._recreate_connection())
 
     async def _recreate_connection(self):
-        """重建一个连接并补充通道"""
+        """重建连接：固定间隔重试"""
         try:
+            # 重建前检查是否已达到连接池上限
+            async with self._conn_lock:
+                if len(self._connections) >= self.connection_pool_size:
+                    logger.debug("连接池已达最大限制，跳过重建连接")
+                    return
+
             conn = await self._create_single_connection()
             async with self._conn_lock:
                 self._connections.append(
@@ -181,20 +216,29 @@ class RabbitMQConnectionPool:
                     logger.warning(f"为新连接创建通道失败: {str(e)}")
         except Exception as e:
             logger.error(f"重建连接失败: {str(e)}", exc_info=True)
+            # 重建失败后，15秒后再次尝试
+            if not self._is_shutdown:
+                asyncio.create_task(self._recreate_connection())
 
     async def _monitor_connections(self):
-        """后台监控连接状态（每30秒检查一次）"""
-        while self._initialized:
+        """后台监控：固定15秒检查一次连接状态"""
+        while self._initialized and not self._is_shutdown:
             try:
-                await asyncio.sleep(30)
+                await asyncio.sleep(self.reconnect_interval)  # 固定15秒间隔检查
                 current_time = asyncio.get_event_loop().time()
+
+                # 清理失效/超时连接
                 async with self._conn_lock:
-                    # 检查连接有效性+清理超时连接（10分钟无活动）
                     valid_connections = []
                     for conn, last_active in self._connections:
-                        if conn.is_closed or (current_time - last_active) > 600:
+                        if conn.is_closed or (current_time - last_active) > 600:  # 10分钟无活动清理
                             logger.warning(f"清理失效/超时连接: {conn}")
                             try:
+                                # 移除回调+关闭连接
+                                callback = getattr(
+                                    conn, '_pool_close_callback', None)
+                                if callback:
+                                    conn.close_callbacks.discard(callback)
                                 await conn.close()
                             except:
                                 pass
@@ -202,13 +246,18 @@ class RabbitMQConnectionPool:
                             valid_connections.append((conn, last_active))
                     self._connections = valid_connections
 
-                # 补充缺失的连接
+                # 补充缺失的连接（不超过连接池最大限制）
                 missing_conn_count = self.connection_pool_size - \
                     len(self._connections)
-                for _ in range(missing_conn_count):
-                    asyncio.create_task(self._recreate_connection())
+                if missing_conn_count > 0:
+                    logger.info(f"连接池缺少{missing_conn_count}个连接，尝试补充")
+                    # 逐个补充，避免同时创建大量连接
+                    for _ in range(missing_conn_count):
+                        asyncio.create_task(self._recreate_connection())
             except Exception as e:
                 logger.error(f"连接监控任务异常: {str(e)}", exc_info=True)
+                # 异常后仍保持15秒间隔
+                await asyncio.sleep(self.reconnect_interval)
 
     async def acquire_channel(self) -> Tuple[Channel, AbstractRobustConnection]:
         """获取通道（返回通道+所属连接，便于释放时校验）"""
@@ -303,6 +352,11 @@ class RabbitMQConnectionPool:
         async with self._conn_lock:
             for conn, _ in self._connections:
                 try:
+                    # 移除所有连接的回调
+                    callback = getattr(conn, '_pool_close_callback', None)
+                    if callback:
+                        conn.close_callbacks.discard(callback)
+                        delattr(conn, '_pool_close_callback', None)
                     if not conn.is_closed:
                         await conn.close()
                 except Exception as e:

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.43}/src/sycommon/rabbitmq/rabbitmq_service.py

@@ -1,10 +1,11 @@
 import asyncio
 import json
 from typing import (
-    Callable, Coroutine, Dict, List, Optional, Type, Union, Any, Set
+    Callable, Coroutine, Dict, List, Optional, Type, Union, Any, Set, Tuple, cast
 )
 from pydantic import BaseModel
-from aio_pika.abc import AbstractIncomingMessage, ConsumerTag
+from aio_pika.abc import AbstractIncomingMessage, ConsumerTag, AbstractRobustConnection
+from aio_pika import Channel, exceptions as aio_pika_exceptions
 
 from sycommon.models.mqmsg_model import MQMsgModel
 from sycommon.models.mqlistener_config import RabbitMQListenerConfig
@@ -19,7 +20,7 @@ logger = SYLogger
 class RabbitMQService:
     """
     RabbitMQ服务封装，管理多个客户端实例，基于连接池实现资源复用
-    适配细粒度锁设计的RabbitMQClient，确保线程安全
+    适配细粒度锁设计的RabbitMQClient，确保线程安全+高可用
     """
 
     # 保存多个客户端实例
@@ -52,12 +53,15 @@ class RabbitMQService:
     _is_shutdown: bool = False
     # 服务关闭锁
     _shutdown_lock = asyncio.Lock()
+    # 连接状态监控任务
+    _connection_monitor_task: Optional[asyncio.Task] = None
+    # 重连配置
+    RECONNECT_INTERVAL = 15  # 重连基础间隔（秒）
+    MAX_RECONNECT_ATTEMPTS = 10  # 最大连续重连次数
 
     @classmethod
     def init(cls, config: dict, has_listeners: bool = False, has_senders: bool = False) -> Type['RabbitMQService']:
-        """
-        初始化RabbitMQ服务（支持集群配置），同时创建连接池
-        """
+        """初始化RabbitMQ服务（支持集群配置），同时创建连接池"""
         from sycommon.synacos.nacos_service import NacosService
 
         # 防止重复初始化
@@ -75,7 +79,8 @@ class RabbitMQService:
             f"RabbitMQ服务初始化 - 集群节点: {cls._config.get('host')}, "
             f"端口: {cls._config.get('port')}, "
             f"虚拟主机: {cls._config.get('virtual-host')}, "
-            f"应用名: {cls._config.get('APP_NAME')}"
+            f"应用名: {cls._config.get('APP_NAME')}, "
+            f"心跳: {cls._config.get('heartbeat', 30)}s"
         )
 
         # 保存发送器和监听器存在状态
@@ -86,6 +91,10 @@ class RabbitMQService:
         # 初始化连接池（在单独的异步方法中启动）
         asyncio.create_task(cls._init_connection_pool())
 
+        # 启动连接监控任务（监听连接状态，自动重连）
+        cls._connection_monitor_task = asyncio.create_task(
+            cls._monitor_connections())
+
         return cls
 
     @classmethod
@@ -110,9 +119,8 @@ class RabbitMQService:
                 password=cls._config.get('password', ""),
                 virtualhost=cls._config.get('virtual-host', "/"),
                 connection_pool_size=cls._config.get(
-                    'connection_pool_size', 5),  # 连接池大小
-                channel_pool_size=cls._config.get(
-                    'channel_pool_size', 10),       # 通道池大小
+                    'connection_pool_size', 2),
+                channel_pool_size=cls._config.get('channel_pool_size', 5),
                 heartbeat=cls._config.get('heartbeat', 30),
                 app_name=cls._config.get("APP_NAME", "")
             )
@@ -125,19 +133,133 @@ class RabbitMQService:
             logger.error(f"RabbitMQ连接池初始化失败: {str(e)}", exc_info=True)
             # 连接池初始化失败时重试（未关闭状态下）
             if not cls._is_shutdown:
-                await asyncio.sleep(3)
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)
                 asyncio.create_task(cls._init_connection_pool())
 
+    @classmethod
+    async def _monitor_connections(cls):
+        """连接监控任务：定期检查所有客户端连接状态，自动重连"""
+        logger.info("RabbitMQ连接监控任务启动")
+        while not cls._is_shutdown:
+            try:
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)  # 固定15秒间隔
+
+                # 跳过未初始化的连接池
+                if not cls._connection_pool or not cls._connection_pool._initialized:
+                    continue
+
+                # 检查所有客户端连接
+                # 使用list避免迭代中修改
+                for client_name, client in list(cls._clients.items()):
+                    try:
+                        # 双重校验连接状态（客户端内部校验 + 连接池连接校验）
+                        client_connected = await client.is_connected
+                        conn_connected = not (
+                            client._channel_conn and client._channel_conn.is_closed)
+
+                        if not client_connected or not conn_connected:
+                            logger.warning(
+                                f"客户端 '{client_name}' 连接异常 - 客户端状态: {client_connected}, "
+                                f"连接状态: {conn_connected}，触发自动重连"
+                            )
+
+                            # 重连前先清理无效资源
+                            await cls._clean_client_resources(client)
+
+                            # 执行重连（带重试）
+                            reconnect_success = await cls._reconnect_client(client_name, client)
+                            if reconnect_success:
+                                logger.info(f"客户端 '{client_name}' 重连成功")
+                            else:
+                                logger.error(f"客户端 '{client_name}' 重连失败，将继续监控")
+
+                    except Exception as e:
+                        logger.error(
+                            f"监控客户端 '{client_name}' 连接状态失败: {str(e)}", exc_info=True)
+
+                # 检查连接池状态（如果连接池已关闭，重新初始化）
+                if not cls._connection_pool.is_alive:
+                    logger.error("RabbitMQ连接池已关闭，尝试重新初始化")
+                    asyncio.create_task(cls._init_connection_pool())
+
+            except Exception as e:
+                logger.error("RabbitMQ连接监控任务异常", exc_info=True)
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)  # 异常后延迟重启监控
+
+        logger.info("RabbitMQ连接监控任务停止")
+
+    @classmethod
+    async def _clean_client_resources(cls, client: RabbitMQClient):
+        """清理客户端无效资源（通道+连接）"""
+        try:
+            if client._channel and client._channel_conn:
+                # 先停止消费（避免消费中释放资源）
+                if client._consumer_tag:
+                    await client.stop_consuming()
+                # 释放通道到连接池
+                await cls._connection_pool.release_channel(client._channel, client._channel_conn)
+                logger.debug("客户端无效资源释放成功")
+        except Exception as e:
+            logger.warning(f"释放客户端无效资源失败: {str(e)}")
+        finally:
+            # 强制重置客户端状态
+            client._channel = None
+            client._channel_conn = None
+            client._exchange = None
+            client._queue = None
+            client._consumer_tag = None
+
+    @classmethod
+    async def _reconnect_client(cls, client_name: str, client: RabbitMQClient) -> bool:
+        """客户端重连（带重试机制）"""
+        # 重连冷却，避免任务堆积
+        cooldown = cls.RECONNECT_INTERVAL * 2
+        await asyncio.sleep(cooldown)
+
+        for attempt in range(cls.MAX_RECONNECT_ATTEMPTS):
+            try:
+                # 执行重连
+                await client.connect()
+
+                # 验证重连结果（双重校验）
+                if await client.is_connected and client._queue:
+                    # 如果是消费者，重新启动消费
+                    if client_name in cls._message_handlers:
+                        # 先停止旧的消费任务
+                        if client_name in cls._consumer_tasks:
+                            old_task = cls._consumer_tasks[client_name]
+                            if not old_task.done():
+                                old_task.cancel()
+                                try:
+                                    await asyncio.wait_for(old_task, timeout=5)
+                                except:
+                                    pass
+                        # 启动新的消费任务
+                        await cls.start_consumer(client_name)
+                    return True
+                else:
+                    logger.warning(
+                        f"客户端 '{client_name}' 重连尝试 {attempt+1} 失败：资源未完全初始化")
+            except Exception as e:
+                logger.error(
+                    f"客户端 '{client_name}' 重连尝试 {attempt+1} 失败: {str(e)}", exc_info=True)
+
+            await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+        if not cls._is_shutdown:
+            asyncio.create_task(cls._reconnect_client(client_name, client))
+        return False
+
     @classmethod
     async def _create_client(cls, queue_name: str, **kwargs) -> RabbitMQClient:
         """创建客户端实例（适配新的RabbitMQClient API）"""
         if cls._is_shutdown:
             raise RuntimeError("RabbitMQService已关闭，无法创建客户端")
 
-        if not cls._connection_pool:
+        if not cls._connection_pool or not cls._connection_pool._initialized:
             # 等待连接池初始化
             start_time = asyncio.get_event_loop().time()
-            while not cls._connection_pool and not cls._is_shutdown:
+            while not (cls._connection_pool and cls._connection_pool._initialized) and not cls._is_shutdown:
                 if asyncio.get_event_loop().time() - start_time > 30:
                     raise TimeoutError("等待连接池初始化超时")
                 await asyncio.sleep(1)
@@ -146,8 +268,6 @@ class RabbitMQService:
 
         app_name = kwargs.get('app_name', cls._config.get(
             "APP_NAME", "")) if cls._config else ""
-
-        # 确定是否为发送器
         is_sender = not cls._has_listeners
 
         # 根据组件类型决定是否允许创建队列
@@ -183,7 +303,7 @@ class RabbitMQService:
             prefetch_count=kwargs.get('prefetch_count', 2),
         )
 
-        # 新客户端connect无declare_queue参数，自动根据create_if_not_exists处理
+        # 连接客户端
         await client.connect()
 
         # 监听器客户端连接后延迟1秒，确保消费状态就绪（仅首次启动）
@@ -197,12 +317,9 @@ class RabbitMQService:
     @classmethod
     async def get_client(
         cls,
-        client_name: str = "default", ** kwargs
+        client_name: str = "default", **kwargs
     ) -> RabbitMQClient:
-        """
-        获取或创建RabbitMQ客户端（基于连接池，线程安全）
-        适配新的RabbitMQClient异步状态检查
-        """
+        """获取或创建RabbitMQ客户端（基于连接池，线程安全）"""
         if cls._is_shutdown:
             raise RuntimeError("RabbitMQService已关闭，无法获取客户端")
 
@@ -210,9 +327,9 @@ class RabbitMQService:
             raise ValueError("RabbitMQService尚未初始化，请先调用init方法")
 
         # 等待连接池就绪
-        if not cls._connection_pool:
+        if not cls._connection_pool or not cls._connection_pool._initialized:
             start_time = asyncio.get_event_loop().time()
-            while not cls._connection_pool and not cls._is_shutdown:
+            while not (cls._connection_pool and cls._connection_pool._initialized) and not cls._is_shutdown:
                 if asyncio.get_event_loop().time() - start_time > 30:
                     raise TimeoutError("等待连接池初始化超时")
                 await asyncio.sleep(1)
@@ -230,10 +347,9 @@ class RabbitMQService:
                 is_sender = not cls._has_listeners or (
                     not kwargs.get('create_if_not_exists', True))
 
-                # 异步检查连接状态（适配新客户端的async属性）
                 if await client.is_connected:
                     # 如果是监听器但队列未初始化，重新连接
-                    if not is_sender and not client._queue:  # 直接访问 _queue 属性
+                    if not is_sender and not client._queue:
                         logger.info(f"客户端 '{client_name}' 队列未初始化，重新连接")
                         client.create_if_not_exists = True
                         await client.connect()
@@ -258,7 +374,6 @@ class RabbitMQService:
                     app_name=cls._config.get("APP_NAME", ""),
                     **kwargs
                 )
-                await client.connect()
                 cls._clients[client_name] = client
                 return client
 
@@ -268,10 +383,7 @@ class RabbitMQService:
             # 检查队列是否已初始化
             if initial_queue_name in cls._initialized_queues:
                 logger.info(f"队列 '{initial_queue_name}' 已初始化，直接创建客户端")
-                client = await cls._create_client(
-                    initial_queue_name, ** kwargs
-                )
-                await client.connect()
+                client = await cls._create_client(initial_queue_name, **kwargs)
                 cls._clients[client_name] = client
                 return client
 
@@ -282,10 +394,7 @@ class RabbitMQService:
                 **kwargs
             )
 
-            client.create_if_not_exists = True
-            await client.connect()
-
-            # 验证队列是否创建成功（直接访问 _queue 属性）
+            # 验证队列是否创建成功
             if not client._queue:
                 logger.error(f"队列 '{initial_queue_name}' 创建失败，尝试重新创建")
                 client.create_if_not_exists = True
@@ -302,7 +411,7 @@ class RabbitMQService:
             return client
 
     @classmethod
-    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False, ** kwargs) -> None:
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False, **kwargs) -> None:
         """设置消息发送器（适配新客户端）"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法设置发送器")
@@ -348,7 +457,7 @@ class RabbitMQService:
                         queue_name=queue_name,
                         create_if_not_exists=False,
                         prefetch_count=prefetch_count,
-                        ** kwargs
+                        **kwargs
                     )
 
                 # 记录客户端
@@ -367,7 +476,7 @@ class RabbitMQService:
         logger.info(f"消息发送器设置完成，共 {len(cls._sender_client_names)} 个发送器")
 
     @classmethod
-    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False, ** kwargs) -> None:
+    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False, **kwargs) -> None:
         """设置消息监听器（适配新客户端）"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法设置监听器")
@@ -403,7 +512,7 @@ class RabbitMQService:
 
     @classmethod
     async def _verify_consumers_started(cls, timeout: int = 30) -> None:
-        """验证消费者是否成功启动（适配新客户端的消费者标签管理）"""
+        """验证消费者是否成功启动"""
         start_time = asyncio.get_event_loop().time()
         required_clients = list(cls._message_handlers.keys())
         running_clients = []
@@ -433,7 +542,7 @@ class RabbitMQService:
     async def add_listener(
         cls,
         queue_name: str,
-        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]], ** kwargs
+        handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]], **kwargs
     ) -> None:
         """添加消息监听器（线程安全）"""
         if cls._is_shutdown:
@@ -470,14 +579,24 @@ class RabbitMQService:
 
     @classmethod
     async def start_consumer(cls, client_name: str) -> None:
-        """启动指定客户端的消费者（适配新客户端的消费API）"""
+        """启动指定客户端的消费者"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法启动消费者")
             return
 
-        if client_name in cls._consumer_tasks and not cls._consumer_tasks[client_name].done():
-            logger.info(f"消费者 '{client_name}' 已在运行中，无需重复启动")
-            return
+        # 检查任务状态，避免重复创建
+        if client_name in cls._consumer_tasks:
+            existing_task = cls._consumer_tasks[client_name]
+            if not existing_task.done():
+                # 检查任务是否处于异常状态，仅在异常时重启
+                if existing_task.exception() is not None:
+                    logger.info(f"消费者 '{client_name}' 任务异常，重启")
+                    existing_task.cancel()
+                else:
+                    logger.info(f"消费者 '{client_name}' 已在运行中，无需重复启动")
+                    return
+            else:
+                logger.info(f"消费者 '{client_name}' 任务已完成，重新启动")
 
         if client_name not in cls._clients:
             raise ValueError(f"RabbitMQ客户端 '{client_name}' 未初始化")
@@ -489,10 +608,10 @@ class RabbitMQService:
             logger.warning(f"未找到客户端 '{client_name}' 的处理器，使用默认处理器")
             handler = cls.default_message_handler
 
-        # 设置消息处理器（适配新客户端的async方法）
+        # 设置消息处理器
         await client.set_message_handler(handler)
 
-        # 确保客户端已连接（异步检查连接状态）
+        # 确保客户端已连接
         start_time = asyncio.get_event_loop().time()
         while not await client.is_connected and not cls._is_shutdown:
             if asyncio.get_event_loop().time() - start_time > cls.CONSUMER_START_TIMEOUT:
@@ -501,12 +620,11 @@ class RabbitMQService:
             logger.info(f"等待客户端 '{client_name}' 连接就绪...")
             await asyncio.sleep(1)
         if cls._is_shutdown:
-            logger.info("服务关闭中，取消启动消费者")
             return
 
-        # 监听器启动消费前额外延迟1秒，确保consumer_tag完全生成（不删消息）
+        # 监听器启动消费前额外延迟1秒
         if cls._has_listeners and not client_name.startswith("sender-"):
-            logger.info(f"消费者 '{client_name}' 准备启动，延迟1秒等待消费状态就绪（不删除积压消息）")
+            logger.info(f"消费者 '{client_name}' 准备启动，延迟1秒等待消费状态就绪")
             await asyncio.sleep(1)
 
         # 创建停止事件
@@ -528,11 +646,9 @@ class RabbitMQService:
                             logger.info(f"消费者 '{client_name}' 连接断开，尝试重连")
                             await client.connect()
 
-                        # 确保队列已就绪（直接访问 _queue 属性）
+                        # 确保队列和处理器已就绪
                         if not client._queue:
                             raise Exception("队列未初始化完成")
-
-                        # 确保消息处理器已设置
                         if not client._message_handler:
                             raise Exception("消息处理器未设置")
 
@@ -544,10 +660,9 @@ class RabbitMQService:
                         logger.warning(
                             f"启动消费者尝试 {attempt}/{max_attempts} 失败: {str(e)}")
                         if attempt < max_attempts:
-                            await asyncio.sleep(2)  # 延长重试间隔
+                            await asyncio.sleep(2)
 
                 if cls._is_shutdown:
-                    logger.info("服务关闭中，消费者启动中止")
                     return
 
                 if not consumer_tag:
@@ -556,7 +671,7 @@ class RabbitMQService:
                 # 记录消费者标签
                 cls._consumer_tags[client_name] = consumer_tag
                 logger.info(
-                    f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}（将处理队列中所有积压消息）")
+                    f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}")
 
                 # 等待停止事件
                 await stop_event.wait()
@@ -570,8 +685,7 @@ class RabbitMQService:
                 # 非主动停止时尝试重启
                 if not stop_event.is_set() and not cls._is_shutdown:
                     logger.info(f"尝试重启消费者 '{client_name}'")
-                    # 延迟重启，避免频繁重试
-                    await asyncio.sleep(3)
+                    await asyncio.sleep(cls.RECONNECT_INTERVAL)
                     asyncio.create_task(cls.start_consumer(client_name))
             finally:
                 # 清理资源
@@ -580,7 +694,7 @@ class RabbitMQService:
                 except Exception as e:
                     logger.error(f"停止消费者 '{client_name}' 时出错: {str(e)}")
 
-                # 移除状态记录（线程安全）
+                # 移除状态记录
                 if client_name in cls._consumer_tags:
                     del cls._consumer_tags[client_name]
                 if client_name in cls._consumer_events:
@@ -600,7 +714,6 @@ class RabbitMQService:
                     t.result()
             except Exception as e:
                 logger.error(f"消费者任务 '{client_name}' 异常结束: {str(e)}")
-                # 任务异常时自动重启（如果服务未关闭）
                 if client_name in cls._message_handlers and not cls._is_shutdown:
                     asyncio.create_task(cls.start_consumer(client_name))
 
@@ -618,7 +731,7 @@ class RabbitMQService:
 
     @classmethod
     async def get_sender(cls, queue_name: str) -> Optional[RabbitMQClient]:
-        """获取发送客户端（异步检查连接状态）"""
+        """获取发送客户端"""
         if cls._is_shutdown:
             logger.warning("服务已关闭，无法获取发送器")
             return None
@@ -630,7 +743,6 @@ class RabbitMQService:
         # 检查是否在已注册的发送器中
         if queue_name in cls._sender_client_names and queue_name in cls._clients:
             client = cls._clients[queue_name]
-            # 异步检查连接状态
             if await client.is_connected:
                 return client
             else:
@@ -667,13 +779,13 @@ class RabbitMQService:
     async def send_message(
         cls,
         data: Union[BaseModel, str, Dict[str, Any], None],
-        queue_name: str, ** kwargs
+        queue_name: str, **kwargs
     ) -> None:
-        """发送消息到指定队列（适配新客户端的publish API）"""
+        """发送消息到指定队列"""
         if cls._is_shutdown:
             raise RuntimeError("RabbitMQService已关闭，无法发送消息")
 
-        # 获取发送客户端（异步方法）
+        # 获取发送客户端
         sender = await cls.get_sender(queue_name)
         if not sender:
             error_msg = f"未找到可用的RabbitMQ发送器 (queue_name: {queue_name})"
@@ -683,28 +795,24 @@ class RabbitMQService:
         # 确保连接有效
         if not await sender.is_connected:
             logger.info(f"发送器 '{queue_name}' 连接已关闭，尝试重新连接")
-            max_retry = 3  # 最大重试次数
+            max_retry = 3
             retry_count = 0
             last_exception = None
 
             while retry_count < max_retry and not cls._is_shutdown:
                 try:
-                    # 尝试重连，每次重试间隔1秒
                     await sender.connect()
                     if await sender.is_connected:
                         logger.info(
                             f"发送器 '{queue_name}' 第 {retry_count + 1} 次重连成功")
-                        break  # 重连成功则退出循环
+                        break
                 except Exception as e:
                     last_exception = e
                     retry_count += 1
                     logger.warning(
-                        f"发送器 '{queue_name}' 第 {retry_count} 次重连失败: {str(e)}"
-                    )
-                    if retry_count < max_retry:
-                        await asyncio.sleep(1)  # 重试前等待1秒
+                        f"发送器 '{queue_name}' 第 {retry_count} 次重连失败: {str(e)}")
+                    await asyncio.sleep(cls.RECONNECT_INTERVAL)
 
-            # 所有重试都失败则抛出异常
             if retry_count >= max_retry and not await sender.is_connected:
                 error_msg = f"发送器 '{queue_name}' 经过 {max_retry} 次重连仍失败"
                 logger.error(f"{error_msg}: {str(last_exception)}")
@@ -745,7 +853,7 @@ class RabbitMQService:
                 ).model_dump_json()
             }
 
-            # 发送消息（适配新客户端的publish方法）
+            # 发送消息
             await sender.publish(
                 message_body=mq_message.model_dump_json(),
                 headers=mq_header,
@@ -758,7 +866,7 @@ class RabbitMQService:
 
     @classmethod
     async def shutdown(cls, timeout: float = 15.0) -> None:
-        """优雅关闭所有资源（线程安全，适配新客户端的close API）"""
+        """优雅关闭所有资源（线程安全）"""
         async with cls._shutdown_lock:
             if cls._is_shutdown:
                 logger.info("RabbitMQService已关闭，无需重复操作")
@@ -767,7 +875,17 @@ class RabbitMQService:
             cls._is_shutdown = True
             logger.info("开始关闭RabbitMQ服务...")
 
-            # 1. 停止所有消费者任务
+            # 1. 停止连接监控任务
+            if cls._connection_monitor_task and not cls._connection_monitor_task.done():
+                cls._connection_monitor_task.cancel()
+                try:
+                    await asyncio.wait_for(cls._connection_monitor_task, timeout=timeout)
+                except asyncio.TimeoutError:
+                    logger.warning("连接监控任务关闭超时")
+                except Exception as e:
+                    logger.error(f"关闭连接监控任务失败: {str(e)}")
+
+            # 2. 停止所有消费者任务
             for client_name, task in cls._consumer_tasks.items():
                 if not task.done():
                     # 触发停止事件
@@ -776,28 +894,26 @@ class RabbitMQService:
                     # 取消任务
                     task.cancel()
                     try:
-                        await asyncio.wait_for(task, timeout=5.0)
-                    except asyncio.TimeoutError:
-                        logger.warning(f"消费者 '{client_name}' 关闭超时")
+                        await asyncio.wait_for(task, timeout=timeout)
                     except Exception as e:
                         logger.error(f"关闭消费者 '{client_name}' 失败: {str(e)}")
 
-            # 2. 关闭所有客户端
+            # 3. 关闭所有客户端
             for client in cls._clients.values():
                 try:
                     await client.close()
                 except Exception as e:
                     logger.error(f"关闭客户端失败: {str(e)}")
 
-            # 3. 关闭连接池
-            if cls._connection_pool:
+            # 4. 关闭连接池
+            if cls._connection_pool and cls._connection_pool._initialized:
                 try:
                     await cls._connection_pool.close()
                     logger.info("RabbitMQ连接池已关闭")
                 except Exception as e:
                     logger.error(f"关闭连接池失败: {str(e)}")
 
-            # 4. 清理状态
+            # 5. 清理状态
             cls._clients.clear()
             cls._message_handlers.clear()
             cls._consumer_tasks.clear()

{sycommon_python_lib-0.1.41 → sycommon_python_lib-0.1.43}/src/sycommon_python_lib.egg-info/PKG-INFO

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