sycommon-python-lib 0.1.8__tar.gz → 0.1.9__tar.gz

{sycommon_python_lib-0.1.8 → sycommon_python_lib-0.1.9}/PKG-INFO

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

{sycommon_python_lib-0.1.8 → sycommon_python_lib-0.1.9}/pyproject.toml

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

{sycommon_python_lib-0.1.8 → sycommon_python_lib-0.1.9}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -183,8 +183,14 @@ class RabbitMQClient:
                 await asyncio.sleep(1)
         return False
 
-    async def connect(self, force_reconnect: bool = False, max_retries: int = 3) -> None:
-        """建立连接并检查/创建资源"""
+    async def connect(self, force_reconnect: bool = False, declare_queue: bool = True) -> None:
+        """建立连接并检查/创建资源，新增declare_queue参数控制是否声明队列"""
+        # 增加日志确认参数状态
+        logging.debug(
+            f"connect() 调用 - 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
 
@@ -196,7 +202,8 @@ class RabbitMQClient:
             f"尝试连接RabbitMQ - 主机: {self.host}:{self.port}, "
             f"虚拟主机: {self.virtualhost}, "
             f"队列: {self.queue_name}, "
-            f"心跳间隔: {self.heartbeat}s"
+            f"声明队列: {declare_queue}, "
+            f"允许创建: {self.create_if_not_exists}"
         )
 
         # 重置状态
@@ -207,13 +214,13 @@ class RabbitMQClient:
         retries = 0
         last_exception = None
 
-        while retries < max_retries:
+        while retries < 3:  # 使用固定重试次数
             try:
                 # 关闭旧连接
                 if self.connection and not self.connection.is_closed:
                     await self.connection.close()
 
-                # 建立新连接 - 配置更短的心跳间隔
+                # 建立新连接
                 self.connection = await asyncio.wait_for(
                     aio_pika.connect_robust(
                         host=self.host,
@@ -223,7 +230,7 @@ class RabbitMQClient:
                         virtualhost=self.virtualhost,
                         heartbeat=self.heartbeat,
                         client_properties={
-                            "connection_name": self.app_name or "rabbitmq-client"}  # 增加连接标识
+                            "connection_name": self.app_name or "rabbitmq-client"}
                     ),
                     timeout=self.connection_timeout
                 )
@@ -262,28 +269,29 @@ class RabbitMQClient:
                     )
                     logging.info(f"使用已存在的交换机 '{self.exchange_name}'")
 
-                # 2. 处理队列
-                if self.queue_name:
+                # 2. 处理队列 - 只有declare_queue为True时才处理
+                if declare_queue and self.queue_name:
                     queue_exists = await self._check_queue_exists()
 
                     if not queue_exists:
-                        if self.create_if_not_exists:
-                            # 创建队列
-                            self.queue = await asyncio.wait_for(
-                                self.channel.declare_queue(
-                                    name=self.queue_name,
-                                    durable=self.durable,
-                                    auto_delete=self.auto_delete,
-                                    exclusive=False,
-                                    passive=False
-                                ),
-                                timeout=self.rpc_timeout
-                            )
-                            self._queue_exists = True
-                            logging.info(f"已创建队列 '{self.queue_name}'")
-                        else:
+                        # 关键检查点：确保有权限创建队列
+                        if not self.create_if_not_exists:
                             raise Exception(
                                 f"队列 '{self.queue_name}' 不存在且不允许自动创建")
+
+                        # 创建队列
+                        self.queue = await asyncio.wait_for(
+                            self.channel.declare_queue(
+                                name=self.queue_name,
+                                durable=self.durable,
+                                auto_delete=self.auto_delete,
+                                exclusive=False,
+                                passive=False
+                            ),
+                            timeout=self.rpc_timeout
+                        )
+                        self._queue_exists = True
+                        logging.info(f"已创建队列 '{self.queue_name}'")
                     else:
                         # 获取已有队列
                         self.queue = await asyncio.wait_for(
@@ -292,12 +300,18 @@ class RabbitMQClient:
                         )
                         logging.info(f"使用已存在的队列 '{self.queue_name}'")
 
-                # 3. 绑定队列到交换机
-                if self.queue and self.exchange:
-                    bound = await self._bind_queue()
-                    if not bound:
-                        raise Exception(
-                            f"队列 '{self.queue_name}' 绑定到交换机 '{self.exchange_name}' 失败")
+                    # 3. 绑定队列到交换机
+                    if self.queue and self.exchange:
+                        bound = await self._bind_queue()
+                        if not bound:
+                            raise Exception(
+                                f"队列 '{self.queue_name}' 绑定到交换机 '{self.exchange_name}' 失败")
+                else:
+                    # 不声明队列时，将队列相关状态设为False
+                    self.queue = None
+                    self._queue_exists = False
+                    self._queue_bound = False
+                    logging.debug(f"跳过队列 '{self.queue_name}' 的声明和绑定")
 
                 # 如果之前在消费，重新开始消费
                 if self._is_consuming and self.message_handler:
@@ -308,23 +322,22 @@ class RabbitMQClient:
                 self._start_keepalive_task()
 
                 self._update_activity_timestamp()
-                logging.info(f"RabbitMQ客户端连接成功 (队列: {self.queue_name})")
+                logging.info(
+                    f"RabbitMQ客户端连接成功 (队列: {self.queue_name}, 声明队列: {declare_queue})")
                 return
 
             except Exception as e:
                 retries += 1
                 last_exception = e
                 logging.warning(
-                    f"连接失败（{retries}/{max_retries}）: {str(e)}，重试中...")
+                    f"连接失败（{retries}/3）: {str(e)}, create_if_not_exists={self.create_if_not_exists}, 重试中...")
 
-            if retries < max_retries:
+            if retries < 3:
                 await asyncio.sleep(self.reconnection_delay)
 
-        logging.error(f"最终连接失败: {str(last_exception)}", exc_info=True)
+        logging.error(f"最终连接失败: {str(last_exception)}")
         raise Exception(
-            f"经过{max_retries}次重试后仍无法完成连接和资源初始化。"
-            f"最后错误: {str(last_exception)}"
-        )
+            f"经过3次重试后仍无法完成连接和资源初始化。最后错误: {str(last_exception)}")
 
     def _start_connection_monitor(self):
         """启动连接监控任务，检测连接/通道关闭"""
@@ -534,16 +547,31 @@ class RabbitMQClient:
         self.message_handler = handler
 
     async def start_consuming(self, timeout: Optional[float] = None) -> str:
-        """开始消费消息并返回consumer_tag，支持超时控制"""
+        """开始消费消息并返回consumer_tag，支持超时控制和队列检查重试"""
         if self._is_consuming:
             logging.debug("已经在消费中，返回现有consumer_tag")
             return self._consumer_tag
 
-        if not self.is_connected:
-            await self.connect()
+        # 增加队列检查和连接确保逻辑
+        max_attempts = 5
+        attempt = 0
+        while attempt < max_attempts:
+            if not self.is_connected:
+                await self.connect()
+
+            if self.queue:
+                break
+
+            attempt += 1
+            logging.warning(f"队列尚未初始化，等待后重试（{attempt}/{max_attempts}）")
+            await asyncio.sleep(1)
 
         if not self.queue:
-            raise Exception("队列未初始化")
+            # 最后尝试一次显式连接并声明队列
+            logging.warning("最后尝试重新连接并声明队列")
+            await self.connect(force_reconnect=True, declare_queue=True)
+            if not self.queue:
+                raise Exception("队列未初始化，多次尝试后仍无法创建")
 
         if not self.message_handler:
             raise Exception("未设置消息处理函数")

{sycommon_python_lib-0.1.8 → sycommon_python_lib-0.1.9}/src/sycommon/rabbitmq/rabbitmq_service.py

@@ -31,15 +31,22 @@ class RabbitMQService:
     _initialized_queues: Dict[str, Dict[str, bool]] = {}
     # 添加异步锁
     _init_lock: Dict[str, asyncio.Lock] = {}
+    _has_listeners: bool = False
+    _has_senders: bool = False
 
     @classmethod
-    def init(cls, config: dict) -> Type['RabbitMQService']:
-        """初始化RabbitMQ服务，保存配置"""
+    def init(cls, config: dict, has_listeners: bool = False, has_senders: bool = False) -> Type['RabbitMQService']:
+        """初始化RabbitMQ服务，保存配置和发送器/监听器状态"""
         from sycommon.synacos.nacos_service import NacosService
         # 获取 common 配置
         cls.config = NacosService(config).share_configs.get(
             "mq.yml", {}).get('spring', {}).get('rabbitmq', {})
         cls.config["APP_NAME"] = config.get("Name", "")
+
+        # 保存发送器和监听器存在状态
+        cls._has_listeners = has_listeners
+        cls._has_senders = has_senders
+
         return cls()
 
     @classmethod
@@ -56,21 +63,35 @@ class RabbitMQService:
 
     @classmethod
     def create_client(cls, mq_config: dict, queue_name: str, **kwargs):
-        """创建并返回新的RabbitMQClient实例"""
-        # 从kwargs中提取是否自动创建队列的参数，默认True
-        create_if_not_exists = kwargs.get('create_if_not_exists', True)
+        """创建并返回新的RabbitMQClient实例，遵循队列创建规则"""
+        # 获取当前项目名
+        app_name = kwargs.get('app_name', cls.config.get(
+            "APP_NAME", "")) if cls.config else kwargs.get('app_name', "")
 
         # 确保只在需要时处理一次队列名称
         processed_queue_name = queue_name
 
-        # 如果是监听器且需要自动创建队列，确保队列名拼接app-name（只拼接一次）
-        if create_if_not_exists and processed_queue_name and 'app_name' in kwargs and kwargs['app_name']:
-            app_name = kwargs['app_name']
-            # 只在队列名尚未包含app-name时进行拼接
+        # 通过上下文判断是否为发送器
+        # 发送器场景：当没有监听器时
+        is_sender = not cls._has_listeners
+
+        # 核心逻辑：根据组件存在状态决定是否允许创建队列
+        # 1. 只有发送器：不允许创建队列
+        # 2. 只有监听器：允许创建队列
+        # 3. 两者都存在：允许创建队列（由监听器负责）
+        create_if_not_exists = cls._has_listeners  # 只要有监听器就允许创建
+
+        # 当需要创建队列且是监听器时，拼接项目名
+        if create_if_not_exists and not is_sender and processed_queue_name and app_name:
             if not processed_queue_name.endswith(f".{app_name}"):
                 processed_queue_name = f"{processed_queue_name}.{app_name}"
                 logging.debug(f"监听器队列名称自动拼接app-name: {processed_queue_name}")
 
+        logging.debug(
+            f"队列创建权限 - 监听器存在: {cls._has_listeners}, 发送器存在: {cls._has_senders}, "
+            f"是否发送器: {is_sender}, 允许创建: {create_if_not_exists}, 队列: {processed_queue_name}"
+        )
+
         return RabbitMQClient(
             host=mq_config.get('host', ""),
             port=mq_config.get('port', 0),
@@ -80,7 +101,7 @@ class RabbitMQService:
             exchange_name=mq_config.get(
                 'exchange_name', "system.topic.exchange"),
             exchange_type=kwargs.get('exchange_type', "topic"),
-            queue_name=processed_queue_name,  # 使用处理后的队列名
+            queue_name=processed_queue_name,
             routing_key=kwargs.get(
                 'routing_key', f"{processed_queue_name.split('.')[0]}.#" if processed_queue_name else "#"),
             durable=kwargs.get('durable', True),
@@ -89,7 +110,7 @@ class RabbitMQService:
             create_if_not_exists=create_if_not_exists,
             connection_timeout=kwargs.get('connection_timeout', 10),
             rpc_timeout=kwargs.get('rpc_timeout', 5),
-            app_name=kwargs.get('app_name', "")
+            app_name=app_name
         )
 
     @classmethod
@@ -105,52 +126,80 @@ class RabbitMQService:
         async with cls._init_lock[client_name]:
             if client_name in cls.clients:
                 client = cls.clients[client_name]
+                # 移除is_sender判断，通过上下文推断
+                is_sender = not cls._has_listeners or (
+                    not kwargs.get('create_if_not_exists', True))
+
                 if client.is_connected:
-                    logging.debug(f"客户端 '{client_name}' 已存在且连接有效，直接返回")
+                    if not is_sender and not client.queue:
+                        logging.debug(f"客户端 '{client_name}' 存在但队列未初始化，重新连接")
+                        client.create_if_not_exists = True
+                        await client.connect(force_reconnect=True, declare_queue=True)
+                    else:
+                        logging.debug(f"客户端 '{client_name}' 已存在且连接有效，直接返回")
                     return client
                 else:
                     logging.debug(f"客户端 '{client_name}' 存在但连接已关闭，重新连接")
-                    await client.connect()
+                    if not is_sender:
+                        client.create_if_not_exists = True
+                    await client.connect(declare_queue=not is_sender)
                     return client
 
             initial_queue_name = kwargs.pop('queue_name', '')
-            create_if_not_exists = kwargs.get('create_if_not_exists', True)
+            # 移除is_sender参数，通过上下文推断
+            is_sender = not cls._has_listeners or (
+                not kwargs.get('create_if_not_exists', True))
+
+            # 发送器特殊处理
+            if is_sender:
+                kwargs['create_if_not_exists'] = False
 
-            # 检查队列是否已初始化
-            if initial_queue_name in cls._initialized_queues:
-                logging.debug(f"队列 '{initial_queue_name}' 已初始化过，直接创建客户端")
                 client = RabbitMQService.create_client(
                     mq_config,
                     initial_queue_name,
                     app_name=cls.config.get("APP_NAME", ""),
-                    **kwargs
+                    **kwargs  # 不再传递is_sender参数
                 )
-                await client.connect()
+
+                await client.connect(declare_queue=False)
                 cls.clients[client_name] = client
                 return client
 
-            # 处理create_if_not_exists参数，避免重复传递
-            create_if_not_exists = kwargs.pop('create_if_not_exists', True)
+            # 监听器逻辑
+            kwargs['create_if_not_exists'] = True
 
-            # 对于监听器，确保create_if_not_exists为True
-            # 判断是否为监听器：客户端名称与队列名称相同通常是监听器
-            is_listener = client_name == initial_queue_name and initial_queue_name
-            if is_listener:
-                create_if_not_exists = True
-                logging.debug(f"监听器 '{client_name}' 将自动创建队列（如果不存在）")
+            if initial_queue_name in cls._initialized_queues:
+                logging.debug(f"队列 '{initial_queue_name}' 已初始化过，直接创建客户端")
+                client = RabbitMQService.create_client(
+                    mq_config,
+                    initial_queue_name,
+                    # 不再传递is_sender参数
+                    app_name=cls.config.get("APP_NAME", ""), ** kwargs
+                )
+                await client.connect(declare_queue=True)
+                cls.clients[client_name] = client
+                return client
 
-            # 创建客户端（这里会处理队列名称，添加app-name）
             client = RabbitMQService.create_client(
                 mq_config,
                 initial_queue_name,
                 app_name=cls.config.get("APP_NAME", ""),
-                create_if_not_exists=create_if_not_exists,
-                connection_timeout=mq_config.get('connection_timeout', 15),
-                rpc_timeout=mq_config.get('rpc_timeout', 5), ** kwargs
+                **kwargs  # 不再传递is_sender参数
             )
 
-            # 连接时不再处理队列名称，避免重复添加app-name
-            await client.connect()
+            client.create_if_not_exists = True
+            logging.debug(
+                f"监听器客户端创建 - create_if_not_exists={client.create_if_not_exists}")
+
+            await client.connect(declare_queue=True)
+
+            if not client.queue:
+                logging.error(f"队列 '{initial_queue_name}' 创建失败，尝试重新创建")
+                client.create_if_not_exists = True
+                await client.connect(force_reconnect=True, declare_queue=True)
+                if not client.queue:
+                    raise Exception(f"无法创建队列 '{initial_queue_name}'")
+
             final_queue_name = client.queue_name
 
             if final_queue_name not in cls._initialized_queues:
@@ -163,8 +212,11 @@ class RabbitMQService:
             return client
 
     @classmethod
-    async def setup_senders(cls, senders: List[RabbitMQSendConfig]):
-        """设置MQ发送客户端 - 保持不自动创建队列的行为"""
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False):
+        """设置MQ发送客户端"""
+        cls._has_listeners = has_listeners
+        cls._has_senders = True  # 明确标记存在发送器
+
         async def setup_sender_tasks():
             for idx, sender_config in enumerate(senders):
                 try:
@@ -173,20 +225,23 @@ class RabbitMQService:
 
                     normalized_name = sender_config.queue_name
                     app_name = cls.config.get("APP_NAME", "")
+
                     if app_name and normalized_name.endswith(f".{app_name}"):
                         normalized_name = normalized_name[:-
                                                           len(f".{app_name}")]
+                        logging.debug(
+                            f"发送器队列名称移除app-name后缀: {normalized_name}")
 
                     if normalized_name in cls.sender_client_names:
-                        logging.debug(f"发送客户端 '{normalized_name}' 已存在，跳过重复配置")
+                        logging.debug(f"发送客户端 '{normalized_name}' 已存在，跳过")
                         continue
 
                     if normalized_name in cls.clients:
                         client = cls.clients[normalized_name]
                         if not client.is_connected:
-                            await client.connect()
+                            await client.connect(declare_queue=False)
                     else:
-                        # 发送端明确设置不自动创建队列
+                        # 移除is_sender参数传递
                         client = await cls.setup_rabbitmq(
                             cls.config,
                             client_name=normalized_name,
@@ -195,12 +250,12 @@ class RabbitMQService:
                             auto_delete=sender_config.auto_delete,
                             auto_parse_json=sender_config.auto_parse_json,
                             queue_name=sender_config.queue_name,
-                            create_if_not_exists=False  # 发送端不自动创建队列
+                            create_if_not_exists=False  # 仅通过此参数控制
                         )
 
                     if normalized_name not in cls.clients:
                         cls.clients[normalized_name] = client
-                        logging.info(f"客户端 '{normalized_name}' 已添加到客户端列表")
+                        logging.info(f"发送客户端 '{normalized_name}' 已添加")
 
                     if normalized_name not in cls.sender_client_names:
                         cls.sender_client_names.append(normalized_name)
@@ -217,8 +272,11 @@ class RabbitMQService:
             raise
 
     @classmethod
-    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig]):
+    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False):
         """设置MQ监听器 - 确保自动创建队列"""
+        # 存在监听器，设置标志
+        cls._has_listeners = True
+
         for listener_config in listeners:
             # 将监听器配置转换为字典并添加到监听器
             # 强制设置create_if_not_exists为True
@@ -337,19 +395,17 @@ class RabbitMQService:
 
     @classmethod
     def get_sender(cls, client_name: Optional[str] = None) -> Optional[RabbitMQClient]:
-        """获取发送客户端（仅返回已注册的客户端，移除模糊匹配）"""
+        """获取发送客户端（仅返回已注册的客户端）"""
         if not client_name:
             logging.warning("发送器名称不能为空")
             return None
 
-        # 仅精确匹配已注册的客户端，不做模糊匹配
+        # 仅精确匹配已注册的客户端
         if client_name in cls.clients:
             return cls.clients[client_name]
 
-        # 不允许通过拼接app-name反向查找（避免绕过注册）
         app_name = cls.config.get("APP_NAME", "") if cls.config else ""
         if app_name and not client_name.endswith(f".{app_name}"):
-            # 不尝试拼接app-name查找，确保只有注册的名称可被找到
             return None
 
         logging.debug(f"发送器 '{client_name}' 不在已注册客户端列表中")
@@ -359,7 +415,7 @@ class RabbitMQService:
     async def send_message(
         cls,
         data: Union[BaseModel, str, Dict[str, Any], None],
-        queue_name: Optional[str] = None, ** kwargs
+        queue_name: Optional[str] = None, **kwargs
     ) -> None:
         """发送消息到RabbitMQ"""
         sender = cls.get_sender(queue_name)
@@ -472,5 +528,6 @@ class RabbitMQService:
         cls.clients.clear()
         cls.sender_client_names.clear()
         cls._init_lock.clear()
+        cls._has_listeners = False  # 重置标志
 
         logging.info("RabbitMQ服务已完全关闭")

sycommon_python_lib-0.1.9/src/sycommon/services.py

@@ -0,0 +1,208 @@
+from typing import Any, Callable, Dict, List, Tuple, Union, Optional, AsyncGenerator
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from pydantic import BaseModel
+from sycommon.config.Config import SingletonMeta
+from sycommon.models.mqlistener_config import RabbitMQListenerConfig
+from sycommon.models.mqsend_config import RabbitMQSendConfig
+from sycommon.rabbitmq.rabbitmq_service import RabbitMQService
+
+
+class Services(metaclass=SingletonMeta):
+    _loop: Optional[asyncio.AbstractEventLoop] = None
+    _config: Optional[dict] = None
+    _initialized: bool = False
+    _registered_senders: List[str] = []
+    _mq_tasks: List[asyncio.Task] = []
+    _instance: Optional['Services'] = None
+    _app: Optional[FastAPI] = None
+
+    def __init__(self, config: dict, app: FastAPI):
+        if not Services._config:
+            Services._config = config
+        Services._instance = self
+        Services._app = app
+        self._init_event_loop()
+
+    def _init_event_loop(self):
+        """初始化事件循环，确保全局只有一个循环实例"""
+        if not Services._loop:
+            try:
+                Services._loop = asyncio.get_running_loop()
+            except RuntimeError:
+                Services._loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(Services._loop)
+
+    @classmethod
+    def plugins(
+        cls,
+        app: FastAPI,
+        config: dict,
+        middleware: Optional[Callable[[FastAPI, dict], None]] = None,
+        nacos_service: Optional[Callable[[dict], None]] = None,
+        logging_service: Optional[Callable[[dict], None]] = None,
+        database_service: Optional[Union[
+            Tuple[Callable[[dict, str], None], str],
+            List[Tuple[Callable[[dict, str], None], str]]
+        ]] = None,
+        rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
+        rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None
+    ) -> FastAPI:
+        # 保存应用实例和配置
+        cls._app = app
+        cls._config = config
+
+        # 立即配置非异步服务（在应用启动前）
+        if middleware:
+            middleware(app, config)
+
+        if nacos_service:
+            nacos_service(config)
+
+        if logging_service:
+            logging_service(config)
+
+        if database_service:
+            cls._setup_database_static(database_service, config)
+
+        # 创建生命周期管理器
+        @asynccontextmanager
+        async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+            # 启动阶段 - 执行初始化
+            instance = cls(config, app)
+
+            # 检查是否存在监听器
+            has_listeners = bool(
+                rabbitmq_listeners and len(rabbitmq_listeners) > 0)
+            # 检查是否存在发送器
+            has_senders = bool(
+                rabbitmq_senders and len(rabbitmq_senders) > 0)
+
+            # 执行MQ异步初始化，传递是否有监听器的标志
+            try:
+                await instance._setup_mq_async(
+                    rabbitmq_listeners=rabbitmq_listeners,
+                    rabbitmq_senders=rabbitmq_senders,
+                    has_listeners=has_listeners,
+                    has_senders=has_senders
+                )
+                cls._initialized = True
+                logging.info("所有服务初始化完成")
+            except Exception as e:
+                logging.error(f"服务初始化失败: {str(e)}", exc_info=True)
+                raise
+
+            # 将实例挂载到app上
+            app.state.services = instance
+
+            yield  # 应用运行阶段
+
+            # 关闭阶段 - 清理资源
+            await cls.shutdown()
+            logging.info("所有服务已关闭")
+
+        # 设置生命周期
+        app.router.lifespan_context = lifespan
+
+        return app
+
+    @staticmethod
+    def _setup_database_static(database_service, config):
+        """静态方法：设置数据库服务"""
+        if isinstance(database_service, tuple):
+            db_setup, db_name = database_service
+            db_setup(config, db_name)
+        elif isinstance(database_service, list):
+            for db_setup, db_name in database_service:
+                db_setup(config, db_name)
+
+    async def _setup_mq_async(
+        self,
+        rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
+        rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None,
+        has_listeners: bool = False,
+        has_senders: bool = False,
+    ):
+        """异步设置MQ相关服务，保存发送器和监听器存在状态"""
+        # 保存状态到类变量
+        Services._has_listeners = has_listeners
+        Services._has_senders = has_senders
+
+        # 初始化RabbitMQ服务，传递状态
+        RabbitMQService.init(self._config, has_listeners, has_senders)
+
+        # 设置发送器，传递是否有监听器的标志
+        if rabbitmq_senders:
+            await self._setup_senders_async(rabbitmq_senders, has_listeners)
+
+        # 设置监听器，传递是否有发送器的标志
+        if rabbitmq_listeners:
+            await self._setup_listeners_async(rabbitmq_listeners, has_senders)
+
+    async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
+        Services._registered_senders = [
+            sender.queue_name for sender in rabbitmq_senders]
+
+        # 将是否有监听器的信息传递给RabbitMQService
+        await RabbitMQService.setup_senders(rabbitmq_senders, has_listeners)
+        logging.info(f"已注册的RabbitMQ发送器: {Services._registered_senders}")
+
+    async def _setup_listeners_async(self, rabbitmq_listeners, has_senders: bool):
+        await RabbitMQService.setup_listeners(rabbitmq_listeners, has_senders)
+
+    @classmethod
+    async def send_message(
+        cls,
+        queue_name: str,
+        data: Union[str, Dict[str, Any], BaseModel, None],
+        max_retries: int = 3,
+        retry_delay: float = 1.0, ** kwargs
+    ) -> None:
+        """发送消息，添加重试机制"""
+        if not cls._initialized or not cls._loop:
+            logging.error("Services not properly initialized!")
+            raise ValueError("服务未正确初始化")
+
+        for attempt in range(max_retries):
+            try:
+                if queue_name not in cls._registered_senders:
+                    cls._registered_senders = RabbitMQService.sender_client_names
+                    if queue_name not in cls._registered_senders:
+                        raise ValueError(f"发送器 {queue_name} 未注册")
+
+                sender = RabbitMQService.get_sender(queue_name)
+                if not sender:
+                    raise ValueError(f"发送器 '{queue_name}' 不存在")
+
+                await RabbitMQService.send_message(data, queue_name, **kwargs)
+                logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
+                return
+
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    logging.error(
+                        f"消息发送失败（已尝试 {max_retries} 次）: {str(e)}", exc_info=True)
+                    raise
+
+                logging.warning(
+                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，"
+                    f"{retry_delay}秒后重试..."
+                )
+                await asyncio.sleep(retry_delay)
+
+    @staticmethod
+    async def shutdown():
+        """关闭所有服务"""
+        # 取消所有MQ任务
+        for task in Services._mq_tasks:
+            if not task.done():
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+
+        # 关闭RabbitMQ服务
+        await RabbitMQService.shutdown()

{sycommon_python_lib-0.1.8 → sycommon_python_lib-0.1.9}/src/sycommon_python_lib.egg-info/PKG-INFO

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

sycommon_python_lib-0.1.8/src/sycommon/services.py

@@ -1,217 +0,0 @@
-from typing import Any, Callable, Dict, List, Tuple, Union, Optional, Awaitable
-import asyncio
-import logging
-from contextlib import asynccontextmanager
-from dotenv import load_dotenv
-from fastapi import FastAPI
-from pydantic import BaseModel
-import yaml
-from sycommon.config.Config import SingletonMeta
-from sycommon.models.mqlistener_config import RabbitMQListenerConfig
-from sycommon.models.mqsend_config import RabbitMQSendConfig
-from sycommon.rabbitmq.rabbitmq_service import RabbitMQService
-
-
-class Services(metaclass=SingletonMeta):
-    _loop: Optional[asyncio.AbstractEventLoop] = None
-    _config: Optional[dict] = None
-    _initialized: bool = False
-    _registered_senders: List[str] = []
-    _mq_tasks: List[asyncio.Task] = []
-    _pending_setup: Optional[Callable[..., Awaitable[None]]] = None
-    _instance: Optional['Services'] = None
-
-    def __init__(self, config):
-        if not Services._config:
-            Services._config = config
-        Services._instance = self
-
-    @classmethod
-    def get_lifespan(cls, config):
-        """返回 FastAPI 的 lifespan 管理器"""
-        cls._config = config
-
-        @asynccontextmanager
-        async def lifespan(app):
-            # 应用启动时初始化
-            cls._loop = asyncio.get_running_loop()
-            cls._initialized = True
-            logging.info("Services initialized with FastAPI event loop")
-
-            # 执行之前缓存的MQ设置
-            if cls._pending_setup:
-                try:
-                    await cls._pending_setup()
-                except Exception as e:
-                    logging.error(f"执行MQ初始化失败: {str(e)}", exc_info=True)
-                finally:
-                    cls._pending_setup = None
-
-            try:
-                yield
-            finally:
-                # 应用关闭时清理
-                await cls.shutdown()
-                logging.info("Services shutdown completed")
-
-        return lifespan
-
-    @classmethod
-    def plugins(cls,
-                middleware: Optional[Tuple[Callable, FastAPI]] = None,
-                nacos_service: Optional[Callable] = None,
-                logging_service: Optional[Callable] = None,
-                database_service: Optional[Union[Tuple[Callable, str],
-                                                 List[Tuple[Callable, str]]]] = None,
-                rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
-                rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None
-                ) -> None:
-        """
-        类方法：注册各种服务插件
-        确保单例实例存在后调用实例方法的register_plugins
-        """
-        # 确保实例已创建
-        if not cls._instance:
-            if not cls._config:
-                raise ValueError("Services尚未初始化，请先提供配置")
-            cls._instance = Services(cls._config)
-
-        cls._instance.register_plugins(
-            middleware=middleware,
-            nacos_service=nacos_service,
-            logging_service=logging_service,
-            database_service=database_service,
-            rabbitmq_listeners=rabbitmq_listeners,
-            rabbitmq_senders=rabbitmq_senders
-        )
-
-    def register_plugins(
-        self,
-        middleware: Optional[Tuple[Callable, FastAPI]] = None,
-        nacos_service: Optional[Callable] = None,
-        logging_service: Optional[Callable] = None,
-        database_service: Optional[Union[Tuple[Callable,
-                                               str], List[Tuple[Callable, str]]]] = None,
-        rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
-        rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None
-    ) -> None:
-        """实例方法：实际执行各种服务插件的注册逻辑"""
-        # 注册非异步服务
-        if middleware:
-            self._setup_middleware(middleware)
-        if nacos_service:
-            nacos_service(self._config)
-        if logging_service:
-            logging_service(self._config)
-        if database_service:
-            self._setup_database(database_service)
-
-        RabbitMQService.init(self._config)
-
-        # MQ设置异步函数
-        async def setup_mq_components():
-            if rabbitmq_senders:
-                self._setup_senders(rabbitmq_senders)
-            if rabbitmq_listeners:
-                self._setup_listeners(rabbitmq_listeners)
-
-        # 存储到_pending_setup，等待lifespan异步执行
-        Services._pending_setup = setup_mq_components
-
-    def _setup_database(self, database_service):
-        if isinstance(database_service, tuple):
-            db_setup, db_name = database_service
-            db_setup(self._config, db_name)
-        elif isinstance(database_service, list):
-            for db_setup, db_name in database_service:
-                db_setup(self._config, db_name)
-
-    def _setup_middleware(self, middleware):
-        if isinstance(middleware, tuple):
-            middleware_setup, app = middleware
-            middleware_setup(app, self._config)
-
-    def _setup_senders(self, rabbitmq_senders):
-        Services._registered_senders = [
-            sender.queue_name for sender in rabbitmq_senders]
-        if self._loop:  # 确保loop存在
-            task = self._loop.create_task(
-                self._setup_and_wait(
-                    RabbitMQService.setup_senders, rabbitmq_senders)
-            )
-            self._mq_tasks.append(task)
-        logging.info(f"已注册的RabbitMQ发送器: {Services._registered_senders}")
-
-    def _setup_listeners(self, rabbitmq_listeners):
-        if self._loop:  # 确保loop存在
-            task = self._loop.create_task(
-                self._setup_and_wait(
-                    RabbitMQService.setup_listeners, rabbitmq_listeners)
-            )
-            self._mq_tasks.append(task)
-
-    async def _setup_and_wait(self, setup_func, *args, **kwargs):
-        try:
-            await setup_func(*args, **kwargs)
-        except Exception as e:
-            logging.error(
-                f"Error in {setup_func.__name__}: {str(e)}", exc_info=True)
-
-    @classmethod
-    async def send_message(
-        cls,
-        queue_name: str,
-        data: Union[str, Dict[str, Any], BaseModel, None],
-        max_retries: int = 3,  # 最大重试次数
-        retry_delay: float = 1.0,  # 重试间隔（秒）
-        **kwargs
-    ) -> None:
-        """发送消息，添加重试机制处理发送器不存在的情况"""
-        if not cls._initialized or not cls._loop:
-            logging.error("Services not properly initialized!")
-            raise ValueError("服务未正确初始化")
-
-        # 重试逻辑
-        for attempt in range(max_retries):
-            try:
-                # 检查发送器是否已注册
-                if queue_name not in cls._registered_senders:
-                    # 可能是初始化尚未完成，尝试刷新注册列表
-                    cls._registered_senders = RabbitMQService.sender_client_names
-                    if queue_name not in cls._registered_senders:
-                        raise ValueError(f"发送器 {queue_name} 未注册")
-
-                # 获取发送器
-                sender = RabbitMQService.get_sender(queue_name)
-                if not sender:
-                    raise ValueError(f"发送器 '{queue_name}' 不存在")
-
-                # 发送消息
-                await RabbitMQService.send_message(data, queue_name, ** kwargs)
-                logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
-                return  # 成功发送，退出函数
-
-            except Exception as e:
-                # 最后一次尝试失败则抛出异常
-                if attempt == max_retries - 1:
-                    logging.error(
-                        f"消息发送失败（已尝试 {max_retries} 次）: {str(e)}", exc_info=True)
-                    raise
-
-                # 非最后一次尝试，记录警告并等待重试
-                logging.warning(
-                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，"
-                    f"{retry_delay}秒后重试..."
-                )
-                await asyncio.sleep(retry_delay)
-
-    @staticmethod
-    async def shutdown():
-        for task in Services._mq_tasks:
-            if not task.done():
-                task.cancel()
-                try:
-                    await task
-                except asyncio.CancelledError:
-                    pass
-        await RabbitMQService.shutdown()