sycommon-python-lib 0.2.0b2__tar.gz → 0.2.0b4__tar.gz

{sycommon_python_lib-0.2.0b2 → sycommon_python_lib-0.2.0b4}/PKG-INFO

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

{sycommon_python_lib-0.2.0b2 → sycommon_python_lib-0.2.0b4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.0b2"
+version = "0.2.0b4"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.0b2 → sycommon_python_lib-0.2.0b4}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -1,4 +1,5 @@
 import asyncio
+import functools
 import json
 from typing import Optional, Callable, Coroutine, Dict, Any, Union
 from aio_pika import Channel, Message, DeliveryMode, ExchangeType
@@ -67,6 +68,7 @@ class RabbitMQClient:
         # 并发控制
         self._consume_lock = asyncio.Lock()
         self._connect_lock = asyncio.Lock()
+        self._reconnect_lock = asyncio.Lock()
 
         # 防止并发重连覆盖
         self._connecting = False
@@ -78,34 +80,46 @@ class RabbitMQClient:
         self._RECONNECT_INTERVAL = 15
 
     @property
-    async def is_connected(self) -> bool:
+    def is_connected(self) -> bool:
+        """
+        同步检查连接状态
+        【修复】改为同步属性，避免异步调用错误和布尔上下文误判
+        """
         if self._closed:
             return False
         try:
+            # 检查通道是否有效
+            if not self._channel or self._channel.is_closed:
+                return False
+
+            # 检查连接是否有效
+            if self._channel_conn and self._channel_conn.is_closed:
+                return False
+
             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
+                self._exchange is not None
                 and (not self.queue_name or self._queue is not None)
             )
         except Exception:
             return False
 
     async def _rebuild_resources(self) -> None:
+        """重建 Exchange 和 Queue 资源"""
         if not self._channel or self._channel.is_closed:
             raise RuntimeError("无有效通道，无法重建资源")
 
-        # 声明交换机
-        self._exchange = await self._channel.declare_exchange(
+        # 1. 无条件声明交换机
+        exchange_inst = await self._channel.declare_exchange(
             name=self.exchange_name,
             type=self.exchange_type,
             durable=self.durable,
             auto_delete=self.auto_delete,
             passive=not self.create_if_not_exists,
         )
+        self._exchange = exchange_inst
         logger.info(f"交换机重建成功: {self.exchange_name}")
 
-        # 声明队列
+        # 2. 仅在有队列名且符合条件时声明队列
         if self.queue_name and self.queue_name.endswith(f".{self.app_name}"):
             self._queue = await self._channel.declare_queue(
                 name=self.queue_name,
@@ -113,61 +127,76 @@ 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)
+            await self._queue.bind(exchange=exchange_inst, routing_key=self.routing_key)
             logger.info(f"队列重建成功: {self.queue_name}")
 
+    async def _ensure_connection_alive(self) -> AbstractRobustConnection:
+        """
+        【新增安全辅助方法】
+        动态获取当前有效的连接对象，避免引用池中已过期的连接。
+        如果连接无效，会抛出异常，交由上层逻辑处理重连。
+        """
+        if not self.connection_pool or not self.connection_pool._initialized:
+            raise RuntimeError("连接池未初始化")
+
+        conn = self.connection_pool._connection
+        if not conn or conn.is_closed:
+            raise RuntimeError("连接池底层连接已关闭")
+        return conn
+
     async def connect(self) -> None:
-        """连接方法（消费者独立通道 + 移除无效属性检查 + 强制重建队列）"""
+        """连接方法（终极防御版：防并发风暴、防死锁、防资源泄漏）"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
-        # 1. 获取 Condition 锁，用于管理连接并发和等待
-        await self._connect_condition.acquire()
-
-        try:
-            # ===== 阶段 A: 检查状态与排队 =====
-            if await self.is_connected:
-                if self._connect_condition.locked():
-                    self._connect_condition.release()
-                return
-
-            # 如果已有协程正在连接，等待其完成
-            if self._connecting:
-                try:
-                    logger.debug("连接正在进行中，等待现有连接完成...")
-                    await asyncio.wait_for(self._connect_condition.wait(), timeout=60.0)
-                except asyncio.TimeoutError:
-                    logger.warning("等待前序连接超时，当前协程将尝试强制接管并重连...")
-
-                # 唤醒后再次检查状态，防止重复连接
-                if await self.is_connected:
+        # === 阶段 A: 并发控制循环 ===
+        while True:
+            await self._connect_condition.acquire()
+            try:
+                # 1. 检查是否已连接
+                if self.is_connected:
                     if self._connect_condition.locked():
                         self._connect_condition.release()
                     return
 
-            # ===== 阶段 B: 标记开始连接并释放锁 =====
-            # 释放锁是为了让耗时的连接过程不阻塞其他协程
-            self._connecting = True
-            self._connect_condition.release()
+                # 2. 检查是否已有协程在连接
+                if self._connecting:
+                    try:
+                        logger.debug("连接正在进行中，等待现有连接完成...")
+                        # 等待其他协程完成
+                        await asyncio.wait_for(self._connect_condition.wait(), timeout=60.0)
+                    except asyncio.TimeoutError:
+                        logger.warning("⚠️ 等待前序连接超时，重新竞争连接权...")
+
+                    # 【核心修复】
+                    # 无论是因为超时还是被唤醒，都 continue 重新循环
+                    # 这样确保不会出现“所有协程同时醒来”的羊群效应
+                    # 只有抢到锁的那个协程会进入连接逻辑，其他继续 wait
+                    if self._connect_condition.locked():
+                        self._connect_condition.release()
+                    continue
 
-        except Exception as e:
-            if self._connect_condition.locked():
+                # 3. 抢到连接权，标记开始
+                self._connecting = True
                 self._connect_condition.release()
-            raise
+                break  # <--- 跳出循环，去执行连接逻辑
+
+            except Exception as e:
+                if self._connect_condition.locked():
+                    self._connect_condition.release()
+                raise
 
         # === 阶段 C: 执行耗时的连接逻辑 (无锁状态) ===
         connection_failed = False
         was_consuming = False
-
-        # 判断当前是否为消费者模式（通过是否有消息处理函数判断）
         is_consumer = self._message_handler is not None
         old_channel = self._channel
 
         try:
-            # --- 步骤 1: 记录状态并清理旧资源 ---
+            # --- 步骤 1: 清理旧资源 ---
             was_consuming = self._consumer_tag is not None
 
-            # 清理旧连接的 close_callbacks，防止重连触发多次
+            # 清理旧连接的回调
             if self._channel_conn:
                 try:
                     if self._channel_conn.close_callbacks:
@@ -175,56 +204,57 @@ class RabbitMQClient:
                 except Exception:
                     pass
 
-            # 显式关闭旧 Channel
-            # 注意：无论是生产者复用的主通道，还是消费者的独立通道，断开时都应显式关闭以释放服务端资源
             if old_channel and not old_channel.is_closed:
                 try:
                     await old_channel.close()
                 except Exception:
                     pass
 
-            # 【修复点】强制重置所有核心资源引用
-            # 因为我们即将获取一个新的 Channel，旧的 Exchange 和 Queue 对象（基于旧 Channel）将全部失效。
-            # 必须置为 None，强制后续逻辑基于新 Channel 重建这些对象。
+            # 强制重置
             self._channel = None
             self._channel_conn = None
             self._exchange = None
             self._queue = None
             self._consumer_tag = None
 
-            # --- 步骤 2: 根据角色获取新连接 ---
-            # 生产者：复用连接池的主通道（性能高）
-            # 消费者：从连接池获取独立的通道（稳定性高，避免并发冲突）
+            # --- 步骤 2: 获取新通道 ---
             if is_consumer:
                 logger.debug("获取消费者独立通道...")
                 self._channel = await self.connection_pool.acquire_consumer_channel()
-                self._channel_conn = self.connection_pool._connection
             else:
                 logger.debug("获取生产者主通道...")
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
-            # --- 步骤 3: 设置连接关闭回调 ---
+            # --- 步骤 3: 统一获取并注册连接回调 ---
+            if not self._channel_conn:
+                # 消费者路径需要手动获取连接引用
+                # 直接引用连接池的连接对象，确保引用时效性
+                self._channel_conn = self.connection_pool._connection
+
             loop = asyncio.get_running_loop()
 
             def on_conn_closed(conn, exc):
-                if self._closed:
-                    return
-                logger.warning(f"检测到底层连接关闭: {exc}")
-                # 确保在循环中安全调用协程
-                asyncio.run_coroutine_threadsafe(self._safe_reconnect(), loop)
+                # 【核心修复】不再判断 _connecting，直接委托给 _safe_reconnect
+                # _safe_reconnect 内部有锁，会自动处理并发问题
+                if not self._closed:
+                    logger.warning(f"⚠️ 检测到底层连接关闭: {exc}")
+                    asyncio.run_coroutine_threadsafe(
+                        self._safe_reconnect(), loop)
+
+            # 注册回调前，再次防御性清理
+            if self._channel_conn.close_callbacks:
+                self._channel_conn.close_callbacks.clear()
 
-            if self._channel_conn:
-                self._channel_conn.close_callbacks.add(on_conn_closed)
+            self._channel_conn.close_callbacks.add(on_conn_closed)
 
             # --- 步骤 4: 重建基础资源 ---
-            # 这会在新的 self._channel 上声明 Exchange 和 Queue，并执行绑定
             await self._rebuild_resources()
 
         except Exception as e:
             connection_failed = True
-            logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
+            logger.error(f"❌ 客户端连接失败: {str(e)}", exc_info=True)
 
-            # 发生异常时清理引用
+            # 异常时清理
             if self._channel_conn and self._channel_conn.close_callbacks:
                 self._channel_conn.close_callbacks.clear()
 
@@ -233,31 +263,25 @@ class RabbitMQClient:
             self._exchange = None
             self._queue = None
             self._consumer_tag = None
-
             raise
 
         finally:
-            # === 阶段 D: 恢复消费与收尾 (重新加锁) ===
+            # === 阶段 D: 恢复消费与收尾 ===
             try:
                 await self._connect_condition.acquire()
             except Exception:
-                pass
+                # 如果 acquire 本身失败，确保状态复位，防止死锁
+                self._connecting = False
+                self._connect_condition.notify_all()
+                raise
 
             try:
-                # 只有连接完全成功，且之前处于消费状态，才尝试自动恢复消费
                 if not connection_failed and was_consuming and self._message_handler:
                     logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
 
-                    # 【修复核心】
-                    # 由于在步骤 1 中 self._queue 已被置为 None，
-                    # 如果 _rebuild_resources 因为某种原因（例如配置条件）没有成功创建队列，
-                    # 这里需要再次尝试在当前新 Channel 上创建并绑定队列。
-                    # 不再检查 is_closed（因为该属性不存在），直接检查是否为 None。
-
                     if self.queue_name and not self._queue:
                         try:
                             logger.info(f"重连恢复过程中重新声明队列: {self.queue_name}")
-                            # 在当前新 Channel 上声明队列
                             self._queue = await self._channel.declare_queue(
                                 name=self.queue_name,
                                 durable=self.durable,
@@ -265,18 +289,25 @@ class RabbitMQClient:
                                 passive=not self.create_if_not_exists,
                             )
 
-                            # 【关键步骤】显式绑定队列
-                            # 即使队列已存在，也必须在新 Channel 上重新绑定，否则服务端路由状态可能不更新
+                            # 确保绑定
                             if self._exchange:
                                 await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
                                 logger.info(
                                     f"✅ 重连绑定成功: {self.queue_name} -> {self.routing_key}")
+                            else:
+                                # 防御性编程
+                                logger.error(
+                                    "🔥 Exchange missing, forcing declare...")
+                                temp_ex = await self._channel.declare_exchange(
+                                    self.exchange_name, self.exchange_type, durable=self.durable
+                                )
+                                self._exchange = temp_ex
+                                await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+
                         except Exception as bind_err:
                             logger.error(f"❌ 重连恢复队列/绑定失败: {bind_err}")
-                            # 绑定失败，无法恢复消费
                             self._queue = None
 
-                    # 队列对象有效才启动消费
                     if self._queue:
                         try:
                             self._consumer_tag = await self.start_consuming()
@@ -284,41 +315,35 @@ class RabbitMQClient:
                         except Exception as e:
                             logger.error(f"❌ 自动恢复消费失败: {e}")
                             self._consumer_tag = None
-                    else:
-                        logger.warning("⚠️ 队列对象无效，无法恢复消费")
-
             finally:
-                # 最终状态复位
+                # 无论恢复逻辑成功与否，必须解锁
                 self._connecting = False
                 self._connect_condition.notify_all()
-
                 if self._connect_condition.locked():
                     self._connect_condition.release()
 
     async def _safe_reconnect(self):
-        """安全重连任务（仅用于被动监听连接关闭）"""
-        async with self._reconnect_semaphore:
-            if self._closed:
-                return
-
-            # 如果已经在重连，直接忽略
-            if self._connecting:
-                return
-
-            logger.info(f"将在{self._RECONNECT_INTERVAL}秒后尝试重连...")
-            await asyncio.sleep(self._RECONNECT_INTERVAL)
-
-            if self._closed or await self.is_connected:
-                return
+        """
+        安全重连入口
+        【核心修复】使用锁防止并发风暴，确保同一时间只有一个重连任务在执行。
+        """
+        # 如果锁已经被占用，说明已经有重连任务在进行中，直接忽略，防止无限递归
+        if self._reconnect_lock.locked():
+            logger.debug("⏳ 重连任务已在执行中，忽略本次触发，避免并发风暴")
+            return
 
+        async with self._reconnect_lock:
             try:
-                self._current_reconnect_task = asyncio.create_task(
-                    self.connect())
-                await self._current_reconnect_task
+                if self._closed:
+                    logger.info("客户端已手动关闭，取消重连")
+                    return
+
+                logger.warning("🔄 触发底层连接重连...")
+                # 调用实际的 connect 方法
+                await self.connect()
             except Exception as e:
-                logger.warning(f"重连失败: {str(e)}")
-            finally:
-                self._current_reconnect_task = None
+                # 即使重连失败，也不要在这里递归调用自己，而是依赖外部的定时任务或下一次网络事件
+                logger.error(f"❌ 安全重连执行失败: {str(e)}", exc_info=True)
 
     async def set_message_handler(self, handler: Callable[..., Coroutine]) -> None:
         if not asyncio.iscoroutinefunction(handler):
@@ -327,23 +352,42 @@ class RabbitMQClient:
             self._message_handler = handler
 
     async def _process_message_callback(self, message: AbstractIncomingMessage):
+        """
+        消息处理回调
+        """
         try:
+            # === 阶段 1: 消息解析与上下文设置 (在主线程执行) ===
             body_dict = json.loads(message.body.decode("utf-8"))
             msg_obj: MQMsgModel = MQMsgModel(**body_dict)
+
             if not msg_obj.traceId:
                 msg_obj.traceId = message.headers.get(
                     "trace-id") if message.headers else SYLogger.get_trace_id()
 
             SYLogger.set_trace_id(msg_obj.traceId)
 
+            # === 阶段 2: 业务逻辑执行 ===
             if self._message_handler:
-                await self._message_handler(msg_obj, message)
+                def run_job_with_context():
+                    # 【关键修复】在子线程内重新设置 TraceId
+                    SYLogger.set_trace_id(msg_obj.traceId)
 
+                    return asyncio.run(
+                        functools.partial(
+                            self._message_handler, msg_obj, message)()
+                    )
+
+                await asyncio.to_thread(run_job_with_context)
+
+            # === 阶段 3: 消息确认 ===
             await message.ack()
 
         except Exception as e:
-            logger.error(f"消息处理异常: {e}", exc_info=True)
-            await message.ack()
+            logger.error(f"❌ 消息处理异常: {str(e)}", exc_info=True)
+            try:
+                await message.ack()
+            except Exception:
+                pass
 
     async def start_consuming(self) -> Optional[ConsumerTag]:
         if self._closed:
@@ -353,7 +397,7 @@ class RabbitMQClient:
             if not self._message_handler:
                 raise RuntimeError("未设置消息处理器")
 
-            if not await self.is_connected:
+            if not self.is_connected:
                 await self.connect()
 
             if not self._queue:
@@ -431,7 +475,7 @@ class RabbitMQClient:
 
         for retry in range(retry_count):
             try:
-                if not await self.is_connected:
+                if not self.is_connected:
                     await self.connect()
 
                 result = await self._exchange.publish(

{sycommon_python_lib-0.2.0b2 → sycommon_python_lib-0.2.0b4}/src/sycommon/rabbitmq/rabbitmq_pool.py

@@ -23,7 +23,7 @@ class AsyncProperty:
 
 
 class RabbitMQConnectionPool:
-    """单连接单通道RabbitMQ客户端 (严格执行“先清理后连接”策略)"""
+    """单连接单通道RabbitMQ客户端"""
 
     def __init__(
         self,
@@ -73,6 +73,7 @@ class RabbitMQConnectionPool:
                 return False
             if not self._initialized:
                 return False
+            # 修复：简化检查，移除耗时的 connect() 调用，直接检查状态
             if self._connection is None or self._connection.is_closed:
                 return False
             if self._channel is None or self._channel.is_closed:
@@ -112,7 +113,6 @@ class RabbitMQConnectionPool:
         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}")
@@ -121,67 +121,29 @@ class RabbitMQConnectionPool:
 
         logger.info("✅ [CLEANUP] 资源清理完成")
 
-    async def _create_connection_impl(self, host: str) -> AbstractRobustConnection:
-        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"
-        )
-        logger.info(f"🔌 [CONNECT] 尝试连接节点: {host}")
-        try:
-            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] 节点 {host} 连接失败: {str(e)}")
-            raise ConnectionError(f"无法连接RabbitMQ {host}") from e
-
     async def _ensure_main_channel(self) -> RobustChannel:
         """
-        确保主通道有效 (修复：将探活逻辑移入锁内，防止死锁)
+        确保主通道有效 (修复版：移除会导致死锁的代码)
         """
         async with self._lock:  # 持有锁贯穿整个方法
             if self._is_shutdown:
                 raise RuntimeError("客户端已关闭")
 
             # --- 阶段 A: 连接检查与重建 ---
+            # 修复：直接检查 is_closed，不调用 connect(timeout=1) 防止阻塞
             connection_is_dead = False
-            if self._connection is None:
+            if self._connection is None or self._connection.is_closed:
                 connection_is_dead = True
-            else:
-                try:
-                    if self._connection.is_closed:
-                        connection_is_dead = True
-                    else:
-                        # 【修复】显式探活，保持在锁内
-                        # 这样如果探活失败，可以直接在锁内进入重建流程，无需重新竞争锁
-                        try:
-                            await asyncio.wait_for(self._connection.connect(timeout=1), timeout=15)
-                        except Exception:
-                            logger.warning("⚠️ 连接探活失败，判定为死连接，强制重建...")
-                            connection_is_dead = True
-                except Exception:
-                    connection_is_dead = True
 
-            # 如果连接死掉，执行清理和重建
             if connection_is_dead:
                 await self._cleanup_resources()
-                # ... (重建连接逻辑保持不变: 遍历 hosts -> connect_robust -> 赋值 self._connection) ...
-                # 确保重建成功，否则抛出异常
 
-                # 为了代码完整性，这里补全重建逻辑的核心部分（基于你之前的代码）
+                # 重建连接逻辑
                 retry_hosts = self.hosts.copy()
                 random.shuffle(retry_hosts)
                 last_error = None
-                max_attempts = min(len(retry_hosts), 3)
 
-                for _ in range(max_attempts):
-                    if not retry_hosts:
-                        break
-                    host = retry_hosts.pop()
+                for host in retry_hosts:
                     self._current_host = host
                     temp_conn = None
                     try:
@@ -192,8 +154,13 @@ class RabbitMQConnectionPool:
                         )
                         temp_conn = await asyncio.wait_for(
                             connect_robust(conn_url),
-                            timeout=self.connection_timeout + 5
+                            timeout=self.connection_timeout
                         )
+
+                        if self._is_shutdown:
+                            await temp_conn.close()
+                            raise RuntimeError("客户端已关闭")
+
                         self._connection = temp_conn
                         self._initialized = True
                         last_error = None
@@ -211,10 +178,11 @@ class RabbitMQConnectionPool:
                         await asyncio.sleep(self.reconnect_interval)
 
                 if last_error:
-                    raise ConnectionError("所有 RabbitMQ 节点连接失败") from last_error
+                    self._initialized = False
+                    raise ConnectionError(
+                        f"所有 RabbitMQ 节点连接失败: {last_error}") from last_error
 
             # --- 阶段 B: 通道恢复逻辑 ---
-            # 此时 self._connection 必须是有效的
             if self._channel is None or self._channel.is_closed:
                 max_channel_attempts = 2
                 for attempt in range(max_channel_attempts):
@@ -227,18 +195,19 @@ class RabbitMQConnectionPool:
                         logger.warning(
                             f"⚠️ [CHANNEL_RETRY] 第 {attempt + 1} 次尝试创建通道失败: {e}")
                         if attempt < max_channel_attempts - 1:
-                            await self._cleanup_resources()  # 通道失败导致连接可能也坏了，重置
-                            # 简单重试逻辑：这里抛出异常让外层重试，或者在这里递归调用
-                            # 鉴于复杂度，建议抛出异常
-                            raise e
+                            try:
+                                await self._connection.close()
+                            except:
+                                pass
+                            self._connection = None
                         else:
-                            raise e
+                            raise RuntimeError(f"创建通道失败: {e}")
             else:
-                # 通道存在，进行一次轻量级探活 (保持一致性)
+                # 通道存在，进行一次轻量级 QOS 刷新
                 try:
                     await self._channel.set_qos(prefetch_count=self.prefetch_count)
                 except Exception:
-                    logger.warning("⚠️ 通道探活失败，重建通道...")
+                    logger.warning("⚠️ 通道 QOS 刷新失败，重建通道...")
                     self._channel = await self._connection.channel()
                     await self._channel.set_qos(prefetch_count=self.prefetch_count)
 
@@ -246,14 +215,12 @@ class RabbitMQConnectionPool:
 
     async def init_pools(self):
         """初始化入口"""
-        # 快速检查
         if self._initialized:
             return
 
         conn_created_in_this_try = None
 
         try:
-            # 锁外创建连接，减少锁持有时间
             init_host = random.choice(self.hosts)
             conn = await self._create_connection_impl(init_host)
             conn_created_in_this_try = conn
@@ -262,14 +229,12 @@ class RabbitMQConnectionPool:
                 if self._is_shutdown:
                     raise RuntimeError("客户端已关闭")
 
-                # 双重检查：防止在锁外等待时，状态已改变或被其他协程初始化
                 if self._initialized:
                     logger.info("🚀 [INIT_SKIP] 其他协程已完成初始化")
                     if conn_created_in_this_try:
                         await conn_created_in_this_try.close()
                     return
 
-                # 提交新资源
                 self._connection = conn
                 self._channel = await self._connection.channel()
                 await self._channel.set_qos(prefetch_count=self.prefetch_count)
@@ -286,29 +251,38 @@ class RabbitMQConnectionPool:
                 except Exception:
                     pass
             if not self._is_shutdown:
-                await self.close()
+                async with self._lock:
+                    self._initialized = False
             raise
 
+    async def _create_connection_impl(self, host: str) -> AbstractRobustConnection:
+        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"
+        )
+        logger.info(f"🔌 [CONNECT] 尝试连接节点: {host}")
+        try:
+            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] 节点 {host} 连接失败: {str(e)}")
+            raise ConnectionError(f"无法连接RabbitMQ {host}") from e
+
     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] 强制重连成功")
@@ -317,20 +291,13 @@ class RabbitMQConnectionPool:
             raise
 
     async def acquire_consumer_channel(self) -> RobustChannel:
-        """
-        专门为消费者获取独立的通道。
-        遵循 aio_pika 最佳实践：消费者不应与发布者或其他消费者共享同一个 Channel 对象。
-        """
-        # 确保连接池已初始化且连接是活的
+        """获取消费者独立通道"""
         if not self._initialized:
             await self.init_pools()
 
-        # 确保 self._connection 是有效的（复用 _ensure_main_channel 的连接恢复逻辑）
         await self._ensure_main_channel()
 
-        # 基于有效连接创建一个新的独立通道
         try:
-            # 注意：这里直接使用 self._connection，而不是返回缓存的 self._channel
             consumer_ch = await self._connection.channel()
             await consumer_ch.set_qos(prefetch_count=self.prefetch_count)
             logger.debug("✅ [CONSUMER_CH] 消费者独立通道已创建")
@@ -424,11 +391,9 @@ class RabbitMQConnectionPool:
     async def close(self):
         """资源销毁"""
         try:
-            # 设置超时，防止因锁异常导致无法关闭
             await asyncio.wait_for(self._lock.acquire(), timeout=5.0)
         except asyncio.TimeoutError:
             logger.error("⚠️ [CLOSE_TIMEOUT] 获取锁超时，强制标记关闭")
-            # 如果拿不到锁，我们只能标记状态，无法安全清理连接
             self._is_shutdown = True
             self._initialized = False
             return

{sycommon_python_lib-0.2.0b2 → sycommon_python_lib-0.2.0b4}/src/sycommon/rabbitmq/rabbitmq_service_client_manager.py

@@ -29,29 +29,17 @@ class RabbitMQClientManager(RabbitMQCoreService):
     @classmethod
     async def _clean_client_resources(cls, client: RabbitMQClient) -> None:
         """
-        清理客户端无效资源（修正版：只清理消费行为，不关闭 Channel）
-
-        重要变更：
-        - 移除了 await client._channel.close() 调用。
-        - 原因：关闭 Channel 可能会触发底层连接的 close_callback，导致重连死锁或冲突。
-        -       Channel 的关闭应该由 RabbitMQClient.connect() 内部的重建逻辑接管。
+        清理客户端无效资源
         """
         try:
-            # 1. 尝试正常停止消费（发送 basic_cancel）
+            # 1. 停止消费
             if client._consumer_tag:
                 await client.stop_consuming()
         except Exception as e:
             logger.warning(f"停止消费逻辑异常: {str(e)}")
 
-        # 注意：这里不再显式关闭 client._channel
-        # 原因：
-        # 1. 如果是消费者独立通道，关闭它是安全的，但不如交给 connect() 统一处理（重建前关闭）。
-        # 2. 如果是生产者主通道（由 Pool 缓存），绝对不能在这里关闭！否则会影响其他生产者。
-        # 3. connect() 方法已经包含了 "显式关闭旧 Channel" 的逻辑，这里重复操作是多余的且危险的。
-
         try:
-            # 2. 重置客户端状态引用（为后续 connect() 扫清障碍）
-            # 注意：虽然清理了状态，但不要清空 _message_handler！
+            # 2. 重置引用
             client._channel = None
             client._channel_conn = None
             client._exchange = None
@@ -59,6 +47,8 @@ class RabbitMQClientManager(RabbitMQCoreService):
             client._consumer_tag = None
         except Exception as e:
             logger.warning(f"重置客户端状态异常: {str(e)}")
+            # 注意：不要在这里关闭 _channel，交给 client.close() 或者重连逻辑处理
+            # 这里主要确保引用断开，帮助 GC
 
     @classmethod
     async def _reconnect_client(cls, client_name: str, client: RabbitMQClient) -> bool:
@@ -95,7 +85,7 @@ class RabbitMQClientManager(RabbitMQCoreService):
             await client.connect()
 
             # 验证重连结果
-            if await client.is_connected:
+            if client.is_connected:
                 logger.info(f"✅ 客户端 '{client_name}' 重连成功")
                 return True
             else:
@@ -209,7 +199,7 @@ class RabbitMQClientManager(RabbitMQCoreService):
                     if not client.queue_name and kwargs.get("queue_name"):
                         client.queue_name = kwargs.get("queue_name")
 
-                if await client.is_connected:
+                if client.is_connected:
                     return client
                 else:
                     logger.info(f"客户端 '{client_name}' 连接已断开，重新创建")

{sycommon_python_lib-0.2.0b2 → sycommon_python_lib-0.2.0b4}/src/sycommon/rabbitmq/rabbitmq_service_connection_monitor.py

@@ -33,7 +33,7 @@ class RabbitMQConnectionMonitor(RabbitMQClientManager):
                 # 检查所有客户端连接
                 for client_name, client in list(cls._clients.items()):
                     try:
-                        client_connected = await client.is_connected
+                        client_connected = client.is_connected
                         if not client_connected:
                             logger.warning(
                                 f"客户端 '{client_name}' 连接异常，触发重连")

{sycommon_python_lib-0.2.0b2 → sycommon_python_lib-0.2.0b4}/src/sycommon/rabbitmq/rabbitmq_service_consumer_manager.py

@@ -160,7 +160,7 @@ class RabbitMQConsumerManager(RabbitMQClientManager):
 
         # 确保客户端已连接
         start_time = asyncio.get_event_loop().time()
-        while not await client.is_connected and not cls._is_shutdown:
+        while not client.is_connected and not cls._is_shutdown:
             if asyncio.get_event_loop().time() - start_time > cls.CONSUMER_START_TIMEOUT:
                 raise TimeoutError(f"等待客户端 '{client_name}' 连接超时")
 
@@ -184,7 +184,7 @@ class RabbitMQConsumerManager(RabbitMQClientManager):
                 while attempt < max_attempts and not stop_event.is_set() and not cls._is_shutdown:
                     try:
                         # 启动消费前再次校验
-                        if not await client.is_connected:
+                        if not client.is_connected:
                             logger.info(f"消费者 '{client_name}' 连接断开，尝试重连")
                             await client.connect()
 

{sycommon_python_lib-0.2.0b2 → sycommon_python_lib-0.2.0b4}/src/sycommon/rabbitmq/rabbitmq_service_producer_manager.py

@@ -56,7 +56,7 @@ class RabbitMQProducerManager(RabbitMQClientManager):
                 # ===== 处理已有客户端重连 =====
                 if normalized_name in cls._clients:
                     client = cls._clients[normalized_name]
-                    if not await client.is_connected:
+                    if not client.is_connected:
                         client.queue_name = normalized_name
                         client.create_if_not_exists = False
                         await client.connect()
@@ -104,14 +104,14 @@ class RabbitMQProducerManager(RabbitMQClientManager):
         # 检查是否在已注册的发送器中
         if queue_name in cls._sender_client_names and queue_name in cls._clients:
             client = cls._clients[queue_name]
-            if await client.is_connected:
+            if client.is_connected:
                 return client
             else:
                 logger.info(f"发送器 '{queue_name}' 连接已断开，尝试重连")
                 try:
                     client.create_if_not_exists = False
                     await client.connect()
-                    if await client.is_connected:
+                    if client.is_connected:
                         return client
                 except Exception as e:
                     logger.error(f"发送器 '{queue_name}' 重连失败: {str(e)}")
@@ -123,14 +123,14 @@ class RabbitMQProducerManager(RabbitMQClientManager):
             suffixed_name = f"{queue_name}.{app_name}"
             if suffixed_name in cls._sender_client_names and suffixed_name in cls._clients:
                 client = cls._clients[suffixed_name]
-                if await client.is_connected:
+                if client.is_connected:
                     return client
                 else:
                     logger.info(f"发送器 '{suffixed_name}' 连接已断开，尝试重连")
                     try:
                         client.create_if_not_exists = False
                         await client.connect()
-                        if await client.is_connected:
+                        if client.is_connected:
                             return client
                     except Exception as e:
                         logger.error(f"发送器 '{suffixed_name}' 重连失败: {str(e)}")
@@ -156,7 +156,7 @@ class RabbitMQProducerManager(RabbitMQClientManager):
             raise ValueError(error_msg)
 
         # 确保连接有效
-        if not await sender.is_connected:
+        if not sender.is_connected:
             logger.info(f"发送器 '{queue_name}' 连接已关闭，尝试重新连接")
             max_retry = 3
             retry_count = 0
@@ -166,7 +166,7 @@ class RabbitMQProducerManager(RabbitMQClientManager):
                 try:
                     sender.create_if_not_exists = False
                     await sender.connect()
-                    if await sender.is_connected:
+                    if sender.is_connected:
                         logger.info(
                             f"发送器 '{queue_name}' 第 {retry_count + 1} 次重连成功")
                         break
@@ -177,7 +177,7 @@ class RabbitMQProducerManager(RabbitMQClientManager):
                         f"发送器 '{queue_name}' 第 {retry_count} 次重连失败: {str(e)}")
                     await asyncio.sleep(cls.RECONNECT_INTERVAL)
 
-            if retry_count >= max_retry and not await sender.is_connected:
+            if retry_count >= max_retry and not sender.is_connected:
                 error_msg = f"发送器 '{queue_name}' 经过 {max_retry} 次重连仍失败"
                 logger.error(f"{error_msg}: {str(last_exception)}")
                 raise Exception(error_msg) from last_exception

{sycommon_python_lib-0.2.0b2 → sycommon_python_lib-0.2.0b4}/src/sycommon_python_lib.egg-info/PKG-INFO

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