sycommon-python-lib 0.1.59__py3-none-any.whl → 0.2.0b1__py3-none-any.whl

sycommon/notice/uvicorn_monitor.py

@@ -1,10 +1,9 @@
-from datetime import datetime
 import sys
 import traceback
 import aiohttp
 import asyncio
-import json
 from typing import Optional
+from datetime import datetime
 from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
 from sycommon.config.Config import Config
 from sycommon.logging.kafka_log import SYLogger
@@ -16,19 +15,7 @@ async def send_wechat_markdown_msg(
 ) -> Optional[dict]:
     """
     异步发送企业微信Markdown格式的WebHook消息
-
-    Args:
-        content: Markdown格式的消息内容（支持企业微信支持的markdown语法）
-        webhook: 完整的企业微信WebHook URL（默认值包含key）
-
-    Returns:
-        接口返回的JSON数据（dict），失败返回None
     """
-    # 设置请求头
-    headers = {
-        "Content-Type": "application/json; charset=utf-8"
-    }
-
     # 构造请求体（Markdown格式）
     payload = {
         "msgtype": "markdown",
@@ -38,54 +25,54 @@ async def send_wechat_markdown_msg(
     }
 
     try:
+        # 使用 json 参数自动处理序列化和 Content-Type
         async with aiohttp.ClientSession() as session:
             async with session.post(
                 url=webhook,
-                data=json.dumps(payload, ensure_ascii=False),
-                headers=headers,
+                json=payload,
                 timeout=aiohttp.ClientTimeout(total=10)
             ) as response:
-                status = response.status
-                response_text = await response.text()
-                response_data = json.loads(
-                    response_text) if response_text else {}
+                response_data = await response.json()
 
-                if status == 200 and response_data.get("errcode") == 0:
+                if response.status == 200 and response_data.get("errcode") == 0:
                     SYLogger.info(f"消息发送成功: {response_data}")
                     return response_data
                 else:
-                    SYLogger.info(
-                        f"消息发送失败 - 状态码: {status}, 响应: {response_data}")
+                    SYLogger.warning(
+                        f"消息发送失败 - 状态码: {response.status}, 响应: {response_data}")
                     return None
     except Exception as e:
-        SYLogger.info(f"错误：未知异常 - {str(e)}")
+        SYLogger.error(f"发送企业微信消息异常: {str(e)}")
         return None
 
 
 async def send_webhook(error_info: dict = None, webhook: str = None):
     """
     发送服务启动结果的企业微信通知
-    Args:
-        error_info: 错误信息字典（启动失败时必填），包含：error_type, error_msg, stack_trace, elapsed_time
-        webhook: 完整的企业微信WebHook URL（覆盖默认值）
     """
-    # 获取服务名和环境（兼容配置读取失败）
+    # 获取服务名和环境（增加默认值保护）
     try:
-        service_name = Config().config.get('Name', "未知服务")
-        env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
-        webHook = Config().config.get('llm', {}).get('WebHook', '未知环境')
+        config = Config().config
+        service_name = config.get('Name', "未知服务")
+        env = config.get('Nacos', {}).get('namespaceId', '未知环境')
+        # 注意：这里使用了大写开头的 WebHook，请确保配置文件中键名一致
+        webHook = config.get('llm', {}).get('WebHook')
     except Exception as e:
         service_name = "未知服务"
         env = "未知环境"
         webHook = None
-        SYLogger.info(f"读取配置失败: {str(e)}")
+        SYLogger.warning(f"读取配置失败: {str(e)}")
 
     start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
 
+    # 如果没有错误信息，就不发送失败告警
+    if not error_info:
+        return
+
     # 启动失败的通知内容（包含详细错误信息）
     error_type = error_info.get("error_type", "未知错误")
     error_msg = error_info.get("error_msg", "无错误信息")
-    stack_trace = error_info.get("stack_trace", "无堆栈信息")[:500]  # 限制长度避免超限
+    stack_trace = error_info.get("stack_trace", "无堆栈信息")[:1000]  # 适当增加长度限制
     elapsed_time = error_info.get("elapsed_time", 0)
 
     markdown_content = f"""### {service_name}服务启动失败告警 ⚠️
@@ -103,22 +90,20 @@ async def send_webhook(error_info: dict = None, webhook: str = None):
         )
         SYLogger.info(f"通知发送结果: {result}")
     else:
-        SYLogger.info("未设置企业微信WebHook")
+        SYLogger.info("未设置企业微信WebHook，跳过告警发送")
 
 
 def run(*args, webhook: str = None, **kwargs):
     """
     带企业微信告警的Uvicorn启动监控
-    调用方式1（默认配置）：uvicorn_monitor.run("app:app", **app.state.config)
-    调用方式2（自定义webhook）：uvicorn_monitor.run("app:app", webhook="完整URL", **app.state.config)
-
-    Args:
-        *args: 传递给uvicorn.run的位置参数（如"app:app"）
-        webhook: 完整的企业微信WebHook URL（可选，覆盖默认值）
-        **kwargs: 传递给uvicorn.run的关键字参数（如app.state.config）
     """
     # 判断环境
-    env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
+    try:
+        env = Config().config.get('Nacos', {}).get('namespaceId', 'dev')
+    except:
+        env = 'dev'
+
+    # 如果是生产环境，通常不需要这种启动脚本进行告警干扰，或者你需要根据实际情况调整
     if env == "prod":
         import uvicorn
         uvicorn.run(*args, **kwargs)
@@ -128,42 +113,44 @@ def run(*args, webhook: str = None, **kwargs):
     start_time = datetime.now()
 
     if webhook:
-        # 脱敏展示webhook（隐藏key的后半部分）
-        parsed = urlparse(webhook)
-        query = parse_qs(parsed.query)
-        if 'key' in query and query['key'][0]:
-            key = query['key'][0]
-            masked_key = key[:8] + "****" if len(key) > 8 else key + "****"
-            query['key'] = [masked_key]
-            masked_query = urlencode(query, doseq=True)
-            masked_webhook = urlunparse(
-                (parsed.scheme, parsed.netloc, parsed.path, parsed.params, masked_query, parsed.fragment))
-            SYLogger.info(f"自定义企业微信WebHook: {masked_webhook}")
+        # 脱敏展示webhook
+        try:
+            parsed = urlparse(webhook)
+            query = parse_qs(parsed.query)
+            if 'key' in query and query['key'][0]:
+                key = query['key'][0]
+                masked_key = key[:8] + "****" if len(key) > 8 else key + "****"
+                query['key'] = [masked_key]
+                masked_query = urlencode(query, doseq=True)
+                masked_webhook = urlunparse(
+                    (parsed.scheme, parsed.netloc, parsed.path, parsed.params, masked_query, parsed.fragment))
+                SYLogger.info(f"自定义企业微信WebHook: {masked_webhook}")
+        except Exception:
+            SYLogger.info("自定义Webhook格式解析失败，但会尝试使用")
 
     # 初始化错误信息
     error_info = None
 
     try:
         import uvicorn
-        # 执行启动（如果启动成功，此方法会阻塞，不会执行后续except）
+        # 执行启动
         uvicorn.run(*args, **kwargs)
 
     except KeyboardInterrupt:
-        # 处理用户手动中断（不算启动失败）
+        # 处理用户手动中断
         elapsed = (datetime.now() - start_time).total_seconds()
         SYLogger.info(f"\n{'='*50}")
         SYLogger.info(f"ℹ️  应用被用户手动中断")
         SYLogger.info(f"启动耗时: {elapsed:.2f} 秒")
         SYLogger.info(f"{'='*50}\n")
+        # 手动中断不需要错误告警，也不需要 sys.exit(1)
         sys.exit(0)
 
     except Exception as e:
-        # 捕获启动失败异常，收集错误信息
+        # 捕获启动失败异常
         elapsed = (datetime.now() - start_time).total_seconds()
-        # 捕获堆栈信息
         stack_trace = traceback.format_exc()
 
-        # 构造错误信息字典
         error_info = {
             "error_type": type(e).__name__,
             "error_msg": str(e),
@@ -171,30 +158,31 @@ def run(*args, webhook: str = None, **kwargs):
             "elapsed_time": elapsed
         }
 
-        # 打印错误信息
-        SYLogger.info(f"\n{'='*50}")
-        SYLogger.info(f"🚨 应用启动失败！")
-        SYLogger.info(f"失败时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        SYLogger.info(f"错误类型: {type(e).__name__}")
-        SYLogger.info(f"错误信息: {str(e)}")
-        SYLogger.info(f"\n📝 错误堆栈（关键）:")
-        SYLogger.info(f"-"*50)
+        # 打印详细错误
+        SYLogger.error(f"\n{'='*50}")
+        SYLogger.error(f"🚨 应用启动失败！")
+        SYLogger.error(f"失败时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        SYLogger.error(f"错误类型: {type(e).__name__}")
+        SYLogger.error(f"错误信息: {str(e)}")
+        SYLogger.error(f"\n📝 错误堆栈:")
+        SYLogger.error(f"-"*50)
         traceback.print_exc(file=sys.stdout)
-        SYLogger.info(f"\n⏱️  启动耗时: {elapsed:.2f} 秒")
-        SYLogger.info(f"{'='*50}\n")
+        SYLogger.error(f"\n⏱️  启动耗时: {elapsed:.2f} 秒")
+        SYLogger.error(f"{'='*50}\n")
 
     finally:
-        # 运行异步通知函数，传递自定义的webhook参数
-        try:
-            asyncio.run(send_webhook(
-                error_info=error_info,
-                webhook=webhook
-            ))
-        except Exception as e:
-            SYLogger.info(f"错误：异步通知失败 - {str(e)}")
-        # 启动失败时退出程序
-        sys.exit(1)
-
-
-# 兼容旧调用方式（可选）
-run_uvicorn_with_monitor = run
+        # 创建新的事件循环来发送通知，防止与 Uvicorn 的循环冲突
+        if error_info:
+            try:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                loop.run_until_complete(send_webhook(
+                    error_info=error_info,
+                    webhook=webhook
+                ))
+                loop.close()
+            except Exception as e:
+                SYLogger.error(f"错误：异步通知发送失败 - {str(e)}")
+
+            # 只有确实有错误时才以状态码 1 退出
+            sys.exit(1)

sycommon/rabbitmq/rabbitmq_client.py

@@ -117,37 +117,37 @@ class RabbitMQClient:
             logger.info(f"队列重建成功: {self.queue_name}")
 
     async def connect(self) -> None:
-        """连接方法（修复恢复消费失效问题）"""
+        """连接方法（消费者独立通道 + 移除无效属性检查 + 强制重建队列）"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
-        # 1. 获取 Condition 锁
+        # 1. 获取 Condition 锁，用于管理连接并发和等待
         await self._connect_condition.acquire()
 
         try:
-            # ===== 阶段 A: 快速检查与等待 =====
+            # ===== 阶段 A: 检查状态与排队 =====
             if await self.is_connected:
-                self._connect_condition.release()
+                if self._connect_condition.locked():
+                    self._connect_condition.release()
                 return
 
+            # 如果已有协程正在连接，等待其完成
             if self._connecting:
                 try:
                     logger.debug("连接正在进行中，等待现有连接完成...")
                     await asyncio.wait_for(self._connect_condition.wait(), timeout=60.0)
                 except asyncio.TimeoutError:
-                    self._connect_condition.release()
-                    raise RuntimeError("等待连接超时")
+                    logger.warning("等待前序连接超时，当前协程将尝试强制接管并重连...")
 
+                # 唤醒后再次检查状态，防止重复连接
                 if await self.is_connected:
-                    self._connect_condition.release()
+                    if self._connect_condition.locked():
+                        self._connect_condition.release()
                     return
-                else:
-                    self._connect_condition.release()
-                    raise RuntimeError("等待重连后，连接状态依然无效")
 
-            # ===== 阶段 B: 标记开始连接 =====
+            # ===== 阶段 B: 标记开始连接并释放锁 =====
+            # 释放锁是为了让耗时的连接过程不阻塞其他协程
             self._connecting = True
-            # 【关键】释放锁，允许其他协程进入等待逻辑
             self._connect_condition.release()
 
         except Exception as e:
@@ -155,13 +155,19 @@ class RabbitMQClient:
                 self._connect_condition.release()
             raise
 
-        # === 阶段 C: 执行耗时的连接逻辑 (此时已释放锁，不阻塞其他协程) ===
+        # === 阶段 C: 执行耗时的连接逻辑 (无锁状态) ===
+        connection_failed = False
+        was_consuming = False
+
+        # 判断当前是否为消费者模式（通过是否有消息处理函数判断）
+        is_consumer = self._message_handler is not None
+        old_channel = self._channel
+
         try:
-            # --- 步骤 1: 记录旧状态并清理资源 ---
-            # 必须在清理前记录状态
+            # --- 步骤 1: 记录状态并清理旧资源 ---
             was_consuming = self._consumer_tag is not None
 
-            # 清理连接回调，防止旧的连接关闭触发新的重连
+            # 清理旧连接的 close_callbacks，防止重连触发多次
             if self._channel_conn:
                 try:
                     if self._channel_conn.close_callbacks:
@@ -169,60 +175,125 @@ class RabbitMQClient:
                 except Exception:
                     pass
 
-            # 统一重置资源状态
+            # 显式关闭旧 Channel
+            # 注意：无论是生产者复用的主通道，还是消费者的独立通道，断开时都应显式关闭以释放服务端资源
+            if old_channel and not old_channel.is_closed:
+                try:
+                    await old_channel.close()
+                except Exception:
+                    pass
+
+            # 【修复点】强制重置所有核心资源引用
+            # 因为我们即将获取一个新的 Channel，旧的 Exchange 和 Queue 对象（基于旧 Channel）将全部失效。
+            # 必须置为 None，强制后续逻辑基于新 Channel 重建这些对象。
             self._channel = None
             self._channel_conn = None
             self._exchange = None
             self._queue = None
             self._consumer_tag = None
 
-            # --- 步骤 2: 获取新连接 ---
-            self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
+            # --- 步骤 2: 根据角色获取新连接 ---
+            # 生产者：复用连接池的主通道（性能高）
+            # 消费者：从连接池获取独立的通道（稳定性高，避免并发冲突）
+            if is_consumer:
+                logger.debug("获取消费者独立通道...")
+                self._channel = await self.connection_pool.acquire_consumer_channel()
+                self._channel_conn = self.connection_pool._connection
+            else:
+                logger.debug("获取生产者主通道...")
+                self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
+
+            # --- 步骤 3: 设置连接关闭回调 ---
+            loop = asyncio.get_running_loop()
 
-            # 设置连接关闭回调
             def on_conn_closed(conn, exc):
+                if self._closed:
+                    return
                 logger.warning(f"检测到底层连接关闭: {exc}")
-                if not self._closed and not self._connecting:
-                    asyncio.create_task(self._safe_reconnect())
+                # 确保在循环中安全调用协程
+                asyncio.run_coroutine_threadsafe(self._safe_reconnect(), loop)
 
             if self._channel_conn:
                 self._channel_conn.close_callbacks.add(on_conn_closed)
 
-            # --- 步骤 3: 重建基础资源 (交换机和队列) ---
+            # --- 步骤 4: 重建基础资源 ---
+            # 这会在新的 self._channel 上声明 Exchange 和 Queue，并执行绑定
             await self._rebuild_resources()
 
-            # --- 步骤 4: 恢复消费 ---
-            if was_consuming and self._message_handler:
-                logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
-                try:
-                    # 直接调用 start_consuming 来恢复，它内部包含了完整的队列检查和绑定逻辑
-                    self._consumer_tag = await self.start_consuming()
-                    logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
-                except Exception as e:
-                    logger.error(f"❌ 自动恢复消费失败: {e}")
-                    self._consumer_tag = None
-
-            logger.info("客户端连接初始化完成")
-
         except Exception as e:
+            connection_failed = True
             logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
-            # 异常时彻底清理
+
+            # 发生异常时清理引用
             if self._channel_conn and self._channel_conn.close_callbacks:
                 self._channel_conn.close_callbacks.clear()
+
             self._channel = None
             self._channel_conn = None
+            self._exchange = None
             self._queue = None
             self._consumer_tag = None
+
             raise
 
         finally:
-            # === 阶段 D: 恢复状态并通知 ===
-            await self._connect_condition.acquire()
+            # === 阶段 D: 恢复消费与收尾 (重新加锁) ===
             try:
+                await self._connect_condition.acquire()
+            except Exception:
+                pass
+
+            try:
+                # 只有连接完全成功，且之前处于消费状态，才尝试自动恢复消费
+                if not connection_failed and was_consuming and self._message_handler:
+                    logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
+
+                    # 【修复核心】
+                    # 由于在步骤 1 中 self._queue 已被置为 None，
+                    # 如果 _rebuild_resources 因为某种原因（例如配置条件）没有成功创建队列，
+                    # 这里需要再次尝试在当前新 Channel 上创建并绑定队列。
+                    # 不再检查 is_closed（因为该属性不存在），直接检查是否为 None。
+
+                    if self.queue_name and not self._queue:
+                        try:
+                            logger.info(f"重连恢复过程中重新声明队列: {self.queue_name}")
+                            # 在当前新 Channel 上声明队列
+                            self._queue = await self._channel.declare_queue(
+                                name=self.queue_name,
+                                durable=self.durable,
+                                auto_delete=self.auto_delete,
+                                passive=not self.create_if_not_exists,
+                            )
+
+                            # 【关键步骤】显式绑定队列
+                            # 即使队列已存在，也必须在新 Channel 上重新绑定，否则服务端路由状态可能不更新
+                            if self._exchange:
+                                await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
+                                logger.info(
+                                    f"✅ 重连绑定成功: {self.queue_name} -> {self.routing_key}")
+                        except Exception as bind_err:
+                            logger.error(f"❌ 重连恢复队列/绑定失败: {bind_err}")
+                            # 绑定失败，无法恢复消费
+                            self._queue = None
+
+                    # 队列对象有效才启动消费
+                    if self._queue:
+                        try:
+                            self._consumer_tag = await self.start_consuming()
+                            logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
+                        except Exception as e:
+                            logger.error(f"❌ 自动恢复消费失败: {e}")
+                            self._consumer_tag = None
+                    else:
+                        logger.warning("⚠️ 队列对象无效，无法恢复消费")
+
+            finally:
+                # 最终状态复位
                 self._connecting = False
                 self._connect_condition.notify_all()
-            finally:
-                self._connect_condition.release()
+
+                if self._connect_condition.locked():
+                    self._connect_condition.release()
 
     async def _safe_reconnect(self):
         """安全重连任务（仅用于被动监听连接关闭）"""
@@ -313,6 +384,11 @@ class RabbitMQClient:
             self._consumer_tag = None
 
     async def _handle_publish_failure(self):
+        # 如果当前正在重连，或者已经关闭，直接返回，避免冲突
+        if self._connecting or self._closed:
+            logger.warning("⚠️ 正在重连或已关闭，跳过故障转移触发")
+            return
+
         try:
             logger.info("检测到发布异常，强制连接池切换节点...")
             await self.connection_pool.force_reconnect()
@@ -387,9 +463,12 @@ class RabbitMQClient:
         raise RuntimeError(f"消息发布最终失败: {last_exception}")
 
     async def close(self) -> None:
+        """关闭客户端（支持独立通道的清理与死锁修复）"""
+        # 1. 先标记关闭
         self._closed = True
         logger.info("开始关闭RabbitMQ客户端...")
 
+        # 2. 取消可能存在的后台重连任务
         if self._current_reconnect_task and not self._current_reconnect_task.done():
             self._current_reconnect_task.cancel()
             try:
@@ -397,21 +476,53 @@ class RabbitMQClient:
             except asyncio.CancelledError:
                 pass
 
+        # 3. 停止消费
         await self.stop_consuming()
 
-        async with self._connect_lock:
-            if self._conn_close_callback and self._channel_conn:
-                self._channel_conn.close_callbacks.discard(
-                    self._conn_close_callback)
+        # 4. 处理 _connect_condition 锁
+        try:
+            await asyncio.wait_for(self._connect_condition.acquire(), timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning("获取连接锁超时，强制清理资源...")
+
+        try:
+            # 清理回调
+            if self._channel_conn:
+                try:
+                    if self._channel_conn.close_callbacks:
+                        self._channel_conn.close_callbacks.clear()
+                except Exception:
+                    pass
+
+            # 【关键修改】显式关闭持有的通道
+            # 无论是生产者（主通道，但 Client 只是持有者，通常不关 Pool 管理的主通道），
+            # 还是消费者（独立通道，必须显式关闭），这里都需要处理。
+            # 由于我们引入了独立消费者通道，这里必须显式关闭 self._channel
+            if self._channel and not self._channel.is_closed:
+                try:
+                    # 注意：如果是主通道，这里关闭可能会影响其他 Producer。
+                    # 但由于我们的架构中，Consumer 用独立通道，这里大概率是 Consumer 关闭。
+                    # 为了安全，可以增加判断：如果 shared_channel 标志为 False 才关？
+                    # 简化策略：统一关闭，因为 Client 被销毁意味着不再需要该通道。
+                    await self._channel.close()
+                    logger.debug("客户端通道已关闭")
+                except Exception as e:
+                    logger.warning(f"关闭客户端通道异常: {e}")
 
+            # 置空资源引用
             self._channel = None
             self._channel_conn = None
             self._exchange = None
             self._queue = None
             self._message_handler = None
+            self._conn_close_callback = None
 
-            # 确保唤醒可能正在等待 connect 的任务
+        finally:
+            # 强制重置状态并唤醒所有等待者
             self._connecting = False
             self._connect_condition.notify_all()
 
+            if self._connect_condition.locked():
+                self._connect_condition.release()
+
         logger.info("客户端已关闭")

sycommon/rabbitmq/rabbitmq_pool.py

@@ -141,21 +141,38 @@ class RabbitMQConnectionPool:
 
     async def _ensure_main_channel(self) -> RobustChannel:
         """
-        确保主通道有效
-        修复逻辑：
-        1. 如果连接对象不存在或已关闭 -> 重建连接
-        2. 如果连接对象存在但处于重连中 -> 等待其 ready
-        3. 如果通道不存在或已关闭 -> 重建通道
+        确保主通道有效 (修复：将探活逻辑移入锁内，防止死锁)
         """
-        async with self._lock:
+        async with self._lock:  # 持有锁贯穿整个方法
             if self._is_shutdown:
                 raise RuntimeError("客户端已关闭")
 
-            # --- 阶段A：连接恢复逻辑 ---
-            if self._connection is None or self._connection.is_closed:
-                # 情况1：连接对象不存在，或已显式关闭 -> 走清理重连流程
+            # --- 阶段 A: 连接检查与重建 ---
+            connection_is_dead = False
+            if self._connection is None:
+                connection_is_dead = True
+            else:
+                try:
+                    if self._connection.is_closed:
+                        connection_is_dead = True
+                    else:
+                        # 【修复】显式探活，保持在锁内
+                        # 这样如果探活失败，可以直接在锁内进入重建流程，无需重新竞争锁
+                        try:
+                            await asyncio.wait_for(self._connection.connect(timeout=1), timeout=15)
+                        except Exception:
+                            logger.warning("⚠️ 连接探活失败，判定为死连接，强制重建...")
+                            connection_is_dead = True
+                except Exception:
+                    connection_is_dead = True
+
+            # 如果连接死掉，执行清理和重建
+            if connection_is_dead:
                 await self._cleanup_resources()
+                # ... (重建连接逻辑保持不变: 遍历 hosts -> connect_robust -> 赋值 self._connection) ...
+                # 确保重建成功，否则抛出异常
 
+                # 为了代码完整性，这里补全重建逻辑的核心部分（基于你之前的代码）
                 retry_hosts = self.hosts.copy()
                 random.shuffle(retry_hosts)
                 last_error = None
@@ -164,110 +181,110 @@ class RabbitMQConnectionPool:
                 for _ in range(max_attempts):
                     if not retry_hosts:
                         break
-
                     host = retry_hosts.pop()
                     self._current_host = host
                     temp_conn = None
-
                     try:
-                        temp_conn = await self._create_connection_impl(host)
+                        conn_url = (
+                            f"amqp://{self.username}:{self.password}@{host}:{self.port}/"
+                            f"{self.virtualhost}?name={self.app_name}&heartbeat={self.heartbeat}"
+                            f"&reconnect_interval={self.reconnect_interval}&fail_fast=1"
+                        )
+                        temp_conn = await asyncio.wait_for(
+                            connect_robust(conn_url),
+                            timeout=self.connection_timeout + 5
+                        )
                         self._connection = temp_conn
-                        temp_conn = None
                         self._initialized = True
                         last_error = None
-                        logger.info(f"🔗 [RECONNECT_OK] 切换到节点: {host}")
+                        logger.info(f"✅ [CONNECT_OK] 新连接建立成功: {host}")
                         break
                     except Exception as e:
-                        logger.warning(f"⚠️ [RECONNECT_RETRY] 节点 {host} 不可用")
-                        if temp_conn is not None:
+                        logger.warning(
+                            f"⚠️ [RECONNECT_RETRY] 节点 {host} 连接失败: {e}")
+                        if temp_conn:
                             try:
                                 await temp_conn.close()
-                            except Exception:
+                            except:
                                 pass
                         last_error = e
                         await asyncio.sleep(self.reconnect_interval)
 
                 if last_error:
-                    self._connection = None
-                    self._initialized = False
-                    logger.error("💥 [RECONNECT_FATAL] 所有节点重试失败")
                     raise ConnectionError("所有 RabbitMQ 节点连接失败") from last_error
-            else:
-                # 情况2：连接对象存在，但可能处于“连接丢失，正在重连”的状态
-                # 【关键修复】显式调用 connect() 确保连接真正就绪
-                # 如果连接已经好，这会立即返回；如果正在重连，这会等待完成
-                try:
-                    logger.debug(f"⏳ [WAIT_CONN] 等待连接就绪...")
-                    await self._connection.connect(timeout=5)  # 设置一个短暂超时避免卡死太久
-                    logger.debug(f"✅ [WAIT_CONN_OK] 连接已就绪")
-                except asyncio.TimeoutError:
-                    logger.warning("⚠️ [WAIT_CONN_TIMEOUT] 等待连接就绪超时，强制重连")
-                    await self._cleanup_resources()
-                    raise
-                except Exception as e:
-                    logger.error(f"❌ [WAIT_CONN_FAIL] 连接不可用: {e}")
-                    await self._cleanup_resources()
-                    raise
 
-            # --- 阶段B：通道恢复逻辑 ---
+            # --- 阶段 B: 通道恢复逻辑 ---
+            # 此时 self._connection 必须是有效的
             if self._channel is None or self._channel.is_closed:
+                max_channel_attempts = 2
+                for attempt in range(max_channel_attempts):
+                    try:
+                        self._channel = await self._connection.channel()
+                        await self._channel.set_qos(prefetch_count=self.prefetch_count)
+                        logger.info(f"✅ [CHANNEL_OK] 主通道已就绪")
+                        break
+                    except Exception as e:
+                        logger.warning(
+                            f"⚠️ [CHANNEL_RETRY] 第 {attempt + 1} 次尝试创建通道失败: {e}")
+                        if attempt < max_channel_attempts - 1:
+                            await self._cleanup_resources()  # 通道失败导致连接可能也坏了，重置
+                            # 简单重试逻辑：这里抛出异常让外层重试，或者在这里递归调用
+                            # 鉴于复杂度，建议抛出异常
+                            raise e
+                        else:
+                            raise e
+            else:
+                # 通道存在，进行一次轻量级探活 (保持一致性)
                 try:
-                    # 只有在确保连接有效后，才创建通道
+                    await self._channel.set_qos(prefetch_count=self.prefetch_count)
+                except Exception:
+                    logger.warning("⚠️ 通道探活失败，重建通道...")
                     self._channel = await self._connection.channel()
                     await self._channel.set_qos(prefetch_count=self.prefetch_count)
-                    logger.info(f"✅ [CHANNEL_OK] 主通道已恢复")
-                except Exception as e:
-                    logger.error(f"❌ [CHANNEL_FAIL] 通道创建失败: {e}")
-                    # 如果连通道都创建不了，说明连接状态有问题，回滚清理
-                    await self._cleanup_resources()
-                    raise
 
             return self._channel
 
     async def init_pools(self):
         """初始化入口"""
-        async with self._lock:
-            if self._is_shutdown:
-                raise RuntimeError("客户端已关闭")
-            if self._initialized:
-                return
+        # 快速检查
+        if self._initialized:
+            return
 
-        # 在 try 之前声明变量，确保 except 块能访问
         conn_created_in_this_try = None
 
         try:
             # 锁外创建连接，减少锁持有时间
             init_host = random.choice(self.hosts)
             conn = await self._create_connection_impl(init_host)
-
-            # 记录本次创建的连接
             conn_created_in_this_try = conn
 
             async with self._lock:
                 if self._is_shutdown:
                     raise RuntimeError("客户端已关闭")
 
+                # 双重检查：防止在锁外等待时，状态已改变或被其他协程初始化
+                if self._initialized:
+                    logger.info("🚀 [INIT_SKIP] 其他协程已完成初始化")
+                    if conn_created_in_this_try:
+                        await conn_created_in_this_try.close()
+                    return
+
                 # 提交新资源
                 self._connection = conn
                 self._channel = await self._connection.channel()
                 await self._channel.set_qos(prefetch_count=self.prefetch_count)
                 self._initialized = True
 
-                # 所有权转移成功，清空临时引用，防止 finally 重复关闭
                 conn_created_in_this_try = None
-
                 logger.info(f"🚀 [INIT_OK] 连接池初始化完成: {init_host}")
 
         except Exception as e:
             logger.error(f"💥 [INIT_FAIL] 初始化异常: {str(e)}")
-
-            # 这里现在可以合法访问 conn_created_in_this_try
             if conn_created_in_this_try is not None:
                 try:
                     await conn_created_in_this_try.close()
                 except Exception:
                     pass
-
             if not self._is_shutdown:
                 await self.close()
             raise
@@ -299,6 +316,29 @@ class RabbitMQConnectionPool:
             logger.error(f"❌ [FORCE_RECONNECT_FAIL] 强制重连失败: {e}")
             raise
 
+    async def acquire_consumer_channel(self) -> RobustChannel:
+        """
+        专门为消费者获取独立的通道。
+        遵循 aio_pika 最佳实践：消费者不应与发布者或其他消费者共享同一个 Channel 对象。
+        """
+        # 确保连接池已初始化且连接是活的
+        if not self._initialized:
+            await self.init_pools()
+
+        # 确保 self._connection 是有效的（复用 _ensure_main_channel 的连接恢复逻辑）
+        await self._ensure_main_channel()
+
+        # 基于有效连接创建一个新的独立通道
+        try:
+            # 注意：这里直接使用 self._connection，而不是返回缓存的 self._channel
+            consumer_ch = await self._connection.channel()
+            await consumer_ch.set_qos(prefetch_count=self.prefetch_count)
+            logger.debug("✅ [CONSUMER_CH] 消费者独立通道已创建")
+            return consumer_ch
+        except Exception as e:
+            logger.error(f"❌ [CONSUMER_CH_FAIL] 创建消费者独立通道失败: {e}")
+            raise
+
     async def acquire_channel(self) -> Tuple[RobustChannel, AbstractRobustConnection]:
         """获取主通道"""
         if not self._initialized and not self._is_shutdown:
@@ -383,18 +423,28 @@ class RabbitMQConnectionPool:
 
     async def close(self):
         """资源销毁"""
-        async with self._lock:
+        try:
+            # 设置超时，防止因锁异常导致无法关闭
+            await asyncio.wait_for(self._lock.acquire(), timeout=5.0)
+        except asyncio.TimeoutError:
+            logger.error("⚠️ [CLOSE_TIMEOUT] 获取锁超时，强制标记关闭")
+            # 如果拿不到锁，我们只能标记状态，无法安全清理连接
+            self._is_shutdown = True
+            self._initialized = False
+            return
+
+        try:
             if self._is_shutdown:
                 return
             self._is_shutdown = True
             self._initialized = False
 
-        logger.info("🛑 [CLOSE] 开始关闭连接池...")
-
-        # 1. 清理所有资源
-        await self._cleanup_resources()
-
-        logger.info("🏁 [CLOSE] 连接池已关闭")
+            logger.info("🛑 [CLOSE] 开始关闭连接池...")
+            await self._cleanup_resources()
+            logger.info("🏁 [CLOSE] 连接池已关闭")
+        finally:
+            if self._lock.locked():
+                self._lock.release()
 
     async def declare_queue(self, queue_name: str, **kwargs) -> AbstractQueue:
         channel, _ = await self.acquire_channel()

sycommon/rabbitmq/rabbitmq_service_client_manager.py

@@ -28,16 +28,31 @@ class RabbitMQClientManager(RabbitMQCoreService):
 
     @classmethod
     async def _clean_client_resources(cls, client: RabbitMQClient) -> None:
-        """清理客户端无效资源"""
+        """清理客户端无效资源（支持显式关闭独立通道）"""
         try:
-            # 先停止消费
+            # 1. 先尝试正常停止消费
             if client._consumer_tag:
                 await client.stop_consuming()
-            logger.debug("客户端无效资源清理完成（单通道无需归还）")
         except Exception as e:
-            logger.warning(f"释放客户端无效资源失败: {str(e)}")
+            logger.warning(f"停止消费逻辑异常: {str(e)}")
+
+        try:
+            # 2. 【关键】显式关闭 Channel
+            # 在我们的新架构中，消费者持有独立通道，必须在这里显式关闭。
+            # 生产者持有的主通道虽然通常由 Pool 管理，但这里为了彻底清理，
+            # 可以尝试关闭（Pool 内部会有保护，或者接受主通道被关闭后重新创建）。
+            if client._channel and not client._channel.is_closed:
+                try:
+                    await client._channel.close()
+                    logger.debug(f"清理资源：已关闭客户端通道")
+                except Exception as e:
+                    logger.warning(f"清理资源：关闭通道异常: {e}")
+        except Exception as e:
+            logger.warning(f"清理资源过程发生异常: {str(e)}")
         finally:
-            # 强制重置客户端状态
+            # 3. 强制重置客户端状态
+            # 注意：不要将 _channel_conn 置空，因为它是连接池的引用，置空后可能导致逻辑判断出错
+            # 但为了彻底断开，置空也是安全的，因为 connect 会重新获取。
             client._channel = None
             client._channel_conn = None
             client._exchange = None

sycommon/synacos/nacos_service_discovery.py

@@ -53,20 +53,23 @@ class NacosServiceDiscovery:
                 instance for instance in all_instances
                 if instance.get('enabled', True)
             ]
+
+            if not all_instances:
+                SYLogger.info(f"nacos:筛选后 {service_name} 无可用实例")
+                return []
+
             SYLogger.info(
                 f"nacos:共发现 {len(all_instances)} 个 {service_name} 服务实例")
 
-            version_to_use = target_version
-
-            if version_to_use:
+            if target_version:
                 same_version_instances = [
                     instance for instance in all_instances
-                    if instance.get('metadata', {}).get('version') == version_to_use
+                    if instance.get('metadata', {}).get('version') == target_version
                 ]
 
                 if same_version_instances:
                     SYLogger.info(
-                        f"nacos:筛选出 {len(same_version_instances)} 个与当前版本({version_to_use})匹配的实例")
+                        f"nacos:筛选出 {len(same_version_instances)} 个与当前版本({target_version})匹配的实例")
                     return same_version_instances
 
                 no_version_instances = [
@@ -76,7 +79,7 @@ class NacosServiceDiscovery:
 
                 if no_version_instances:
                     SYLogger.info(
-                        f"nacos:未找到相同版本({version_to_use})的实例，筛选出 {len(no_version_instances)} 个无版本号的实例")
+                        f"nacos:未找到相同版本({target_version})的实例，筛选出 {len(no_version_instances)} 个无版本号的实例")
                     return no_version_instances
             else:
                 no_version_instances = [

sycommon/tests/test_email.py

@@ -0,0 +1,172 @@
+import os
+import smtplib
+import asyncio
+from typing import List, Optional
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.header import Header
+from email.mime.base import MIMEBase
+from email import encoders
+from src.sycommon.config.Config import Config
+
+
+class SYEmail:
+    """盛业邮件发送工具类"""
+
+    @staticmethod
+    def _get_config() -> dict:
+        """获取邮件配置"""
+        return Config().config.get("AIEmailConfig", {})
+
+    @staticmethod
+    async def send(
+        to: List[str],
+        subject: str,
+        content: str,
+        attachments: Optional[List[str]] = None,
+        verbose: bool = False
+    ) -> bool:
+        """
+        异步发送邮件
+
+        :param to: 收件人列表
+        :param subject: 邮件主题
+        :param content: 邮件正文
+        :param attachments: 附件路径列表 (可选)
+        :param verbose: 是否打印详细日志
+        :return: 是否发送成功
+        """
+        try:
+            # 1. 构建邮件对象
+            message = SYEmail._build_message(
+                to, subject, content, attachments
+            )
+
+            # 2. 发送邮件 (网络阻塞型，扔到线程池运行)
+            loop = asyncio.get_running_loop()
+            success = await loop.run_in_executor(
+                None,
+                SYEmail._send_smtp,
+                message,
+                to,
+                verbose
+            )
+            return success
+
+        except Exception as e:
+            print(f"❌ 异步邮件调度异常: {e}")
+            return False
+
+    @staticmethod
+    def _build_message(to: List[str], subject: str, content: str, attachments: Optional[List[str]] = None):
+        """构建邮件对象"""
+        config = SYEmail._get_config()
+
+        message = MIMEMultipart()
+        message['From'] = Header(config.get('sender_name', ''), 'utf-8')
+        message['To'] = Header(", ".join(to), 'utf-8')
+        message['Subject'] = Header(subject, 'utf-8')
+        message.attach(MIMEText(content, 'plain', 'utf-8'))
+
+        if attachments:
+            for file_path in attachments:
+                if os.path.exists(file_path):
+                    try:
+                        with open(file_path, 'rb') as f:
+                            # 使用 octet-stream 通用流类型
+                            attachment = MIMEBase(
+                                'application', 'octet-stream')
+                            attachment.set_payload(f.read())
+                            encoders.encode_base64(attachment)
+
+                            # 解决文件名中文乱码问题
+                            filename = os.path.basename(file_path)
+                            attachment.add_header(
+                                'Content-Disposition',
+                                'attachment',
+                                filename=('utf-8', '', filename)
+                            )
+                            message.attach(attachment)
+                    except Exception as e:
+                        print(f"⚠️ 读取附件失败 [{file_path}]: {e}")
+                else:
+                    print(f"⚠️ 附件文件不存在: {file_path}")
+        return message
+
+    @staticmethod
+    def _send_smtp(message, to_list: List[str], verbose: bool) -> bool:
+        """执行 SMTP 发送 (在线程池中运行)"""
+        config = SYEmail._get_config()
+        smtp_obj = None
+
+        try:
+            if verbose:
+                print(
+                    f"正在连接 {config.get('smtp_server')}:{config.get('smtp_port')} ...")
+
+            # 1. 创建连接
+            smtp_obj = smtplib.SMTP(
+                config.get('smtp_server'),
+                config.get('smtp_port'),
+                timeout=10
+            )
+
+            if verbose:
+                smtp_obj.set_debuglevel(1)
+
+            # 2. 直接进行登录认证
+            if verbose:
+                print(f"正在使用账号 {config.get('smtp_user')} 登录...")
+
+            smtp_obj.login(config.get('smtp_user'), config.get('smtp_pass'))
+
+            if verbose:
+                print("✅ 登录成功")
+
+            # 3. 发送邮件
+            smtp_obj.sendmail(
+                config.get('sender_email'),
+                to_list,
+                message.as_string()
+            )
+
+            if verbose:
+                print("✅ 邮件发送成功！")
+            return True
+
+        except smtplib.SMTPAuthenticationError:
+            print("❌ 认证失败：请检查账号密码。")
+        except smtplib.SMTPException as e:
+            print(f"❌ SMTP 协议错误: {e}")
+        except Exception as e:
+            print(f"❌ 发送邮件时发生未知错误: {e}")
+        finally:
+            if smtp_obj:
+                try:
+                    smtp_obj.quit()
+                except:
+                    pass
+        return False
+
+
+# 使用示例
+async def main():
+    """异步主函数测试"""
+    print("开始发送邮件...")
+
+    success = await SYEmail.send(
+        to=["Osulcode.xiao@syholdings.com"],
+        subject="异步邮件测试",
+        content="这是一封通过异步方式发送的测试邮件。",
+        attachments=["test_file.txt"],
+        verbose=True
+    )
+
+    if success:
+        print("\n🎉 任务完成")
+    else:
+        print("\n⚠️ 任务失败")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

sycommon/tools/syemail.py

@@ -0,0 +1,173 @@
+import os
+import smtplib
+import asyncio
+from typing import List, Optional
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.header import Header
+from email.mime.base import MIMEBase
+from email import encoders
+from src.sycommon.config.Config import Config
+from src.sycommon.logging.kafka_log import SYLogger
+
+
+class SYEmail:
+    """盛业邮件发送工具类"""
+
+    @staticmethod
+    def _get_config() -> dict:
+        """获取邮件配置"""
+        return Config().config.get("AIEmailConfig", {})
+
+    @staticmethod
+    async def send(
+        to: List[str],
+        subject: str,
+        content: str,
+        attachments: Optional[List[str]] = None,
+        verbose: bool = False
+    ) -> bool:
+        """
+        异步发送邮件
+
+        :param to: 收件人列表
+        :param subject: 邮件主题
+        :param content: 邮件正文
+        :param attachments: 附件路径列表 (可选)
+        :param verbose: 是否打印详细日志
+        :return: 是否发送成功
+        """
+        try:
+            # 1. 构建邮件对象
+            message = SYEmail._build_message(
+                to, subject, content, attachments
+            )
+
+            # 2. 发送邮件 (网络阻塞型，扔到线程池运行)
+            loop = asyncio.get_running_loop()
+            success = await loop.run_in_executor(
+                None,
+                SYEmail._send_smtp,
+                message,
+                to,
+                verbose
+            )
+            return success
+
+        except Exception as e:
+            SYLogger.error(f"❌ 异步邮件调度异常: {e}")
+            return False
+
+    @staticmethod
+    def _build_message(to: List[str], subject: str, content: str, attachments: Optional[List[str]] = None):
+        """构建邮件对象"""
+        config = SYEmail._get_config()
+
+        message = MIMEMultipart()
+        message['From'] = Header(config.get('sender_name', ''), 'utf-8')
+        message['To'] = Header(", ".join(to), 'utf-8')
+        message['Subject'] = Header(subject, 'utf-8')
+        message.attach(MIMEText(content, 'plain', 'utf-8'))
+
+        if attachments:
+            for file_path in attachments:
+                if os.path.exists(file_path):
+                    try:
+                        with open(file_path, 'rb') as f:
+                            # 使用 octet-stream 通用流类型
+                            attachment = MIMEBase(
+                                'application', 'octet-stream')
+                            attachment.set_payload(f.read())
+                            encoders.encode_base64(attachment)
+
+                            # 解决文件名中文乱码问题
+                            filename = os.path.basename(file_path)
+                            attachment.add_header(
+                                'Content-Disposition',
+                                'attachment',
+                                filename=('utf-8', '', filename)
+                            )
+                            message.attach(attachment)
+                    except Exception as e:
+                        SYLogger.error(f"⚠️ 读取附件失败 [{file_path}]: {e}")
+                else:
+                    SYLogger.error(f"⚠️ 附件文件不存在: {file_path}")
+        return message
+
+    @staticmethod
+    def _send_smtp(message, to_list: List[str], verbose: bool) -> bool:
+        """执行 SMTP 发送 (在线程池中运行)"""
+        config = SYEmail._get_config()
+        smtp_obj = None
+
+        try:
+            if verbose:
+                SYLogger.info(
+                    f"正在连接 {config.get('smtp_server')}:{config.get('smtp_port')} ...")
+
+            # 1. 创建连接
+            smtp_obj = smtplib.SMTP(
+                config.get('smtp_server'),
+                config.get('smtp_port'),
+                timeout=10
+            )
+
+            if verbose:
+                smtp_obj.set_debuglevel(1)
+
+            # 2. 直接进行登录认证
+            if verbose:
+                SYLogger.info(f"正在使用账号 {config.get('smtp_user')} 登录...")
+
+            smtp_obj.login(config.get('smtp_user'), config.get('smtp_pass'))
+
+            if verbose:
+                SYLogger.info("✅ 登录成功")
+
+            # 3. 发送邮件
+            smtp_obj.sendmail(
+                config.get('sender_email'),
+                to_list,
+                message.as_string()
+            )
+
+            if verbose:
+                SYLogger.info("✅ 邮件发送成功！")
+            return True
+
+        except smtplib.SMTPAuthenticationError:
+            SYLogger.error("❌ 认证失败：请检查账号密码。")
+        except smtplib.SMTPException as e:
+            SYLogger.error(f"❌ SMTP 协议错误: {e}")
+        except Exception as e:
+            SYLogger.error(f"❌ 发送邮件时发生未知错误: {e}")
+        finally:
+            if smtp_obj:
+                try:
+                    smtp_obj.quit()
+                except:
+                    pass
+        return False
+
+
+# 使用示例
+# async def main():
+#     """异步主函数测试"""
+#     print("开始发送邮件...")
+
+#     success = await SYEmail.send(
+#         to=["Osulcode.xiao@syholdings.com"],
+#         subject="异步邮件测试",
+#         content="这是一封通过异步方式发送的测试邮件。",
+#         attachments=["test_file.txt"],
+#         verbose=True
+#     )
+
+#     if success:
+#         print("\n🎉 任务完成")
+#     else:
+#         print("\n⚠️ 任务失败")
+
+
+# if __name__ == "__main__":
+#     asyncio.run(main())

{sycommon_python_lib-0.1.59.dist-info → sycommon_python_lib-0.2.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.59
+Version: 0.2.0b1
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -21,6 +21,7 @@ Requires-Dist: nacos-sdk-python<3.0,>=2.0.9
 Requires-Dist: psutil>=7.2.1
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: python-multipart>=0.0.21
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: sentry-sdk[fastapi]>=2.49.0
 Requires-Dist: sqlalchemy[asyncio]>=2.0.45

{sycommon_python_lib-0.1.59.dist-info → sycommon_python_lib-0.2.0b1.dist-info}/RECORD

@@ -50,11 +50,11 @@ sycommon/models/mqmsg_model.py,sha256=Zo-LsDMFuF1Vkx9ZmwBC9E7TrCw-7nAQD2TE4v9-6F
 sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6D7I,268
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
 sycommon/notice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/notice/uvicorn_monitor.py,sha256=VryQYcAtjijJuGDBimbVurgwxlsLaLtkNnABPDY5Tao,7332
-sycommon/rabbitmq/rabbitmq_client.py,sha256=mLdggb_Jv_gDLWXL8nrkKahjsiLNooNgEmPAgWKwHLc,16136
-sycommon/rabbitmq/rabbitmq_pool.py,sha256=EzM3j3MCLgoy6VW8tLONtcZB3VmYQI7CWi_X1kOdqF8,16194
+sycommon/notice/uvicorn_monitor.py,sha256=PrC-OFRE71mL8TcbfdkJRKbjwGAbgsWtyBPWIw1qs08,6753
+sycommon/rabbitmq/rabbitmq_client.py,sha256=MC4QNSZpfYSPHY8-iW3RRuZAs0MZcNGWJD9EzCLc68k,22115
+sycommon/rabbitmq/rabbitmq_pool.py,sha256=igQ4Yh96oZyM8UEhNa_rljhZcitHwske3UsjPtBuj8c,18946
 sycommon/rabbitmq/rabbitmq_service.py,sha256=XSHo9HuIJ_lq-vizRh4xJVdZr_2zLqeLhot09qb0euA,2025
-sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=IP9TMFeG5LSrwFPEmOy1ce4baPxBUZnWJZR3nN_-XR4,8009
+sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=O4zVL7lY2eaN_hUajwB5Ai6nnW-bevRBXysxSMhfVqw,9005
 sycommon/rabbitmq/rabbitmq_service_connection_monitor.py,sha256=uvoMuJDzJ9i63uVRq1NKFV10CvkbGnTMyEoq2rgjQx8,3013
 sycommon/rabbitmq/rabbitmq_service_consumer_manager.py,sha256=489r1RKd5WrTNMAcWCxUZpt9yWGrNunZlLCCp-M_rzM,11497
 sycommon/rabbitmq/rabbitmq_service_core.py,sha256=6RMvIf78DmEOZmN8dA0duA9oy4ieNswdGrOeyJdD6tU,4753
@@ -73,17 +73,19 @@ sycommon/synacos/nacos_client_base.py,sha256=KZgQAg9Imfr_TfM-4LXdtrnTdJ-beu6bcNJ
 sycommon/synacos/nacos_config_manager.py,sha256=Cff-4gpp0aD7sQVi-nEvDO4BWqK9abEDDDJ9qXKFQgs,4399
 sycommon/synacos/nacos_heartbeat_manager.py,sha256=G80_pOn37WdO_HpYUiAfpwMqAxW0ff0Bnw0NEuge9v0,5568
 sycommon/synacos/nacos_service.py,sha256=BezQ1eDIYwBPE567Po_Qh1Ki_z9WmhZy1J1NiTPbdHY,6118
-sycommon/synacos/nacos_service_discovery.py,sha256=O0M4facMa3I9YDFaovrfiTnCMtJWTuewbt9ce4a2-CA,6828
+sycommon/synacos/nacos_service_discovery.py,sha256=rcnMTX8e6VJmu2LwW5lrubt2UQNpu4e8P7GVcOi79Cg,6926
 sycommon/synacos/nacos_service_registration.py,sha256=plg2PmH8CWgmVnPtiIXBxtj-3BpyMdSzKr1wyWRdzh4,10968
 sycommon/synacos/param.py,sha256=KcfSkxnXOa0TGmCjY8hdzU9pzUsA8-4PeyBKWI2-568,1765
+sycommon/tests/test_email.py,sha256=-oPtYVGQzJ3Cv-op3ZNRMeyYOF-UNidGJC35CHRgjGQ,5442
 sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
 sycommon/tools/env.py,sha256=Ah-tBwG2C0_hwLGFebVQgKdWWXCjTzBuF23gCkLHYy4,2437
 sycommon/tools/merge_headers.py,sha256=u9u8_1ZIuGIminWsw45YJ5qnsx9MB-Fot0VPge7itPw,4941
 sycommon/tools/snowflake.py,sha256=xQlYXwYnI85kSJ1rZ89gMVBhzemP03xrMPVX9vVa3MY,9228
+sycommon/tools/syemail.py,sha256=BDFhgf7WDOQeTcjxJEQdu0dQhnHFPO_p3eI0-Ni3LhQ,5612
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.59.dist-info/METADATA,sha256=sZT5EhFuzDcvhX9Q68MmljOgn5A4irjOxC0RI29X7gw,7331
-sycommon_python_lib-0.1.59.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.59.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.59.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.59.dist-info/RECORD,,
+sycommon_python_lib-0.2.0b1.dist-info/METADATA,sha256=5MhM3eTt-f3-du7nf8tlpH8wDKIU3_4z6nIRURL6Rg4,7372
+sycommon_python_lib-0.2.0b1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+sycommon_python_lib-0.2.0b1.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.2.0b1.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.2.0b1.dist-info/RECORD,,

{sycommon_python_lib-0.1.59.dist-info → sycommon_python_lib-0.2.0b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any