sycommon-python-lib 0.1.36__tar.gz → 0.1.38__tar.gz

{sycommon_python_lib-0.1.36 → sycommon_python_lib-0.1.38}/PKG-INFO

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

{sycommon_python_lib-0.1.36 → sycommon_python_lib-0.1.38}/pyproject.toml

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

{sycommon_python_lib-0.1.36 → sycommon_python_lib-0.1.38}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -1,3 +1,7 @@
+from aio_pika.pool import Pool
+from aio_pika.abc import AbstractRobustConnection
+from aio_pika import connect_robust, Channel
+from typing import Optional, List
 import asyncio
 import json
 from typing import Callable, Coroutine, Optional, Dict, Any, Union, Set
@@ -81,9 +85,8 @@ class RabbitMQClient:
         self._exchange_exists = False  # 由 _connection_lock 保护
         self._queue_exists = False     # 由 _connection_lock 保护
         self._queue_bound = False      # 由 _connection_lock 保护
-        self._is_consuming = False     # 由 _consume_state_lock 保护
         self._closed = False           # 由 _connection_lock 保护
-        # 由 _consume_state_lock 保护
+        # 由 _consume_state_lock 保护：通过 consumer_tag 存在性判断是否在消费
         self._consumer_tag: Optional[ConsumerTag] = None
         self._last_activity_timestamp = asyncio.get_event_loop().time()
         self._last_message_processed = asyncio.get_event_loop().time()
@@ -102,7 +105,7 @@ class RabbitMQClient:
         self._tracking_messages: Dict[str, Dict[str, Any]] = {}
 
         # 细粒度锁（核心设计：按资源类型拆分，避免嵌套）
-        # 保护消费状态（_is_consuming、message_handler、_consumer_tag）
+        # 保护消费状态（message_handler、_consumer_tag）
         self._consume_state_lock = asyncio.Lock()
         self._tracking_lock = asyncio.Lock()       # 保护消息跟踪记录（_tracking_messages）
         # 保护连接/资源状态（channel、exchange、queue、_closed等）
@@ -131,17 +134,19 @@ class RabbitMQClient:
     async def _get_consume_state(self) -> tuple[bool, Optional[Callable], Optional[ConsumerTag]]:
         """安全获取消费相关状态（一次性获取，避免多次加锁）"""
         async with self._consume_state_lock:
-            return self._is_consuming, self.message_handler, self._consumer_tag
+            # 通过 _consumer_tag 是否存在判断是否在消费
+            is_consuming = self._consumer_tag is not None
+            return is_consuming, self.message_handler, self._consumer_tag
 
-    async def _set_consume_state(self, is_consuming: bool, consumer_tag: Optional[ConsumerTag] = None):
-        """安全更新消费状态（原子操作）"""
+    async def _set_consumer_tag(self, consumer_tag: Optional[ConsumerTag] = None):
+        """安全更新消费者标签（替代原 _set_consume_state）"""
         async with self._consume_state_lock:
-            old_is_consuming = self._is_consuming
-            self._is_consuming = is_consuming
-            if consumer_tag is not None:
-                self._consumer_tag = consumer_tag
-            if old_is_consuming != is_consuming:
-                logger.info(f"消费状态变更: {old_is_consuming} → {is_consuming}")
+            old_tag = self._consumer_tag
+            self._consumer_tag = consumer_tag
+            old_is_consuming = old_tag is not None
+            new_is_consuming = consumer_tag is not None
+            if old_is_consuming != new_is_consuming:
+                logger.info(f"消费状态变更: {old_is_consuming} → {new_is_consuming}")
 
     async def set_message_handler(self, handler):
         """设置消息处理器（加锁保护，避免并发修改）"""
@@ -332,7 +337,7 @@ class RabbitMQClient:
         # 重置连接状态和跟踪记录
         await self._reset_connection_state()
         await self._clear_tracking_messages()
-        await self._set_consume_state(is_consuming=False)
+        await self._set_consumer_tag(None)  # 重置消费者标签（停止消费）
 
         retries = 0
         last_exception = None
@@ -401,9 +406,9 @@ class RabbitMQClient:
                 if not await self.is_connected:
                     raise Exception("连接验证失败，状态异常")
 
-                # 重新开始消费（如果已设置处理器）
-                is_consuming, handler, _ = await self._get_consume_state()
-                if handler:
+                # 重新开始消费（如果已设置处理器且之前在消费）
+                _, handler, consumer_tag = await self._get_consume_state()
+                if handler and consumer_tag:  # 有处理器且之前有消费标签，说明需要恢复消费
                     await self.start_consuming()
 
                 # 启动监控和保活任务
@@ -411,6 +416,12 @@ class RabbitMQClient:
                 self._start_keepalive()
 
                 self._update_activity_timestamp()
+
+                # 首次启动时延迟1秒（避免初始化未完成就接收消息）
+                if not force_reconnect:
+                    logger.info("客户端初始化成功，延迟1秒接收消息（解决启动时序问题）")
+                    await asyncio.sleep(1)
+
                 logger.info(f"RabbitMQ客户端初始化成功 (队列: {self.actual_queue_name})")
                 return
 
@@ -447,9 +458,9 @@ class RabbitMQClient:
                     if cleaned_count > 0:
                         logger.info(f"清理了 {cleaned_count} 条已确认消息记录")
 
-                    # 检查消费停滞（仅当消费状态为True时）
-                    is_consuming, _, _ = await self._get_consume_state()
-                    if is_consuming:
+                    # 检查消费停滞（仅当有消费者标签时）
+                    _, handler, consumer_tag = await self._get_consume_state()
+                    if consumer_tag:  # 有消费标签说明正在消费
                         tracking_count = await self._get_tracking_count()
                         if current_time - self._last_message_processed > self.consumption_stall_threshold:
                             if tracking_count > 0:
@@ -469,7 +480,7 @@ class RabbitMQClient:
                                 except Exception as e:
                                     logger.error(
                                         f"重启消费失败: {str(e)}", exc_info=True)
-                                    await self._set_consume_state(is_consuming=False)
+                                    await self._set_consumer_tag(None)
 
                 except Exception as e:
                     logger.error(f"监控任务出错: {str(e)}", exc_info=True)
@@ -482,7 +493,7 @@ class RabbitMQClient:
     async def _recreate_channel(self) -> None:
         """重建通道并恢复资源（无锁嵌套）"""
         # 先停止消费
-        await self._set_consume_state(is_consuming=False)
+        await self._set_consumer_tag(None)
         logger.info("开始重建通道...")
 
         try:
@@ -505,7 +516,7 @@ class RabbitMQClient:
             # 更新连接资源
             await self._update_connection_resources(channel, exchange, queue)
 
-            # 重新开始消费
+            # 重新开始消费（如果有处理器）
             _, handler, _ = await self._get_consume_state()
             if handler:
                 await self.start_consuming()
@@ -516,7 +527,7 @@ class RabbitMQClient:
             self._update_activity_timestamp()
         except Exception as e:
             logger.error(f"通道重建失败: {str(e)}，触发重连", exc_info=True)
-            await self._set_consume_state(is_consuming=False)
+            await self._set_consumer_tag(None)
             await self.connect(force_reconnect=True)
 
     def _start_keepalive(self) -> None:
@@ -701,16 +712,29 @@ class RabbitMQClient:
         if await self._is_closed():
             raise Exception("客户端已关闭，无法启动消费")
 
-        # 检查连接状态
+        # 检查连接状态（确保通道完全就绪）
         if not await self.is_connected:
             await self.connect()
 
+        # 确保通道未关闭（解决启动时通道初始化滞后问题）
+        channel, _, _ = await self._get_connection_resources()
+        max_wait_attempts = 5
+        wait_interval = 0.5
+        for attempt in range(max_wait_attempts):
+            if channel and not channel.is_closed:
+                break
+            logger.debug(f"等待通道就绪（第{attempt+1}/{max_wait_attempts}次）")
+            await asyncio.sleep(wait_interval)
+            channel, _, _ = await self._get_connection_resources()
+        if not channel or channel.is_closed:
+            raise Exception("通道初始化失败，无法启动消费")
+
         # 获取消费状态和资源
-        is_consuming, handler, consumer_tag = await self._get_consume_state()
-        channel, exchange, queue = await self._get_connection_resources()
+        _, handler, consumer_tag = await self._get_consume_state()
+        _, exchange, queue = await self._get_connection_resources()
 
-        # 检查是否已在消费
-        if is_consuming and consumer_tag:
+        # 检查是否已在消费（通过 consumer_tag 是否存在判断）
+        if consumer_tag:
             logger.info(f"已经在消费中，返回现有consumer_tag: {consumer_tag}")
             return consumer_tag
 
@@ -732,31 +756,31 @@ class RabbitMQClient:
             if not new_consumer_tag:
                 raise Exception("未能获取到有效的consumer_tag")
 
-            # 更新消费状态
-            await self._set_consume_state(is_consuming=True, consumer_tag=new_consumer_tag)
+            # 更新消费状态（设置消费者标签）
+            await self._set_consumer_tag(new_consumer_tag)
             logger.info(
                 f"消费者已启动，队列: {queue.name}, tag: {new_consumer_tag}")
             return new_consumer_tag
         except Exception as e:
             # 异常时回滚状态
-            await self._set_consume_state(is_consuming=False)
+            await self._set_consumer_tag(None)
             logger.error(f"启动消费失败: {str(e)}", exc_info=True)
             raise
 
     async def stop_consuming(self) -> None:
         """停止消费（无锁嵌套，通过原子方法获取/更新状态）"""
         # 获取消费状态和资源
-        is_consuming, _, consumer_tag = await self._get_consume_state()
+        _, _, consumer_tag = await self._get_consume_state()
         _, _, queue = await self._get_connection_resources()
 
-        if not is_consuming:
+        if not consumer_tag:  # 无消费标签说明未在消费
             logger.info("未处于消费状态，无需停止")
             return
 
         logger.info(f"开始停止消费（consumer_tag: {consumer_tag}）")
 
-        # 先更新消费状态为False
-        await self._set_consume_state(is_consuming=False)
+        # 先清除消费标签
+        await self._set_consumer_tag(None)
 
         # 取消消费者
         if consumer_tag and queue and not await self._is_closed():
@@ -781,10 +805,6 @@ class RabbitMQClient:
                     break
                 await asyncio.sleep(1)
 
-        # 清理消费状态
-        async with self._consume_state_lock:
-            self._consumer_tag = None
-
         logger.info(f"已停止消费队列: {queue.name if queue else '未知'}")
 
     async def _parse_message(self, message: AbstractIncomingMessage) -> Union[Dict[str, Any], str]:
@@ -911,21 +931,21 @@ class RabbitMQClient:
 
         # 重试检查消费状态（处理极端并发场景）
         for attempt in range(max_check_attempts):
-            is_consuming, handler, _ = await self._get_consume_state()
-            if is_consuming and handler:
+            _, handler, consumer_tag = await self._get_consume_state()
+            if consumer_tag and handler:  # 有消费标签且有处理器才继续
                 break
             if attempt < max_check_attempts - 1:
                 logger.debug(
                     f"消息 {message_id} 处理状态检查重试（第{attempt+1}次）: "
                     f"handler={'存在' if handler else '不存在'}, "
-                    f"is_consuming={is_consuming}"
+                    f"consumer_tag={'存在' if consumer_tag else '不存在'}"
                 )
                 await asyncio.sleep(check_interval)
 
         # 最终状态判断：状态异常则拒绝消息
-        is_consuming, handler, _ = await self._get_consume_state()
-        if not is_consuming or not handler:
-            err_msg = f"消息 {message_id} 拒绝处理：handler={'存在' if handler else '不存在'}, is_consuming={is_consuming}"
+        _, handler, consumer_tag = await self._get_consume_state()
+        if not consumer_tag or not handler:
+            err_msg = f"消息 {message_id} 拒绝处理：handler={'存在' if handler else '不存在'}, consumer_tag={'存在' if consumer_tag else '不存在'}"
             logger.warning(err_msg)
             try:
                 await self._handle_business_retry(message, Exception(err_msg), drop=False)

{sycommon_python_lib-0.1.36 → sycommon_python_lib-0.1.38}/src/sycommon/rabbitmq/rabbitmq_service.py

@@ -191,6 +191,13 @@ class RabbitMQService:
 
         # 使用declare_queue控制是否声明队列（发送器不声明，监听器声明）
         await client.connect(declare_queue=not is_sender)
+
+        # 监听器客户端连接后延迟1秒，确保消费状态就绪（仅首次启动）
+        if not is_sender and create_if_not_exists:
+            logger.info(
+                f"监听器客户端 '{processed_queue_name}' 连接成功，延迟1秒启动消费（解决启动时序问题）")
+            await asyncio.sleep(1)
+
         return client
 
     @classmethod
@@ -508,6 +515,11 @@ class RabbitMQService:
             logger.info("服务关闭中，取消启动消费者")
             return
 
+        # 监听器启动消费前额外延迟1秒，确保consumer_tag完全生成（不删消息）
+        if cls._has_listeners and not client_name.startswith("sender-"):
+            logger.info(f"消费者 '{client_name}' 准备启动，延迟1秒等待消费状态就绪（不删除积压消息）")
+            await asyncio.sleep(1)
+
         # 创建停止事件
         stop_event = asyncio.Event()
         cls._consumer_events[client_name] = stop_event
@@ -522,6 +534,16 @@ class RabbitMQService:
 
                 while attempt < max_attempts and not stop_event.is_set() and not cls._is_shutdown:
                     try:
+                        # 启动消费前再次校验连接和队列状态
+                        if not await client.is_connected:
+                            logger.info(f"消费者 '{client_name}' 连接断开，尝试重连")
+                            await client.connect(force_reconnect=True, declare_queue=True)
+
+                        # 确保队列已就绪
+                        _, _, queue = await client._get_connection_resources()
+                        if not queue:
+                            raise Exception("队列未初始化完成")
+
                         consumer_tag = await client.start_consuming()
                         if consumer_tag:
                             break
@@ -541,7 +563,8 @@ class RabbitMQService:
 
                 # 记录消费者标签
                 cls._consumer_tags[client_name] = consumer_tag
-                logger.info(f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}")
+                logger.info(
+                    f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}（将处理队列中所有积压消息）")
 
                 # 等待停止事件
                 await stop_event.wait()

{sycommon_python_lib-0.1.36 → sycommon_python_lib-0.1.38}/src/sycommon/synacos/nacos_service.py

@@ -47,7 +47,7 @@ class NacosService(metaclass=SingletonMeta):
             self.retry_backoff = self.nacos_config.get('retryBackoff', 1.5)
             self.max_retry_delay = self.nacos_config.get('maxRetryDelay', 30)
             self.heartbeat_interval = self.nacos_config.get(
-                'heartbeatInterval', 10)
+                'heartbeatInterval', 15)
             self.register_retry_interval = self.nacos_config.get(
                 'registerRetryInterval', 5)  # 注册重试间隔
 

{sycommon_python_lib-0.1.36 → sycommon_python_lib-0.1.38}/src/sycommon_python_lib.egg-info/PKG-INFO

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