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

sycommon/rabbitmq/rabbitmq_client.py

@@ -9,16 +9,13 @@ from aio_pika.abc import (
     AbstractQueue,
     AbstractIncomingMessage,
     ConsumerTag,
-    AbstractRobustConnection
+    AbstractRobustConnection,
 )
 from sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.models.mqmsg_model import MQMsgModel
 
 
-# 最大重试次数限制
-MAX_RETRY_COUNT = 3
-
 logger = SYLogger
 
 
@@ -27,10 +24,10 @@ class RabbitMQClient:
     RabbitMQ 客户端（支持消息发布、消费、自动重连、异常重试）
     核心特性：
     1. 基于连接池复用资源，性能优化
-    2. 连接/通道失效时自动重建，高可用
-    3. 消息发布支持重试，消费支持手动ACK/NACK
-    4. 兼容JSON/字符串/字典消息格式
-    5. 严格的协程调用规范，避免"未等待"警告
+    2. 连接/通道失效时自动重建，高可用（限制并发重连）
+    3. 消息发布支持重试+mandatory机制+超时控制，确保路由有效
+    4. 消费支持手动ACK/NACK
+    5. 兼容JSON/字符串/字典消息格式
     """
 
     def __init__(
@@ -45,7 +42,6 @@ class RabbitMQClient:
         auto_parse_json: bool = True,
         create_if_not_exists: bool = True,
         prefetch_count: int = 2,
-        # 兼容旧代码参数（无需使用）
         **kwargs,
     ):
         # 依赖注入：连接池（必须已初始化）
@@ -87,10 +83,8 @@ class RabbitMQClient:
         self._connect_lock = asyncio.Lock()
         # 跟踪连接关闭回调（用于后续移除）
         self._conn_close_callback: Optional[Callable] = None
-        # 控制重连频率的信号量（避免短时间内大量重连任务）
+        # 控制重连频率的信号量（限制并发重连数，默认1个）
         self._reconnect_semaphore = asyncio.Semaphore(1)
-        # 重连冷却时间（秒）
-        self._reconnect_cooldown = 3
         # 固定重连间隔15秒（全局统一）
         self._RECONNECT_INTERVAL = 15
         # 重连任务锁（确保同一时间只有一个重连任务）
@@ -140,7 +134,7 @@ class RabbitMQClient:
             self._conn_close_callback = None
 
             try:
-                # 从连接池获取通道+连接（连接池已控制连接数）
+                # 从连接池获取通道+连接（连接池返回的是 RobustChannel）
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
                 def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
@@ -164,7 +158,11 @@ class RabbitMQClient:
                 await self._channel.set_qos(prefetch_count=self.prefetch_count)
                 SYLogger.debug(f"设置预取计数: {self.prefetch_count}")
 
-                # 3. 声明交换机
+                # 3. 低版本 RobustChannel 说明：默认启用异步发布确认，无显式确认方法
+                SYLogger.debug(
+                    "基于 RobustChannel 异步发布确认（低版本 aio-pika 不支持显式确认方法）")
+
+                # 4. 声明交换机
                 self._exchange = await self._channel.declare_exchange(
                     name=self.exchange_name,
                     type=self.exchange_type,
@@ -175,7 +173,7 @@ class RabbitMQClient:
                 SYLogger.info(
                     f"交换机初始化成功: {self.exchange_name}（类型: {self.exchange_type.value}）")
 
-                # 4. 声明队列（如果配置了队列名）
+                # 5. 声明队列（如果配置了队列名）
                 if self.queue_name:
                     self._queue = await self._channel.declare_queue(
                         name=self.queue_name,
@@ -215,33 +213,38 @@ class RabbitMQClient:
                 raise
 
     async def _safe_reconnect(self):
-        """安全重连：固定15秒间隔，避免重复任务"""
-        # 检查是否已有重连任务在运行
-        if self._current_reconnect_task and not self._current_reconnect_task.done():
-            SYLogger.debug("已有重连任务在运行，跳过重复触发")
-            return
-
-        async with self._reconnect_task_lock:
-            if self._closed or await self.is_connected:
+        """安全重连：信号量控制并发+固定15秒间隔，避免短时间大量重连"""
+        # 1. 信号量控制：限制同时进行的重连任务数（默认1个）
+        async with self._reconnect_semaphore:
+            # 2. 检查是否已有重连任务在运行（双重保障）
+            if self._current_reconnect_task and not self._current_reconnect_task.done():
+                SYLogger.debug("已有重连任务在运行，跳过重复触发")
                 return
 
-            # 固定15秒重连间隔
-            SYLogger.info(f"将在15秒后尝试重连...")
-            await asyncio.sleep(self._RECONNECT_INTERVAL)
+            async with self._reconnect_task_lock:
+                if self._closed or await self.is_connected:
+                    SYLogger.debug("客户端已关闭或已连接，取消重连")
+                    return
 
-            if self._closed or await self.is_connected:
-                return
+                # 3. 固定15秒重连间隔（避免频繁重试）
+                SYLogger.info(f"将在15秒后尝试重连...")
+                await asyncio.sleep(self._RECONNECT_INTERVAL)
 
-            try:
-                self._current_reconnect_task = asyncio.create_task(
-                    self.connect())
-                await self._current_reconnect_task
-            except Exception as e:
-                SYLogger.warning(f"重连失败: {str(e)}")
-                # 重连失败后，继续触发下一次重连（仍保持15秒间隔）
-                asyncio.create_task(self._safe_reconnect())
-            finally:
-                self._current_reconnect_task = None
+                if self._closed or await self.is_connected:
+                    SYLogger.debug("重连等待期间客户端状态变化，取消重连")
+                    return
+
+                try:
+                    # 4. 执行重连
+                    SYLogger.info("开始重连RabbitMQ客户端...")
+                    self._current_reconnect_task = asyncio.create_task(
+                        self.connect())
+                    await self._current_reconnect_task
+                except Exception as e:
+                    SYLogger.warning(f"重连失败: {str(e)}")
+                    # 重连失败后，不主动触发下一次（等待连接关闭回调再次触发，避免死循环）
+                finally:
+                    self._current_reconnect_task = None
 
     async def set_message_handler(
         self,
@@ -315,7 +318,7 @@ class RabbitMQClient:
                     # 检查连接状态，失效则触发重连
                     if not await self.is_connected:
                         SYLogger.warning("连接已失效，触发客户端重连")
-                        asyncio.create_task(self.connect())
+                        asyncio.create_task(self._safe_reconnect())
 
             # 3. 启动消费
             self._consumer_tag = await self._queue.consume(consume_callback)
@@ -345,7 +348,7 @@ class RabbitMQClient:
         retry_count: int = 3,
     ) -> None:
         """
-        发布消息（支持自动重试、JSON序列化）
+        发布消息（支持自动重试、mandatory路由校验、5秒超时控制）
         :param message_body: 消息体（字符串/字典/MQMsgModel）
         :param headers: 消息头（可选）
         :param content_type: 内容类型（默认application/json）
@@ -387,33 +390,53 @@ class RabbitMQClient:
                     SYLogger.warning(f"发布消息前连接失效，触发重连（retry: {retry}）")
                     await self.connect()
 
-                # 发布消息
-                await self._exchange.publish(
+                # 核心：发布消息（添加 mandatory=True 和 timeout=5.0）
+                publish_result = await self._exchange.publish(
                     message=message,
                     routing_key=self.routing_key or self.queue_name or "#",
+                    mandatory=True,  # 强制路由到至少一个队列，否则返回None
+                    timeout=5.0      # 5秒超时控制，避免无限阻塞
                 )
+
+                # 处理 mandatory=True 结果：未路由到队列返回 None，直接抛出异常
+                if publish_result is None:
+                    raise RuntimeError(
+                        f"消息未找到匹配的队列（routing_key: {self.routing_key}），mandatory=True 触发失败"
+                    )
+
+                # 低版本 RobustChannel 异步确认，无需显式等待，仅日志说明
                 SYLogger.info(
                     f"消息发布成功（retry: {retry}），routing_key: {self.routing_key}，"
-                    f"delivery_mode: {delivery_mode.value}"
+                    f"delivery_mode: {delivery_mode.value}，mandatory: True，timeout: 5.0s"
                 )
                 return
+            except asyncio.TimeoutError:
+                SYLogger.error(
+                    f"消息发布超时（retry: {retry}/{retry_count-1}），超时时间: 5.0s"
+                )
+            except RuntimeError as e:
+                # 捕获 mandatory 未路由等业务异常
+                SYLogger.error(
+                    f"消息发布业务失败（retry: {retry}/{retry_count-1}）: {str(e)}"
+                )
             except Exception as e:
                 SYLogger.error(
                     f"消息发布失败（retry: {retry}/{retry_count-1}）: {str(e)}",
                     exc_info=True
                 )
-                # 清理失效状态，下次重试时重连
+                # 清理失效状态，下次重试重连
                 self._exchange = None
-                # 重试间隔（指数退避）
-                await asyncio.sleep(0.5 * (2 ** retry))
+            # 指数退避重试间隔（0.5s, 1s, 2s...）
+            await asyncio.sleep(0.5 * (2 ** retry))
 
-        # 所有重试失败，抛出异常
+        # 所有重试失败，抛出最终异常
         raise RuntimeError(
-            f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}"
+            f"消息发布失败（已重试{retry_count}次），routing_key: {self.routing_key}，"
+            f"mandatory: True，timeout: 5.0s"
         )
 
     async def close(self) -> None:
-        """关闭客户端（移除回调）"""
+        """关闭客户端（移除回调+释放资源）"""
         self._closed = True
         SYLogger.info("开始关闭RabbitMQ客户端...")
 

sycommon/synacos/nacos_service.py

@@ -35,7 +35,7 @@ class NacosService(metaclass=SingletonMeta):
 
             # 配置参数
             self.max_retries = self.nacos_config.get('maxRetries', 5)
-            self.retry_delay = self.nacos_config.get('retryDelay', 1)
+            self.retry_delay = self.nacos_config.get('retryDelay', 5)
             self.max_retry_delay = self.nacos_config.get('maxRetryDelay', 30)
             # 心跳间隔：优先从配置读取，默认15秒（可通过配置修改）
             self.heartbeat_interval = self.nacos_config.get(
@@ -51,11 +51,13 @@ class NacosService(metaclass=SingletonMeta):
             self.max_long_term_retries = self.nacos_config.get(
                 'maxLongTermRetries', -1)  # -1表示无限重试
 
-            # 注册验证配置
+            # 注册验证配置：优化默认值（增加次数+延长间隔）
             self.registration_verify_count = self.nacos_config.get(
                 'registrationVerifyCount', 1)  # 验证次数
             self.registration_verify_interval = self.nacos_config.get(
                 'registrationVerifyInterval', 1)  # 验证间隔
+            self.registration_post_delay = self.nacos_config.get(
+                'registrationPostDelay', 3)  # 注册后延迟3秒再开始验证
 
             self.real_ip = self.get_service_ip(self.host)
             self._long_term_retry_count = 0  # 长期重试计数器
@@ -300,12 +302,12 @@ class NacosService(metaclass=SingletonMeta):
                 if not register_success:
                     raise RuntimeError("nacos:服务注册请求失败")
 
-                # 注册请求发送成功后，等待一小段时间让Nacos服务器处理
+                # 关键优化1：注册请求发送后，延迟一段时间再验证（默认3秒）
                 SYLogger.info(
-                    f"nacos:服务注册请求已发送，等待 {self.registration_verify_interval} 秒后验证")
-                time.sleep(self.registration_verify_interval)
+                    f"nacos:服务注册请求已发送，延迟 {self.registration_post_delay} 秒后开始验证（确保Nacos服务器完成实例写入）")
+                time.sleep(self.registration_post_delay)
 
-                # 多次验证服务是否真正注册成功
+                # 关键优化2：多次验证服务是否真正注册成功（默认3次，每次间隔2秒）
                 registered = self.verify_registration()
 
                 # 带锁更新注册状态

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

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

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

@@ -35,7 +35,7 @@ sycommon/models/mqlistener_config.py,sha256=vXp2uMmd0XQ5B9noSRXWHewTy-juQ2y7IsWt
 sycommon/models/mqmsg_model.py,sha256=cxn0M5b0utQK6crMYmL-1waeGYHvK3AlGaRy23clqTE,277
 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_client.py,sha256=dKpiptV892VbW3fErAoRZSE9UVVBZvbVPM3qPu8rQIk,21573
 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
@@ -46,14 +46,14 @@ sycommon/synacos/example.py,sha256=61XL03tU8WTNOo3FUduf93F2fAwah1S0lbH1ufhRhRk,5
 sycommon/synacos/example2.py,sha256=adUaru3Hy482KrOA17DfaC4nwvLj8etIDS_KrWLWmCU,4811
 sycommon/synacos/feign.py,sha256=-2tuGCqoSM3ddSoSz7h1RJTB06hn8K26v_1ev4qLsTU,7728
 sycommon/synacos/feign_client.py,sha256=JxzxohrsscQNlAjRVo_3ZQrMQSfVHFOtRYyEnP6sDGk,15205
-sycommon/synacos/nacos_service.py,sha256=Hxd3fQOR53iujUjCboJoQum5vAXxQ9sdc8YlDug1OF0,35092
+sycommon/synacos/nacos_service.py,sha256=2m1ZxIii3r657kQJfp7C7I5bxBUEGDweYMfloUUmBSw,35389
 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.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,,
+sycommon_python_lib-0.1.45.dist-info/METADATA,sha256=z1pOqekth0xbqc4RfCkk5CHHm3b4FS4R0Tcy3BxUYus,7037
+sycommon_python_lib-0.1.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.45.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.45.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.45.dist-info/RECORD,,