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

sycommon/rabbitmq/rabbitmq_pool.py

@@ -1,7 +1,9 @@
 import asyncio
-from typing import List, Optional, Set, Tuple, cast
-from aio_pika import connect_robust, Channel
-from aio_pika.abc import AbstractRobustConnection, AbstractConnection
+from typing import Optional, List, Set, Iterator, Tuple
+from aio_pika import connect_robust, Channel, Message
+from aio_pika.abc import (
+    AbstractRobustConnection, AbstractQueue, AbstractExchange, AbstractMessage
+)
 
 from sycommon.logging.kafka_log import SYLogger
 
@@ -9,7 +11,7 @@ logger = SYLogger
 
 
 class RabbitMQConnectionPool:
-    """增强版连接池，支持连接自动重建、通道有效性校验"""
+    """单连接RabbitMQ通道池（严格单连接）"""
 
     def __init__(
         self,
@@ -18,349 +20,385 @@ class RabbitMQConnectionPool:
         username: str,
         password: str,
         virtualhost: str = "/",
-        connection_pool_size: int = 2,
-        channel_pool_size: int = 5,
+        channel_pool_size: int = 1,
         heartbeat: int = 30,
         app_name: str = "",
-        reconnect_interval: int = 15,
-        connection_timeout: int = 10,
+        connection_timeout: int = 30,
+        reconnect_interval: int = 30,
+        prefetch_count: int = 2,
     ):
         self.hosts = [host.strip() for host in hosts if host.strip()]
         if not self.hosts:
             raise ValueError("至少需要提供一个RabbitMQ主机地址")
+
+        # 连接配置（所有通道共享此连接的配置）
         self.port = port
         self.username = username
         self.password = password
         self.virtualhost = virtualhost
         self.app_name = app_name or "rabbitmq-client"
         self.heartbeat = heartbeat
-        self.reconnect_interval = reconnect_interval
         self.connection_timeout = connection_timeout
-
-        # 连接池配置
-        self.connection_pool_size = connection_pool_size
+        self.reconnect_interval = reconnect_interval
+        self.prefetch_count = prefetch_count
         self.channel_pool_size = channel_pool_size
 
-        # 实际存储的连接和通道（用元组存储连接+最后活动时间，便于清理超时连接）
-        self._connections: List[Tuple[AbstractRobustConnection, float]] = []
-        self._free_channels: List[Tuple[Channel,
-                                        AbstractRobustConnection]] = []  # 通道绑定所属连接
-        self._used_channels: Set[Tuple[Channel,
-                                       AbstractRobustConnection]] = set()
+        # 节点轮询：仅用于连接失效时切换节点（仍保持单连接）
+        self._host_iterator: Iterator[str] = self._create_host_iterator()
+        self._current_host: Optional[str] = None  # 当前连接的节点
 
-        # 锁用于线程安全
-        self._conn_lock = asyncio.Lock()
-        self._chan_lock = asyncio.Lock()
+        # 核心资源（严格单连接 + 通道池）
+        self._connection: Optional[AbstractRobustConnection] = None  # 唯一连接
+        self._free_channels: List[Channel] = []  # 通道池（仅存储当前连接的通道）
+        self._used_channels: Set[Channel] = set()
 
-        # 连接状态
+        # 状态控制（确保线程安全）
+        self._lock = asyncio.Lock()
         self._initialized = False
-        self._reconnect_task: Optional[asyncio.Task] = None
         self._is_shutdown = False
+        self._reconnecting = False  # 避免重连并发冲突
+
+    def _create_host_iterator(self) -> Iterator[str]:
+        """创建节点轮询迭代器（无限循环，仅用于切换节点）"""
+        while True:
+            for host in self.hosts:
+                yield host
 
     @property
     def is_alive(self) -> bool:
-        if not self._initialized:
+        """检查唯一连接是否存活（使用is_closed判断，兼容所有版本）"""
+        if not self._initialized or not self._connection:
             return False
-        # 异步清理失效连接（不阻塞当前调用）
-        asyncio.create_task(self._check_connections())
-        # 同步校验存活连接（即使清理未完成，也能反映当前状态）
-        return any(not conn.is_closed for conn, _ in self._connections)
+        # 异步清理失效通道（不影响主流程）
+        asyncio.create_task(self._clean_invalid_channels())
+        return not self._connection.is_closed
+
+    async def _safe_close_resources(self):
+        """安全关闭资源：先关通道，再关连接（保证单连接特性）"""
+        async with self._lock:
+            # 1. 关闭所有通道（无论空闲还是使用中）
+            all_channels = self._free_channels + list(self._used_channels)
+            for channel in all_channels:
+                try:
+                    if not channel.is_closed:
+                        await channel.close()
+                except Exception as e:
+                    logger.warning(f"关闭通道失败: {str(e)}")
+            self._free_channels.clear()
+            self._used_channels.clear()
 
-    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]
+            # 2. 关闭唯一连接
+            if self._connection:
+                try:
+                    if not self._connection.is_closed:
+                        await self._connection.close()
+                    logger.info(f"已关闭唯一连接: {self._current_host}:{self.port}")
+                except Exception as e:
+                    logger.warning(f"关闭连接失败: {str(e)}")
+                self._connection = None  # 置空，确保单连接
 
-    async def init_pools(self):
-        """初始化连接池+启动连接监控任务"""
-        if self._initialized:
-            logger.warning("连接池已初始化，无需重复调用")
-            return
+    async def _create_single_connection(self) -> AbstractRobustConnection:
+        """创建唯一连接（失败时轮询节点，切换前关闭旧连接）"""
+        max_attempts = len(self.hosts)  # 每个节点尝试1次
+        attempts = 0
+        last_error: Optional[Exception] = None
 
-        try:
-            # 创建初始连接
-            await self._create_initial_connections()
-            # 启动连接监控任务（后台检查并重建失效连接）
-            self._reconnect_task = asyncio.create_task(
-                self._monitor_connections())
-            self._initialized = True
-            logger.info(
-                f"RabbitMQ连接池初始化成功 - 连接数: {len(self._connections)}, "
-                f"空闲通道数: {len(self._free_channels)}, 集群节点: {self.hosts}"
-            )
-        except Exception as e:
-            logger.error(f"连接池初始化失败: {str(e)}", exc_info=True)
-            await self.close()
-            raise
+        while attempts < max_attempts and not self._is_shutdown:
+            next_host = next(self._host_iterator)
 
-    async def _create_initial_connections(self):
-        """创建初始连接和通道"""
-        for i in range(self.connection_pool_size):
-            try:
-                conn = await self._create_single_connection()
-                self._connections.append(
-                    (conn, asyncio.get_event_loop().time()))
-                # 为每个连接创建初始通道
-                chan_count_per_conn = self.channel_pool_size // self.connection_pool_size
-                for _ in range(chan_count_per_conn):
-                    chan = await conn.channel()
-                    self._free_channels.append((chan, conn))
-            except Exception as e:
-                logger.error(f"创建初始连接/通道失败（第{i+1}个）: {str(e)}", exc_info=True)
-                # 允许部分连接失败，后续监控任务会重试
-                continue
+            # 切换节点前：强制关闭旧连接（保证单连接）
+            if self._connection:
+                await self._safe_close_resources()
 
-    async def _create_single_connection(self) -> AbstractRobustConnection:
-        hosts = self.hosts.copy()
-        retry_count = 0
-        max_retries = 3  # 每个节点最多重试3次
-
-        while retry_count < max_retries and not self._is_shutdown:
-            if not hosts:
-                hosts = self.hosts.copy()
-                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 = (
-                f"amqp://{self.username}:{self.password}@{host}:{self.port}/{self.virtualhost}"
-                f"?heartbeat={self.heartbeat}&timeout={self.connection_timeout}"
-            )
+            self._current_host = next_host
+            conn_url = f"amqp://{self.username}:{self.password}@{self._current_host}:{self.port}/{self.virtualhost}"
 
             try:
+                logger.info(f"尝试创建唯一连接: {self._current_host}:{self.port}")
                 conn = await connect_robust(
                     conn_url,
-                    client_properties={
-                        "connection_name": f"{self.app_name}@{host}"
+                    properties={
+                        "connection_name": f"{self.app_name}_single_conn",
+                        "product": self.app_name
                     },
-                    reconnect_interval=self.reconnect_interval,  # 客户端内置重连间隔也设为15秒
+                    heartbeat=self.heartbeat,
+                    timeout=self.connection_timeout,
+                    reconnect_interval=self.reconnect_interval,
+                    max_reconnect_attempts=None,  # 单节点内部自动重连
                 )
-
-                # 连接关闭回调（固定间隔重连）
-                def on_connection_closed(conn_instance: AbstractConnection, exc: Optional[BaseException]):
-                    logger.warning(
-                        f"RabbitMQ连接关闭: {conn_instance!r}，原因: {exc}", exc_info=exc)
-                    asyncio.create_task(
-                        self._remove_invalid_connection(cast(AbstractRobustConnection, conn_instance)))
-
-                setattr(conn, '_pool_close_callback', on_connection_closed)
-                conn.close_callbacks.add(on_connection_closed)
-
-                logger.info(f"成功连接到RabbitMQ节点: {host}:{self.port}")
+                logger.info(f"唯一连接创建成功: {self._current_host}:{self.port}")
                 return conn
             except Exception as e:
-                logger.warning(
-                    f"连接节点 {host}:{self.port} 失败（重试{retry_count}/{max_retries}）: {str(e)}"
+                attempts += 1
+                last_error = e
+                logger.error(
+                    f"连接节点 {self._current_host}:{self.port} 失败（{attempts}/{max_attempts}）: {str(e)}",
+                    exc_info=True
                 )
-                # 每个节点连接失败后，固定等待15秒再尝试下一个节点
-                await asyncio.sleep(self.reconnect_interval)
+                await asyncio.sleep(30)  # 避免频繁重试
 
-        raise RuntimeError(
-            f"所有RabbitMQ节点连接失败（已重试{max_retries}次），节点列表: {self.hosts}"
-        )
+        raise ConnectionError(
+            f"所有节点创建唯一连接失败（节点列表: {self.hosts}）"
+        ) from last_error
 
-    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 = [
-                (conn, ts) for conn, ts in self._connections if conn != invalid_conn
-            ]
-        # 2. 移除该连接关联的所有通道
-        async with self._chan_lock:
-            self._free_channels = [
-                (chan, conn) for chan, conn in self._free_channels if conn != invalid_conn
-            ]
-            self._used_channels = {
-                (chan, conn) for chan, conn in self._used_channels if conn != invalid_conn
-            }
-        # 3. 触发连接重建
-        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
+    async def _init_channel_pool(self):
+        """初始化通道池（绑定到唯一连接，仅创建指定数量的通道）"""
+        if not self._connection or self._connection.is_closed:
+            raise RuntimeError("无有效连接，无法初始化通道池")
+
+        async with self._lock:
+            self._free_channels.clear()
+            self._used_channels.clear()
 
-            conn = await self._create_single_connection()
-            async with self._conn_lock:
-                self._connections.append(
-                    (conn, asyncio.get_event_loop().time()))
-            # 补充通道
-            chan_count_per_conn = self.channel_pool_size // self.connection_pool_size
-            for _ in range(chan_count_per_conn):
+            # 创建指定数量的通道（池大小由channel_pool_size控制）
+            for i in range(self.channel_pool_size):
                 try:
-                    chan = await conn.channel()
-                    async with self._chan_lock:
-                        self._free_channels.append((chan, conn))
+                    channel = await self._connection.channel()
+                    await channel.set_qos(prefetch_count=self.prefetch_count)
+                    self._free_channels.append(channel)
                 except Exception as e:
-                    logger.warning(f"为新连接创建通道失败: {str(e)}")
+                    logger.error(f"创建通道失败（第{i+1}个）: {str(e)}", exc_info=True)
+                    # 通道创建失败不中断，继续创建剩余通道
+                    continue
+
+            logger.info(
+                f"通道池初始化完成 - 连接: {self._current_host}:{self.port}, "
+                f"可用通道数: {len(self._free_channels)}/{self.channel_pool_size}"
+            )
+
+    async def _reconnect_if_needed(self) -> bool:
+        """连接失效时重连（保证单连接）"""
+        if self._is_shutdown or self._reconnecting:
+            return False
+
+        self._reconnecting = True
+        try:
+            logger.warning("连接失效，开始重连...")
+            # 重新创建唯一连接
+            self._connection = await self._create_single_connection()
+            # 重新初始化通道池
+            await self._init_channel_pool()
+            logger.info("重连成功，通道池已恢复")
+            return True
         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):
-        """后台监控：固定15秒检查一次连接状态"""
-        while self._initialized and not self._is_shutdown:
-            try:
-                await asyncio.sleep(self.reconnect_interval)  # 固定15秒间隔检查
-                current_time = asyncio.get_event_loop().time()
-
-                # 清理失效/超时连接
-                async with self._conn_lock:
-                    valid_connections = []
-                    for conn, last_active in self._connections:
-                        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
-                        else:
-                            valid_connections.append((conn, last_active))
-                    self._connections = valid_connections
-
-                # 补充缺失的连接（不超过连接池最大限制）
-                missing_conn_count = self.connection_pool_size - \
-                    len(self._connections)
-                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)
+            logger.error(f"重连失败: {str(e)}", exc_info=True)
+            self._initialized = False  # 重连失败后标记未初始化
+            return False
+        finally:
+            self._reconnecting = False
 
-    async def acquire_channel(self) -> Tuple[Channel, AbstractRobustConnection]:
-        """获取通道（返回通道+所属连接，便于释放时校验）"""
-        if not self._initialized:
-            raise RuntimeError("连接池未初始化，请先调用 init_pools()")
-
-        async with self._chan_lock:
-            # 优先从空闲通道池获取有效通道
-            for i in range(len(self._free_channels)-1, -1, -1):
-                chan, conn = self._free_channels[i]
-                # 校验通道和连接是否有效
-                if not conn.is_closed and not chan.is_closed:
-                    # 更新连接最后活动时间
-                    async with self._conn_lock:
-                        for j, (c, ts) in enumerate(self._connections):
-                            if c == conn:
-                                self._connections[j] = (
-                                    c, asyncio.get_event_loop().time())
-                                break
-                    # 移到已使用通道集合
-                    self._free_channels.pop(i)
-                    self._used_channels.add((chan, conn))
-                    return chan, conn
-                else:
-                    # 移除无效通道
-                    self._free_channels.pop(i)
-                    logger.warning("清理无效空闲通道")
-
-            # 空闲通道不足，创建新通道
-            if len(self._used_channels) < self.channel_pool_size:
-                # 选择一个有效连接创建通道
-                async with self._conn_lock:
-                    for conn, _ in self._connections:
-                        if not conn.is_closed:
-                            try:
-                                chan = await conn.channel()
-                                self._used_channels.add((chan, conn))
-                                logger.info(
-                                    f"创建新通道，当前通道数: {len(self._used_channels)}/{self.channel_pool_size}")
-                                return chan, conn
-                            except Exception as e:
-                                logger.warning(f"使用连接创建通道失败: {str(e)}")
-                    # 无有效连接，尝试创建新连接
+    async def _clean_invalid_channels(self):
+        """清理失效通道并补充（仅针对当前唯一连接）"""
+        if not self._connection:
+            return
+
+        async with self._lock:
+            # 1. 清理空闲通道中的失效通道
+            valid_free = [
+                chan for chan in self._free_channels if not chan.is_closed]
+            invalid_count = len(self._free_channels) - len(valid_free)
+            if invalid_count > 0:
+                logger.warning(f"清理{invalid_count}个失效空闲通道")
+            self._free_channels = valid_free
+
+            # 2. 清理使用中通道中的失效通道
+            valid_used = {
+                chan for chan in self._used_channels if not chan.is_closed}
+            invalid_used_count = len(self._used_channels) - len(valid_used)
+            if invalid_used_count > 0:
+                logger.warning(f"清理{invalid_used_count}个失效使用中通道")
+            self._used_channels = valid_used
+
+            # 3. 检查连接是否有效，无效则触发重连
+            if self._connection.is_closed:
+                await self._reconnect_if_needed()
+                return
+
+            # 4. 补充通道到指定大小（仅使用当前唯一连接创建）
+            total_valid = len(self._free_channels) + len(self._used_channels)
+            missing = self.channel_pool_size - total_valid
+            if missing > 0:
+                logger.info(f"通道池缺少{missing}个通道，补充中...")
+                for _ in range(missing):
                     try:
-                        conn = await self._create_single_connection()
-                        self._connections.append(
-                            (conn, asyncio.get_event_loop().time()))
-                        chan = await conn.channel()
-                        self._used_channels.add((chan, conn))
-                        return chan, conn
+                        channel = await self._connection.channel()
+                        await channel.set_qos(prefetch_count=self.prefetch_count)
+                        self._free_channels.append(channel)
                     except Exception as e:
-                        logger.error(f"创建新连接+通道失败: {str(e)}", exc_info=True)
-                        raise RuntimeError("无可用连接创建通道")
-            else:
-                raise RuntimeError(f"通道池已达最大限制: {self.channel_pool_size}")
+                        logger.error(f"补充通道失败: {str(e)}", exc_info=True)
+                        break
+
+    async def init_pools(self):
+        """初始化：创建唯一连接 + 初始化通道池（仅执行一次）"""
+        if self._initialized:
+            logger.warning("通道池已初始化，无需重复调用")
+            return
+
+        if self._is_shutdown:
+            raise RuntimeError("通道池已关闭，无法初始化")
+
+        try:
+            # 1. 创建唯一连接
+            self._connection = await self._create_single_connection()
+            # 2. 初始化通道池（绑定到该连接）
+            await self._init_channel_pool()
+            self._initialized = True
+            logger.info("RabbitMQ单连接通道池初始化完成")
+        except Exception as e:
+            logger.error(f"初始化失败: {str(e)}", exc_info=True)
+            await self._safe_close_resources()
+            raise
+
+    async def acquire_channel(self) -> Tuple[Channel, AbstractRobustConnection]:
+        """获取通道（返回元组：(通道, 唯一连接)，兼容上层代码）"""
+        if not self._initialized:
+            raise RuntimeError("通道池未初始化，请先调用init_pools()")
+
+        if self._is_shutdown:
+            raise RuntimeError("通道池已关闭，无法获取通道")
+
+        # 先清理失效通道，确保池内通道有效
+        await self._clean_invalid_channels()
+
+        async with self._lock:
+            # 优先从空闲池获取
+            if self._free_channels:
+                channel = self._free_channels.pop()
+                self._used_channels.add(channel)
+                # 返回（通道, 唯一连接）元组
+                return channel, self._connection
+
+            # 通道池已满，创建临时通道（超出池大小，用完关闭）
+            try:
+                if not self._connection or self._connection.is_closed:
+                    raise RuntimeError("唯一连接已失效，无法创建临时通道")
+
+                channel = await self._connection.channel()
+                await channel.set_qos(prefetch_count=self.prefetch_count)
+                self._used_channels.add(channel)
+                logger.warning(
+                    f"通道池已达上限（{self.channel_pool_size}），创建临时通道（用完自动关闭）"
+                )
+                # 返回（通道, 唯一连接）元组
+                return channel, self._connection
+            except Exception as e:
+                logger.error(f"获取通道失败: {str(e)}", exc_info=True)
+                raise
 
     async def release_channel(self, channel: Channel, conn: AbstractRobustConnection):
-        """释放通道（校验有效性后归还）"""
-        async with self._chan_lock:
-            key = (channel, conn)
-            if key in self._used_channels:
-                self._used_channels.remove(key)
-                # 通道和连接都有效才归还
-                if not conn.is_closed and not channel.is_closed:
-                    self._free_channels.append(key)
-                else:
-                    logger.warning("释放无效通道，已自动丢弃")
+        """释放通道（接收通道和连接参数，兼容上层代码）"""
+        if not channel or not conn or self._is_shutdown:
+            return
 
-    async def close(self):
-        """关闭连接池+监控任务"""
-        self._initialized = False
-        # 停止监控任务
-        if self._reconnect_task and not self._reconnect_task.done():
-            self._reconnect_task.cancel()
+        # 仅处理当前唯一连接的通道（避免无效连接的通道）
+        if conn != self._connection:
             try:
-                await self._reconnect_task
-            except asyncio.CancelledError:
-                pass
+                await channel.close()
+                logger.warning("已关闭非当前连接的通道（可能是重连后的旧通道）")
+            except Exception as e:
+                logger.warning(f"关闭非当前连接通道失败: {str(e)}")
+            return
+
+        async with self._lock:
+            if channel not in self._used_channels:
+                return
 
-        # 释放所有通道
-        async with self._chan_lock:
-            for channel, conn in self._free_channels + list(self._used_channels):
+            self._used_channels.remove(channel)
+
+            # 仅归还：当前连接有效 + 通道未关闭 + 池未满
+            if (not self._connection.is_closed
+                and not channel.is_closed
+                    and len(self._free_channels) < self.channel_pool_size):
+                self._free_channels.append(channel)
+            else:
+                # 无效通道直接关闭
                 try:
-                    if not channel.is_closed:
-                        await channel.close()
+                    await channel.close()
                 except Exception as e:
                     logger.warning(f"关闭通道失败: {str(e)}")
-            self._free_channels.clear()
-            self._used_channels.clear()
 
-        # 关闭所有连接
-        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:
-                    logger.warning(f"关闭连接失败: {str(e)}")
-            self._connections.clear()
+    async def declare_queue(self, queue_name: str, **kwargs) -> AbstractQueue:
+        """声明队列（使用池内通道，共享唯一连接）"""
+        channel, conn = await self.acquire_channel()
+        try:
+            return await channel.declare_queue(queue_name, **kwargs)
+        finally:
+            await self.release_channel(channel, conn)
+
+    async def declare_exchange(self, exchange_name: str, exchange_type: str = "direct", **kwargs) -> AbstractExchange:
+        """声明交换机（使用池内通道，共享唯一连接）"""
+        channel, conn = await self.acquire_channel()
+        try:
+            return await channel.declare_exchange(exchange_name, exchange_type, **kwargs)
+        finally:
+            await self.release_channel(channel, conn)
+
+    async def publish_message(self, routing_key: str, message_body: bytes, exchange_name: str = "", **kwargs):
+        """发布消息（使用池内通道，共享唯一连接）"""
+        channel, conn = 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"消息发布成功 - 节点: {self._current_host}, 交换机: {exchange.name}, 路由键: {routing_key}"
+            )
+        except Exception as e:
+            logger.error(f"发布消息失败: {str(e)}", exc_info=True)
+            raise
+        finally:
+            await self.release_channel(channel, conn)
+
+    async def consume_queue(self, queue_name: str, callback, auto_ack: bool = False, **kwargs):
+        """消费队列（使用池内通道，共享唯一连接）"""
+        if not self._initialized:
+            raise RuntimeError("通道池未初始化，请先调用init_pools()")
+
+        queue = await self.declare_queue(queue_name, **kwargs)
+        current_channel, current_conn = await self.acquire_channel()  # 元组解包
+
+        async def consume_callback_wrapper(message: AbstractMessage):
+            """消费回调包装（处理通道失效重连）"""
+            nonlocal current_channel, current_conn
+            try:
+                # 检查通道是否有效（连接可能已切换）
+                if (current_channel.is_closed
+                    or current_conn.is_closed
+                        or current_conn != self._connection):
+                    logger.warning("消费通道失效，重新获取通道...")
+                    await self.release_channel(current_channel, current_conn)
+                    current_channel, current_conn = await self.acquire_channel()
+                    return
+
+                await callback(message)
+                if not auto_ack:
+                    await message.ack()
+            except Exception as e:
+                logger.error(f"消费消息失败: {str(e)}", exc_info=True)
+                if not auto_ack:
+                    await message.nack(requeue=True)
+
+        logger.info(f"开始消费队列: {queue_name}（连接节点: {self._current_host}）")
+        try:
+            async with queue.iterator() as queue_iter:
+                async for message in queue_iter:
+                    if self._is_shutdown:
+                        logger.info("消费已停止，退出消费循环")
+                        break
+                    await consume_callback_wrapper(message)
+        finally:
+            await self.release_channel(current_channel, current_conn)
+
+    async def close(self):
+        """关闭通道池：释放所有通道 + 关闭唯一连接"""
+        if self._is_shutdown:
+            logger.warning("通道池已关闭，无需重复操作")
+            return
+
+        self._is_shutdown = True
+        logger.info("开始关闭RabbitMQ单连接通道池...")
+
+        # 安全释放所有资源
+        await self._safe_close_resources()
 
-        logger.info("RabbitMQ连接池已完全关闭")
+        logger.info("RabbitMQ单连接通道池已完全关闭")

sycommon/rabbitmq/rabbitmq_service.py

@@ -118,10 +118,6 @@ class RabbitMQService:
                 username=cls._config.get('username', ""),
                 password=cls._config.get('password', ""),
                 virtualhost=cls._config.get('virtual-host', "/"),
-                connection_pool_size=cls._config.get(
-                    '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", "")
             )
 

sycommon/services.py

@@ -71,7 +71,8 @@ class Services(metaclass=SingletonMeta):
         app.state.config = {
             "host": cls._config.get('Host', '0.0.0.0'),
             "port": cls._config.get('Port', 8080),
-            "workers": cls._config.get('Workers', 1)
+            "workers": cls._config.get('Workers', 1),
+            "h11_max_incomplete_event_size": cls._config.get('H11MaxIncompleteEventSize', 1024 * 1024 * 1024)
         }
 
         # 立即配置非异步服务（在应用启动前）

sycommon/synacos/feign.py

@@ -97,7 +97,7 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
                     data=data,
                     timeout=timeout
                 ) as response:
-                    return await _handle_feign_response(response)
+                    return await _handle_feign_response(response, service_name, api_path)
             else:
                 # 普通JSON请求
                 async with session.request(
@@ -108,21 +108,21 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
                     json=body,
                     timeout=timeout
                 ) as response:
-                    return await _handle_feign_response(response)
+                    return await _handle_feign_response(response, service_name, api_path)
         except aiohttp.ClientError as e:
             SYLogger.error(
-                f"nacos:请求服务接口时出错ClientError path: {api_path} error:{e}")
+                f"nacos:请求服务接口时出错ClientError server: {service_name} path: {api_path} error:{e}")
             return None
     except Exception as e:
         import traceback
         SYLogger.error(
-            f"nacos:请求服务接口时出错 path: {api_path} error:{traceback.format_exc()}")
+            f"nacos:请求服务接口时出错 server: {service_name} path: {api_path} error:{traceback.format_exc()}")
         return None
     finally:
         await session.close()
 
 
-async def _handle_feign_response(response):
+async def _handle_feign_response(response, service_name: str, api_path: str):
     """
     处理Feign请求的响应，统一返回格式
     调整逻辑：先判断状态码，再处理内容
@@ -160,9 +160,9 @@ async def _handle_feign_response(response):
                     response_body = await response.text(encoding='utf-8', errors='ignore')
             except Exception:
                 binary_data = await response.read()
-                response_body = f"非200状态，响应无法解码：{binary_data[:100].hex()}"
+                response_body = f"非200状态，响应无法解码：{binary_data[:100].hex()} server: {service_name} path: {api_path}"
 
-            error_msg = f"请求失败，状态码: {status_code}，响应内容: {str(response_body)[:500]}"
+            error_msg = f"请求失败，状态码: {status_code}，响应内容: {str(response_body)[:500]} server: {service_name} path: {api_path}"
             SYLogger.error(error_msg)
             return {
                 "success": False,
@@ -174,5 +174,6 @@ async def _handle_feign_response(response):
     except Exception as e:
         import traceback
         error_detail = f"处理响应异常: {str(e)}\n{traceback.format_exc()}"
-        SYLogger.error(f"nacos:处理响应时出错: {error_detail}")
+        SYLogger.error(
+            f"nacos:处理响应时出错: {error_detail} server: {service_name} path: {api_path}")
         return None

sycommon/synacos/nacos_service.py

@@ -10,7 +10,6 @@ import yaml
 import time
 import atexit
 import random
-from concurrent.futures import ThreadPoolExecutor
 
 from sycommon.config.Config import SingletonMeta
 from sycommon.logging.kafka_log import SYLogger
@@ -34,22 +33,17 @@ class NacosService(metaclass=SingletonMeta):
             # 添加可重入锁用于状态同步
             self._state_lock = threading.RLock()
 
-            # 优化线程池配置，增加工作线程数量
-            self._executor = ThreadPoolExecutor(max_workers=1)  # 主线程池
-            self._heartbeat_executor = ThreadPoolExecutor(
-                max_workers=1)  # 增加心跳线程
-            self._monitor_executor = ThreadPoolExecutor(
-                max_workers=1)  # 增加监控线程
-
             # 配置参数
             self.max_retries = self.nacos_config.get('maxRetries', 5)
             self.retry_delay = self.nacos_config.get('retryDelay', 1)
-            self.retry_backoff = self.nacos_config.get('retryBackoff', 1.5)
             self.max_retry_delay = self.nacos_config.get('maxRetryDelay', 30)
+            # 心跳间隔：优先从配置读取，默认15秒（可通过配置修改）
             self.heartbeat_interval = self.nacos_config.get(
                 'heartbeatInterval', 15)
+            # 心跳超时：固定设置为10秒（需求指定）
+            self.heartbeat_timeout = 15
             self.register_retry_interval = self.nacos_config.get(
-                'registerRetryInterval', 5)  # 注册重试间隔
+                'registerRetryInterval', 15)  # 注册重试间隔
 
             # 长期重试配置
             self.long_term_retry_delay = self.nacos_config.get(
@@ -129,8 +123,7 @@ class NacosService(metaclass=SingletonMeta):
                 self._client_initialized = True
                 return True
             except Exception as e:
-                delay = min(self.retry_delay * (self.retry_backoff **
-                            attempt), self.max_retry_delay)
+                delay = min(self.retry_delay, self.max_retry_delay)
                 SYLogger.error(
                     f"nacos:客户端初始化失败 (尝试 {attempt+1}/{self.max_retries}): {e}")
                 time.sleep(delay)
@@ -193,8 +186,7 @@ class NacosService(metaclass=SingletonMeta):
 
                 except Exception as e:
                     attempt += 1
-                    delay = min(self.retry_delay * (self.retry_backoff **
-                                (attempt - 1)), self.max_retry_delay)
+                    delay = min(self.retry_delay, self.max_retry_delay)
 
                     SYLogger.error(
                         f"nacos:客户端初始化失败 (尝试 {attempt}/{max_attempts}): {e}")
@@ -342,8 +334,7 @@ class NacosService(metaclass=SingletonMeta):
             except Exception as e:
                 last_error = str(e)
                 retry_count += 1
-                delay = min(self.register_retry_interval *
-                            (self.retry_backoff ** (retry_count - 1)), self.max_retry_delay)
+                delay = min(self.register_retry_interval, self.max_retry_delay)
 
                 SYLogger.warning(
                     f"nacos:服务注册尝试 {retry_count} 失败: {last_error}，{delay}秒后重试")
@@ -429,8 +420,13 @@ class NacosService(metaclass=SingletonMeta):
             timeout = 60  # 60秒超时
             start_time = time.time()
 
-            # 启动注册线程，不阻塞主线程
-            instance._executor.submit(instance.register_with_retry)
+            # 启动注册线程，不阻塞主线程（替换原线程池）
+            register_thread = threading.Thread(
+                target=instance.register_with_retry,
+                daemon=True,
+                name="NacosRegisterThread"
+            )
+            register_thread.start()
 
             # 等待注册完成或超时
             while True:
@@ -461,7 +457,7 @@ class NacosService(metaclass=SingletonMeta):
 
             # 启动连接监控线程
             threading.Thread(target=instance.monitor_connection,
-                             daemon=True).start()
+                             daemon=True, name="NacosConnectionMonitorThread").start()
         else:
             SYLogger.info("nacos:本地开发模式，跳过服务注册流程")
 
@@ -485,7 +481,11 @@ class NacosService(metaclass=SingletonMeta):
             )
             self._heartbeat_thread.daemon = True
             self._heartbeat_thread.start()
-            SYLogger.info(f"nacos:心跳线程启动，线程ID: {self._heartbeat_thread.ident}")
+            SYLogger.info(
+                f"nacos:心跳线程启动，线程ID: {self._heartbeat_thread.ident}，"
+                f"心跳间隔: {self.heartbeat_interval}秒，"
+                f"心跳超时: {self.heartbeat_timeout}秒"
+            )
 
     def _send_heartbeat_loop(self):
         """优化后的心跳发送循环，确保严格按间隔执行"""
@@ -493,7 +493,8 @@ class NacosService(metaclass=SingletonMeta):
         thread_ident = current_thread.ident
         SYLogger.info(
             f"nacos:心跳循环启动 - 线程ID: {thread_ident}, "
-            f"配置间隔: {self.heartbeat_interval}秒"
+            f"配置间隔: {self.heartbeat_interval}秒, "
+            f"超时时间: {self.heartbeat_timeout}秒"
         )
 
         consecutive_fail = 0  # 连续失败计数器
@@ -512,7 +513,7 @@ class NacosService(metaclass=SingletonMeta):
                         f"nacos:服务未注册，跳过心跳 - 线程ID: {thread_ident}")
                     consecutive_fail = 0
                 else:
-                    # 发送心跳
+                    # 发送心跳（10秒超时）
                     success = self.send_heartbeat()
                     if success:
                         consecutive_fail = 0
@@ -545,26 +546,46 @@ class NacosService(metaclass=SingletonMeta):
         SYLogger.info(f"nacos:心跳循环已停止 - 线程ID: {thread_ident}")
 
     def send_heartbeat(self):
-        """发送心跳并添加超时控制"""
+        """发送心跳并添加10秒超时控制（替换线程池实现）"""
         if not self.ensure_client_connected():
             SYLogger.warning("nacos:客户端未连接，心跳发送失败")
             return False
 
-        try:
-            # 严格控制心跳超时（3秒）
-            future = self._heartbeat_executor.submit(
-                self._send_heartbeat_internal)
-            result = future.result(timeout=3)  # 超时后抛出异常
-
-            if result:
-                # 只有确认成功才更新时间戳
-                self._last_successful_heartbeat = time.time()
-            return result
-        except Exception as e:
-            SYLogger.error(f"nacos:发送心跳时发生异常: {e}")
+        # 用线程+join实现10秒超时控制
+        result_list = []  # 用于线程间传递结果
+
+        def heartbeat_task():
+            """心跳实际执行任务"""
+            try:
+                result = self._send_heartbeat_internal()
+                result_list.append(result)
+            except Exception as e:
+                SYLogger.error(f"nacos:心跳任务执行异常: {e}")
+                result_list.append(False)
+
+        # 启动心跳任务线程
+        task_thread = threading.Thread(
+            target=heartbeat_task,
+            daemon=True,
+            name="NacosHeartbeatTaskThread"
+        )
+        task_thread.start()
+
+        # 等待线程完成，最多等待10秒
+        task_thread.join(timeout=self.heartbeat_timeout)
+
+        # 处理结果
+        if not result_list:
+            # 超时未返回
+            SYLogger.error(f"nacos:心跳发送超时（{self.heartbeat_timeout}秒）")
             self._client_initialized = False  # 强制重连
             return False
 
+        # 检查心跳结果
+        if result_list[0]:
+            self._last_successful_heartbeat = time.time()
+        return result_list[0]
+
     def _send_heartbeat_internal(self):
         """实际的心跳发送逻辑"""
         result = self.nacos_client.send_heartbeat(
@@ -620,9 +641,13 @@ class NacosService(metaclass=SingletonMeta):
                         else:
                             self.registered = False
                             SYLogger.warning(f"nacos:服务实例未注册，尝试重新注册")
-                            # 不在锁内调用可能耗时的操作
-                            self._monitor_executor.submit(
-                                self.register_with_retry)
+                            # 启动临时线程执行重新注册（替换原线程池）
+                            retry_thread = threading.Thread(
+                                target=self.register_with_retry,
+                                daemon=True,
+                                name="NacosRetryRegisterThread"
+                            )
+                            retry_thread.start()
 
                 # 20%的概率执行深度检查
                 if random.random() < 0.2:
@@ -673,13 +698,6 @@ class NacosService(metaclass=SingletonMeta):
             SYLogger.error(f"nacos:注销服务时发生错误: {e}")
         finally:
             self._shutdown_event.set()
-            # 优雅地关闭线程池
-            if self._executor and not self._executor._shutdown:
-                self._executor.shutdown(wait=True)
-            if self._heartbeat_executor and not self._heartbeat_executor._shutdown:
-                self._heartbeat_executor.shutdown(wait=True)
-            if self._monitor_executor and not self._monitor_executor._shutdown:
-                self._monitor_executor.shutdown(wait=True)
 
     def handle_signal(self, signum, frame):
         """处理退出信号"""
@@ -751,7 +769,8 @@ class NacosService(metaclass=SingletonMeta):
                 for data_id, callback in list(self._config_listeners.items()):
                     new_config = self.get_config(data_id)
                     if new_config and new_config != self._config_cache.get(data_id):
-                        self._executor.submit(callback, new_config)
+                        # 直接执行回调（替换原线程池，配置回调通常为轻量操作）
+                        callback(new_config)
                         self._config_cache[data_id] = new_config
             except Exception as e:
                 SYLogger.error(f"nacos:配置监视线程异常: {str(e)}")

{sycommon_python_lib-0.1.43.dist-info → sycommon_python_lib-0.1.44.dist-info}/METADATA

@@ -1,22 +1,22 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.43
+Version: 0.1.44
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: aio-pika>=9.5.7
-Requires-Dist: aiohttp>=3.13.1
+Requires-Dist: aio-pika>=9.5.8
+Requires-Dist: aiohttp>=3.13.2
 Requires-Dist: decorator>=5.2.1
-Requires-Dist: fastapi>=0.120.0
-Requires-Dist: kafka-python>=2.2.15
+Requires-Dist: fastapi>=0.121.2
+Requires-Dist: kafka-python>=2.2.16
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mysql-connector-python>=9.5.0
 Requires-Dist: nacos-sdk-python>=2.0.9
-Requires-Dist: pydantic>=2.12.3
+Requires-Dist: pydantic>=2.12.4
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: sqlalchemy>=2.0.44
-Requires-Dist: starlette>=0.48.0
+Requires-Dist: starlette>=0.49.3
 Requires-Dist: uuid>=1.30
 Requires-Dist: uvicorn>=0.38.0
 

{sycommon_python_lib-0.1.43.dist-info → sycommon_python_lib-0.1.44.dist-info}/RECORD

@@ -1,6 +1,6 @@
 command/cli.py,sha256=bP2LCLkRvfETIwWkVD70q5xFxMI4D3BpH09Ws1f-ENc,5849
 sycommon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/services.py,sha256=e9odPBLUoAAUkFU4s8ITIQUbr1GH7dqb9qSHyUhN4A8,11258
+sycommon/services.py,sha256=LHMRxxRvLAiekkVspaQClBgAR_jLKqiJpd5hqF74MIE,11369
 sycommon/config/Config.py,sha256=9yO5b8WfvEDvkyrGrlwrLFasgh_-MjcEvGF20Gz5Xo4,3041
 sycommon/config/DatabaseConfig.py,sha256=ILiUuYT9_xJZE2W-RYuC3JCt_YLKc1sbH13-MHIOPhg,804
 sycommon/config/EmbeddingConfig.py,sha256=gPKwiDYbeu1GpdIZXMmgqM7JqBIzCXi0yYuGRLZooMI,362
@@ -36,24 +36,24 @@ sycommon/models/mqmsg_model.py,sha256=cxn0M5b0utQK6crMYmL-1waeGYHvK3AlGaRy23clqT
 sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6D7I,268
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
 sycommon/rabbitmq/rabbitmq_client.py,sha256=aRS7sYN4RAJ210Bl-Bh0qR7mXpaag_5YygNXz6ryhtQ,19677
-sycommon/rabbitmq/rabbitmq_pool.py,sha256=j4zmmyxFbkeJ9-VsTo3-JqjpvHnfxA8omvp7zNei4yA,16758
-sycommon/rabbitmq/rabbitmq_service.py,sha256=i9SLammld_oMRQskSGw9UGOTuRBdZcuCFUq0YObME-Y,40012
+sycommon/rabbitmq/rabbitmq_pool.py,sha256=ckHEpvPXS4TdHRS_2eGyiQ7kej3P7Wnyk3nttAjk04o,17724
+sycommon/rabbitmq/rabbitmq_service.py,sha256=L7SKf8Ws2wZvF0YGU1ZUiqg3z_viSNmMR0Zz4_5jBSY,39775
 sycommon/sse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/sse/event.py,sha256=k_rBJy23R7crtzQeetT0Q73D8o5-5p-eESGSs_BPOj0,2797
 sycommon/sse/sse.py,sha256=__CfWEcYxOxQ-HpLor4LTZ5hLWqw9-2X7CngqbVHsfw,10128
 sycommon/synacos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/synacos/example.py,sha256=61XL03tU8WTNOo3FUduf93F2fAwah1S0lbH1ufhRhRk,5739
 sycommon/synacos/example2.py,sha256=adUaru3Hy482KrOA17DfaC4nwvLj8etIDS_KrWLWmCU,4811
-sycommon/synacos/feign.py,sha256=0cmnyExXcr1qIV0B_POdQ-_u4-t5K3LjJD_8rDaXwSE,7467
+sycommon/synacos/feign.py,sha256=-2tuGCqoSM3ddSoSz7h1RJTB06hn8K26v_1ev4qLsTU,7728
 sycommon/synacos/feign_client.py,sha256=JxzxohrsscQNlAjRVo_3ZQrMQSfVHFOtRYyEnP6sDGk,15205
-sycommon/synacos/nacos_service.py,sha256=QG1lShrVZNKbExYV_IUwGXTHDnU09RYXooVy_llhW6c,34661
+sycommon/synacos/nacos_service.py,sha256=Hxd3fQOR53iujUjCboJoQum5vAXxQ9sdc8YlDug1OF0,35092
 sycommon/synacos/param.py,sha256=KcfSkxnXOa0TGmCjY8hdzU9pzUsA8-4PeyBKWI2-568,1765
 sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
 sycommon/tools/snowflake.py,sha256=DdEj3T5r5OEvikp3puxqmmmz6BrggxomoSlnsRFb5dM,1174
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.43.dist-info/METADATA,sha256=tC87wV6W1tA6pPVBv1TjUBUV0ZlBeCMUclUt06ANu_g,7037
-sycommon_python_lib-0.1.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.43.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.43.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.43.dist-info/RECORD,,
+sycommon_python_lib-0.1.44.dist-info/METADATA,sha256=e_42ggxA1f4lcE0zFt2uvEPbT_Q5pANx_Dpb6HFIrVQ,7037
+sycommon_python_lib-0.1.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.44.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.44.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.44.dist-info/RECORD,,