sycommon-python-lib 0.1.32__tar.gz → 0.1.33__tar.gz

{sycommon_python_lib-0.1.32 → sycommon_python_lib-0.1.33}/PKG-INFO

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

{sycommon_python_lib-0.1.32 → sycommon_python_lib-0.1.33}/pyproject.toml

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

{sycommon_python_lib-0.1.32 → sycommon_python_lib-0.1.33}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -45,11 +45,6 @@ class RabbitMQClient:
         prefetch_count: int = 2,
         consumption_stall_threshold: int = 10
     ):
-        """
-        初始化RabbitMQ客户端（依赖连接池）
-
-        :param connection_pool: 连接池实例
-        """
         # 连接池依赖
         self.connection_pool = connection_pool
 
@@ -85,7 +80,7 @@ class RabbitMQClient:
         self._exchange_exists = False
         self._queue_exists = False
         self._queue_bound = False
-        self._is_consuming = False
+        self._is_consuming = False  # 核心消费状态标志
         self._closed = False
         self._consumer_tag: Optional[ConsumerTag] = None
         self._last_activity_timestamp = asyncio.get_event_loop().time()
@@ -120,19 +115,23 @@ class RabbitMQClient:
         """更新最后消息处理时间戳"""
         self._last_message_processed = asyncio.get_event_loop().time()
 
+    def _set_is_consuming(self, value: bool) -> None:
+        """安全更新消费状态并记录日志"""
+        if self._is_consuming != value:
+            logger.info(f"消费状态变更: {self._is_consuming} → {value}")
+            self._is_consuming = value
+
     async def _get_channel(self) -> AbstractChannel:
         """从通道池获取通道（使用上下文管理器）"""
         if not self.connection_pool.channel_pool:
             raise Exception("连接池未初始化，请先调用init_pools")
 
-        # 使用async with获取通道，并通过变量返回
         async with self.connection_pool.channel_pool.acquire() as channel:
             return channel
 
     async def _check_exchange_exists(self, channel: AbstractChannel) -> bool:
         """检查交换机是否存在"""
         try:
-            # 使用被动模式检查交换机
             await asyncio.wait_for(
                 channel.declare_exchange(
                     name=self.exchange_name,
@@ -150,7 +149,6 @@ class RabbitMQClient:
         if not self.queue_name:
             return False
         try:
-            # 使用被动模式检查队列
             await asyncio.wait_for(
                 channel.declare_queue(
                     name=self.queue_name,
@@ -186,19 +184,15 @@ class RabbitMQClient:
         return False
 
     async def connect(self, force_reconnect: bool = False, declare_queue: bool = True) -> None:
-        """
-        从连接池获取资源并初始化（交换机、队列）
-        """
+        """从连接池获取资源并初始化（交换机、队列）"""
         logger.info(
             f"连接参数 - force_reconnect={force_reconnect}, "
             f"declare_queue={declare_queue}, create_if_not_exists={self.create_if_not_exists}"
         )
 
-        # 如果已连接且不强制重连，则直接返回
         if self.is_connected and not force_reconnect:
             return
 
-        # 取消正在进行的重连任务
         if self._reconnect_task and not self._reconnect_task.done():
             self._reconnect_task.cancel()
 
@@ -206,13 +200,13 @@ class RabbitMQClient:
         self._exchange_exists = False
         self._queue_exists = False
         self._queue_bound = False
+        self._set_is_consuming(False)  # 连接时先停止消费
 
         retries = 0
         last_exception = None
 
         while retries < self.max_reconnection_attempts:
             try:
-                # 从池获取通道
                 self.channel = await self._get_channel()
                 await self.channel.set_qos(prefetch_count=self.prefetch_count)
 
@@ -220,7 +214,6 @@ class RabbitMQClient:
                 exchange_exists = await self._check_exchange_exists(self.channel)
                 if not exchange_exists:
                     if self.create_if_not_exists:
-                        # 创建交换机
                         self.exchange = await asyncio.wait_for(
                             self.channel.declare_exchange(
                                 name=self.exchange_name,
@@ -235,7 +228,6 @@ class RabbitMQClient:
                         raise Exception(
                             f"交换机 '{self.exchange_name}' 不存在且不允许自动创建")
                 else:
-                    # 获取已有交换机
                     self.exchange = await self.channel.get_exchange(self.exchange_name)
                     logger.info(f"使用已存在的交换机 '{self.exchange_name}'")
 
@@ -248,7 +240,6 @@ class RabbitMQClient:
                             raise Exception(
                                 f"队列 '{self.queue_name}' 不存在且不允许自动创建")
 
-                        # 创建队列
                         self.queue = await asyncio.wait_for(
                             self.channel.declare_queue(
                                 name=self.queue_name,
@@ -261,7 +252,6 @@ class RabbitMQClient:
                         self.actual_queue_name = self.queue_name
                         logger.info(f"已创建队列 '{self.queue_name}'")
                     else:
-                        # 获取已有队列
                         self.queue = await self.channel.get_queue(self.queue_name)
                         self.actual_queue_name = self.queue_name
                         logger.info(f"使用已存在的队列 '{self.queue_name}'")
@@ -272,31 +262,30 @@ class RabbitMQClient:
                         if not bound:
                             raise Exception(f"队列 '{self.queue_name}' 绑定到交换机失败")
                 else:
-                    # 不声明队列时的状态处理
                     self.queue = None
                     self.actual_queue_name = None
                     logger.info(f"跳过队列 '{self.queue_name}' 的声明和绑定")
 
-                # 验证连接状态
                 if not self.is_connected:
                     raise Exception("连接验证失败，状态异常")
 
-                # 如果之前在消费，重新开始消费
-                if self._is_consuming and self.message_handler:
+                # 重新开始消费（如果之前在消费）
+                if self.message_handler:
                     await self.start_consuming()
 
-                # 启动连接监控和保活任务
+                # 启动监控和保活任务
                 self._start_monitoring()
                 self._start_keepalive()
 
                 self._update_activity_timestamp()
+                # 清理可能残留的跟踪记录
+                self._tracking_messages.clear()
                 logger.info(f"RabbitMQ客户端初始化成功 (队列: {self.actual_queue_name})")
                 return
 
             except Exception as e:
                 last_exception = e
                 logger.warning(f"资源初始化失败: {str(e)}，重试中...")
-                # 释放当前通道（放回池并重新获取）
                 self.channel = None
                 retries += 1
                 if retries < self.max_reconnection_attempts:
@@ -320,32 +309,32 @@ class RabbitMQClient:
                         await self._recreate_channel()
                         continue
 
-                    # 清理已确认的消息记录
+                    current_time = asyncio.get_event_loop().time()
+                    # 清理消息跟踪记录
                     if self._tracking_messages:
-                        # 收集所有已确认的消息ID
-                        acked_message_ids = [
-                            msg_id for msg_id, msg_info in self._tracking_messages.items()
-                            if msg_info.get('acked', False)
+                        # 1. 清理已确认的消息
+                        acked_ids = [
+                            msg_id for msg_id, info in self._tracking_messages.items()
+                            if info.get('acked', False)
                         ]
-                        # 移除已确认的消息
-                        for msg_id in acked_message_ids:
+                        for msg_id in acked_ids:
                             del self._tracking_messages[msg_id]
-                        if acked_message_ids:
-                            logger.info(
-                                f"清理了 {len(acked_message_ids)} 条已确认的消息跟踪记录")
+                        if acked_ids:
+                            logger.info(f"清理了 {len(acked_ids)} 条已确认消息记录")
 
                     # 检查消费停滞
                     if self._is_consuming:
-                        current_time = asyncio.get_event_loop().time()
                         if current_time - self._last_message_processed > self.consumption_stall_threshold:
                             if self._tracking_messages:
-                                logger.info(
+                                logger.warning(
                                     f"消费停滞，但有 {len(self._tracking_messages)} 个消息正在处理，暂不重启")
                             else:
-                                # 确实无消息处理，再重启
+                                # 无有效消息，重启消费
+                                logger.info("消费停滞且无消息处理，重启消费")
                                 await self.stop_consuming()
                                 await asyncio.sleep(1)
                                 await self.start_consuming()
+
                 except Exception as e:
                     logger.error(f"监控任务出错: {str(e)}")
                     await asyncio.sleep(1)
@@ -356,21 +345,18 @@ class RabbitMQClient:
 
     async def _recreate_channel(self) -> None:
         try:
-            # 无需手动释放，上下文管理器会自动处理
             self.channel = await self._get_channel()
             await self.channel.set_qos(prefetch_count=self.prefetch_count)
 
-            # 重新获取交换机
+            # 重新获取交换机和队列
             self.exchange = await self.channel.get_exchange(self.exchange_name)
-
-            # 重新绑定队列
             if self.queue_name:
                 self.queue = await self.channel.get_queue(self.queue_name)
                 if self.queue and self.exchange:
                     await self._bind_queue(self.channel, self.queue, self.exchange)
 
             # 重新开始消费
-            if self._is_consuming and self.message_handler:
+            if self.message_handler:
                 await self.start_consuming()
 
             logger.info("通道已重建并恢复服务")
@@ -387,10 +373,9 @@ class RabbitMQClient:
         async def keepalive():
             while not self._closed and self.is_connected:
                 current_time = asyncio.get_event_loop().time()
-                # 检查是否超过指定时间无活动
-                if current_time - self._last_activity_timestamp > self.connection_pool.heartbeat * 1.5:
+                if current_time - self._last_activity_timestamp > self.connection_pool.heartbeat * 2:
                     logger.info(
-                        f"连接 {self.connection_pool.heartbeat*1.5}s 无活动，执行保活检查")
+                        f"连接 {self.connection_pool.heartbeat*2}s 无活动，执行保活检查")
                     try:
                         if self.channel.is_closed:
                             logger.warning("连接已关闭，触发重连")
@@ -411,7 +396,7 @@ class RabbitMQClient:
                         logger.warning(f"保活检查失败: {str(e)}，触发重连")
                         await self.connect(force_reconnect=True)
 
-                await asyncio.sleep(self.connection_pool.heartbeat / 2)
+                await asyncio.sleep(self.connection_pool.heartbeat)
 
         self._keepalive_task = asyncio.create_task(keepalive())
 
@@ -437,7 +422,7 @@ class RabbitMQClient:
     async def close(self) -> None:
         """关闭客户端并释放资源"""
         self._closed = True
-        self._is_consuming = False
+        self._set_is_consuming(False)
 
         # 取消所有任务
         for task in [self._keepalive_task, self._reconnect_task,
@@ -495,14 +480,13 @@ class RabbitMQClient:
         max_retries = 2
         while retry_count < max_retries:
             try:
-                # 从池获取新通道用于发布（避免长时间占用消费通道）
                 async with self.connection_pool.channel_pool.acquire() as publish_channel:
                     exchange = await publish_channel.get_exchange(self.exchange_name)
                     confirmed = await exchange.publish(
                         message,
                         routing_key=routing_key or self.routing_key or '#',
                         mandatory=True,
-                        timeout=5.0
+                        timeout=5
                     )
                     if not confirmed:
                         raise Exception("消息未被服务器确认接收")
@@ -510,9 +494,11 @@ class RabbitMQClient:
                 self._update_activity_timestamp()
                 logger.info(f"消息已发布到交换机 '{self.exchange_name}'")
                 return
-            except (ConnectionClosed, ChannelInvalidStateError):
+            except (ConnectionClosed, ChannelInvalidStateError, asyncio.TimeoutError):
+                # 覆盖更多异常类型
                 retry_count += 1
-                logger.warning(f"连接已关闭，尝试重连后重新发布 (重试次数: {retry_count})")
+                logger.warning(f"连接异常，尝试重连后重新发布 (重试次数: {retry_count})")
+                # 主动刷新连接状态
                 await self.connect(force_reconnect=True)
             except Exception as e:
                 retry_count += 1
@@ -522,7 +508,6 @@ class RabbitMQClient:
 
         raise Exception(f"消息发布失败，经过{retry_count}次重试仍未成功")
 
-    # 以下方法（消息消费相关）逻辑与原有保持一致，仅适配连接池
     def set_message_handler(self, handler):
         self.message_handler = handler
 
@@ -531,9 +516,8 @@ class RabbitMQClient:
             logger.info("已经在消费中，返回现有consumer_tag")
             if self._consumer_tag:
                 return self._consumer_tag
-            # 如果_is_consuming为True但无consumer_tag，重置状态并重新启动
             logger.warning("检测到消费状态异常（无consumer_tag），重置状态后重试")
-            self._is_consuming = False  # 重置状态
+            self._set_is_consuming(False)
 
         if not self.is_connected:
             await self.connect()
@@ -544,25 +528,21 @@ class RabbitMQClient:
         if not self.message_handler:
             raise Exception("未设置消息处理函数")
 
-        self._is_consuming = True
-        logger.info(f"开始消费队列: {self.actual_queue_name}")
-
         try:
-            # 调用队列的consume方法，确保获取到consumer_tag
             self._consumer_tag = await self.queue.consume(
                 self._message_wrapper,
                 no_ack=False  # 手动确认消息
             )
 
-            # 确保consumer_tag有效
             if not self._consumer_tag:
                 raise Exception("未能获取到有效的consumer_tag")
 
+            self._set_is_consuming(True)
             logger.info(
                 f"消费者已启动，队列: {self.actual_queue_name}, tag: {self._consumer_tag}")
             return self._consumer_tag
         except Exception as e:
-            self._is_consuming = False  # 异常时重置状态
+            self._set_is_consuming(False)
             logger.error(f"启动消费失败: {str(e)}", exc_info=True)
             raise
 
@@ -585,22 +565,25 @@ class RabbitMQClient:
         if not self._is_consuming:
             return
 
-        self._is_consuming = False
+        self._set_is_consuming(False)
 
         if self._consumer_tag and self.queue:
             await self._safe_cancel_consumer()
 
         # 等待所有正在处理的消息完成
         if self._tracking_messages:
-            logger.info(
-                f"等待 {len(self._tracking_messages)} 个正在处理的消息完成...")
+            logger.info(f"等待 {len(self._tracking_messages)} 个正在处理的消息完成...")
+            wait_start = asyncio.get_event_loop().time()
             while self._tracking_messages and not self._closed:
+                if asyncio.get_event_loop().time() - wait_start > 30:  # 最多等30秒
+                    logger.warning("等待消息处理超时，强制清理跟踪记录")
+                    self._tracking_messages.clear()
+                    break
                 await asyncio.sleep(1)
 
         # 清理状态
         self._consumer_tag = None
         self._tracking_messages.clear()
-
         logger.info(f"已停止消费队列: {self.actual_queue_name}")
 
     async def _parse_message(self, message: AbstractIncomingMessage) -> Union[Dict[str, Any], str]:
@@ -620,8 +603,7 @@ class RabbitMQClient:
 
     async def _message_wrapper(self, message: AbstractIncomingMessage) -> None:
         if not self.message_handler or not self._is_consuming:
-            logger.warning("未设置消息处理器或已停止消费")
-            # await message.ack()
+            logger.warning("未设置消息处理器或已停止消费，拒绝消息，重新放到队列")
             try:
                 await message.reject(requeue=True)
             except Exception as e:
@@ -634,21 +616,23 @@ class RabbitMQClient:
             await message.ack()
             return
 
-        # 记录消息跟踪信息
+        start_time = asyncio.get_event_loop().time()
         self._tracking_messages[message_id] = {
             'delivery_tag': message.delivery_tag,
             'acked': False,
-            'channel_number': self.channel.number if self.channel else None
+            'channel_number': self.channel.number if self.channel else None,
+            'start_time': start_time
         }
 
         try:
             logger.info(f"收到队列 {self.actual_queue_name} 的消息: {message_id}")
+            print(f"收到队列 {self.actual_queue_name} 的消息: {message_id}")
 
             parsed_data = await self._parse_message(message)
             await self.message_handler(MQMsgModel(** parsed_data), message)
 
             await message.ack()
-            self._tracking_messages[message_id]['acked'] = True  # 更新ACK状态
+            self._tracking_messages[message_id]['acked'] = True
             self._update_activity_timestamp()
             self._update_message_processed_timestamp()
             logger.info(f"消息 {message_id} 处理完成并确认")
@@ -665,9 +649,9 @@ class RabbitMQClient:
 
             if retry_count >= MAX_RETRY_COUNT:
                 logger.error(
-                    f"消息 {message_id} 已达到最大重试次数({MAX_RETRY_COUNT}次)，标记为失败")
+                    f"消息 {message_id} 已达到最大重试次数{MAX_RETRY_COUNT}，标记为失败")
                 await message.ack()
-                self._tracking_messages[message_id]['acked'] = True  # 更新ACK状态
+                self._tracking_messages[message_id]['acked'] = True
                 self._update_activity_timestamp()
                 return
 
@@ -682,7 +666,7 @@ class RabbitMQClient:
             )
 
             await message.reject(requeue=False)
-            self._tracking_messages[message_id]['acked'] = True  # 拒绝也算处理完成
+            self._tracking_messages[message_id]['acked'] = True
 
             if self.exchange:
                 await self.exchange.publish(
@@ -696,6 +680,7 @@ class RabbitMQClient:
         finally:
             if message_id in self._tracking_messages:
                 del self._tracking_messages[message_id]
+                logger.info(f"已删除消息跟踪信息: {message_id}")
 
     async def __aenter__(self):
         await self.connect()

{sycommon_python_lib-0.1.32 → sycommon_python_lib-0.1.33}/src/sycommon/rabbitmq/rabbitmq_service.py

@@ -105,7 +105,7 @@ class RabbitMQService:
             )
 
             # 初始化连接池
-            await cls._connection_pool.init_pools()
+            await asyncio.wait_for(cls._connection_pool.init_pools(), timeout=30)
             logger.info("RabbitMQ连接池初始化成功")
 
         except Exception as e:

{sycommon_python_lib-0.1.32 → sycommon_python_lib-0.1.33}/src/sycommon/services.py

@@ -199,6 +199,10 @@ class Services(metaclass=SingletonMeta):
                 if not sender:
                     raise ValueError(f"发送器 '{queue_name}' 不存在")
 
+                if not (sender.is_connected and sender.channel and not sender.channel.is_closed):
+                    logging.info(f"发送器 '{queue_name}' 连接无效，强制重连")
+                    await sender.connect(force_reconnect=True, declare_queue=False)
+
                 await RabbitMQService.send_message(data, queue_name, ** kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
                 return

{sycommon_python_lib-0.1.32 → sycommon_python_lib-0.1.33}/src/sycommon_python_lib.egg-info/PKG-INFO

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