sycommon-python-lib 0.1.56__py3-none-any.whl → 0.1.56b2__py3-none-any.whl

sycommon/services.py

@@ -12,32 +12,30 @@ from sycommon.models.mqlistener_config import RabbitMQListenerConfig
 from sycommon.models.mqsend_config import RabbitMQSendConfig
 from sycommon.rabbitmq.rabbitmq_service import RabbitMQService
 from sycommon.tools.docs import custom_redoc_html, custom_swagger_ui_html
-from sycommon.sentry.sy_sentry import sy_sentry_init
 
 
 class Services(metaclass=SingletonMeta):
     _loop: Optional[asyncio.AbstractEventLoop] = None
     _config: Optional[dict] = None
     _initialized: bool = False
+    _registered_senders: List[str] = []
     _instance: Optional['Services'] = None
     _app: Optional[FastAPI] = None
     _user_lifespan: Optional[Callable] = None
     _shutdown_lock: asyncio.Lock = asyncio.Lock()
 
+    # 用于存储待执行的异步数据库初始化任务
+    _pending_async_db_setup: List[Tuple[Callable, str]] = []
+
     def __init__(self, config: dict, app: FastAPI):
-        super().__init__()
         if not Services._config:
             Services._config = config
         Services._instance = self
         Services._app = app
-
-        # 在实例初始化时定义变量，防止类变量污染
-        self._pending_async_db_setup: List[Tuple[Callable, str]] = []
-
         self._init_event_loop()
 
     def _init_event_loop(self):
-        """初始化事件循环"""
+        """初始化事件循环，确保全局只有一个循环实例"""
         if not Services._loop:
             try:
                 Services._loop = asyncio.get_running_loop()
@@ -64,20 +62,14 @@ class Services(metaclass=SingletonMeta):
         setup_logger_levels()
         cls._app = app
         cls._config = config
-        # 保存原始的用户 lifespan
         cls._user_lifespan = app.router.lifespan_context
 
         applications.get_swagger_ui_html = custom_swagger_ui_html
         applications.get_redoc_html = custom_redoc_html
 
         if not cls._config:
-            try:
-                with open('app.yaml', 'r', encoding='utf-8') as f:
-                    config = yaml.safe_load(f)
-                cls._config = config
-            except FileNotFoundError:
-                logging.warning("未找到 app.yaml，将使用空配置启动")
-                cls._config = {}
+            config = yaml.safe_load(open('app.yaml', 'r', encoding='utf-8'))
+            cls._config = config
 
         app.state.config = {
             "host": cls._config.get('Host', '0.0.0.0'),
@@ -87,95 +79,94 @@ class Services(metaclass=SingletonMeta):
         }
 
         if middleware:
-            middleware(app, cls._config)
+            middleware(app, config)
 
         if nacos_service:
-            nacos_service(cls._config)
+            nacos_service(config)
 
         if logging_service:
-            logging_service(cls._config)
-
-        sy_sentry_init()
-
+            logging_service(config)
+
+        # ========== 处理数据库服务 ==========
+        # 清空之前的待执行列表（防止热重载时重复）
+        cls._pending_async_db_setup = []
+
+        if database_service:
+            # 解析配置并区分同步/异步
+            items = [database_service] if isinstance(
+                database_service, tuple) else database_service
+            for item in items:
+                db_setup_func, db_name = item
+                if asyncio.iscoroutinefunction(db_setup_func):
+                    # 如果是异步函数，加入待执行列表
+                    logging.info(f"检测到异步数据库服务: {db_name}，将在应用启动时初始化")
+                    cls._pending_async_db_setup.append(item)
+                else:
+                    # 如果是同步函数，立即执行
+                    logging.info(f"执行同步数据库服务: {db_name}")
+                    try:
+                        db_setup_func(config, db_name)
+                    except Exception as e:
+                        logging.error(
+                            f"同步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                        raise
+
+        # 创建组合生命周期管理器
         @asynccontextmanager
-        async def combined_lifespan(app_instance: FastAPI) -> AsyncGenerator[None, None]:
-            # 获取 Services 实例
-            instance = cls(config, app_instance)
+        async def combined_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+            # 1. 执行Services自身的初始化
+            instance = cls(config, app)
+
+            # ========== 执行挂起的异步数据库初始化 ==========
+            if cls._pending_async_db_setup:
+                logging.info("开始执行异步数据库初始化...")
+                for db_setup_func, db_name in cls._pending_async_db_setup:
+                    try:
+                        await db_setup_func(config, db_name)
+                        logging.info(f"异步数据库服务 {db_name} 初始化成功")
+                    except Exception as e:
+                        logging.error(
+                            f"异步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                        raise
+
+            # ========== 初始化 MQ ==========
+            has_valid_listeners = bool(
+                rabbitmq_listeners and len(rabbitmq_listeners) > 0)
+            has_valid_senders = bool(
+                rabbitmq_senders and len(rabbitmq_senders) > 0)
 
             try:
-                # 1. 处理数据库服务
-                if database_service:
-                    instance._pending_async_db_setup = []
-
-                    items = [database_service] if isinstance(
-                        database_service, tuple) else database_service
-                    for item in items:
-                        db_setup_func, db_name = item
-                        if asyncio.iscoroutinefunction(db_setup_func):
-                            logging.info(f"注册异步数据库服务: {db_name}")
-                            instance._pending_async_db_setup.append(item)
-                        else:
-                            logging.info(f"执行同步数据库服务: {db_name}")
-                            try:
-                                db_setup_func(config, db_name)
-                            except Exception as e:
-                                logging.error(
-                                    f"同步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
-                                raise
-
-                # 2. 执行挂起的异步数据库初始化
-                if instance._pending_async_db_setup:
-                    logging.info("开始执行异步数据库初始化...")
-                    for db_setup_func, db_name in instance._pending_async_db_setup:
-                        try:
-                            await db_setup_func(config, db_name)
-                            logging.info(f"异步数据库服务 {db_name} 初始化成功")
-                        except Exception as e:
-                            logging.error(
-                                f"异步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
-                            raise
-
-                # 3. 初始化 MQ
-                has_valid_listeners = bool(
-                    rabbitmq_listeners and len(rabbitmq_listeners) > 0)
-                has_valid_senders = bool(
-                    rabbitmq_senders and len(rabbitmq_senders) > 0)
-
-                try:
-                    if has_valid_listeners or has_valid_senders:
-                        await instance._setup_mq_async(
-                            rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
-                            rabbitmq_senders=rabbitmq_senders if has_valid_senders else None,
-                            has_listeners=has_valid_listeners,
-                            has_senders=has_valid_senders
-                        )
-                    cls._initialized = True
-                    logging.info("Services初始化完成")
-                except Exception as e:
-                    logging.error(f"MQ初始化失败: {str(e)}", exc_info=True)
-                    raise
+                if has_valid_listeners or has_valid_senders:
+                    await instance._setup_mq_async(
+                        rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
+                        rabbitmq_senders=rabbitmq_senders if has_valid_senders else None,
+                        has_listeners=has_valid_listeners,
+                        has_senders=has_valid_senders
+                    )
+                cls._initialized = True
+                logging.info("Services初始化完成")
+            except Exception as e:
+                logging.error(f"Services初始化失败: {str(e)}", exc_info=True)
+                raise
 
-                app_instance.state.services = instance
+            app.state.services = instance
 
-                # 4. 执行用户定义的生命周期
-                if cls._user_lifespan:
-                    async with cls._user_lifespan(app_instance):
-                        yield
-                else:
+            # 2. 执行用户定义的生命周期
+            if cls._user_lifespan:
+                async with cls._user_lifespan(app):
                     yield
+            else:
+                yield
 
-            except Exception:
-                # 如果启动过程中发生任何异常，确保进入 shutdown
-                logging.error("启动阶段发生异常，准备执行清理...")
-                raise
-            finally:
-                # 无论成功或失败，都会执行关闭逻辑
-                await cls.shutdown()
-                logging.info("Services已关闭")
+            # 3. 执行Services的关闭逻辑
+            await cls.shutdown()
+            logging.info("Services已关闭")
 
         app.router.lifespan_context = combined_lifespan
         return app
 
+    # 移除了 _setup_database_static，因为逻辑已内联到 plugins 中
+
     async def _setup_mq_async(
         self,
         rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
@@ -191,21 +182,12 @@ class Services(metaclass=SingletonMeta):
         RabbitMQService.init(self._config, has_listeners, has_senders)
 
         start_time = asyncio.get_event_loop().time()
-        timeout = 30  # 超时时间秒
-
-        # 等待连接池初始化
-        while not (RabbitMQService._connection_pool and RabbitMQService._connection_pool._initialized) \
-                and not RabbitMQService._is_shutdown:
-            if asyncio.get_event_loop().time() - start_time > timeout:
-                logging.error("RabbitMQ连接池初始化超时")
-                raise TimeoutError(f"RabbitMQ连接池初始化超时（{timeout}秒）")
-
-            logging.debug("等待RabbitMQ连接池初始化...")
+        while not (RabbitMQService._connection_pool and RabbitMQService._connection_pool._initialized) and not RabbitMQService._is_shutdown:
+            if asyncio.get_event_loop().time() - start_time > 30:
+                raise TimeoutError("RabbitMQ连接池初始化超时（30秒）")
+            logging.info("等待RabbitMQ连接池初始化...")
             await asyncio.sleep(0.5)
 
-        if RabbitMQService._is_shutdown:
-            raise RuntimeError("RabbitMQService 在初始化期间被关闭")
-
         if has_senders and rabbitmq_senders:
             if has_listeners and rabbitmq_listeners:
                 for sender in rabbitmq_senders:
@@ -225,8 +207,11 @@ class Services(metaclass=SingletonMeta):
 
     async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
         """设置发送器"""
+        Services._registered_senders = [
+            sender.queue_name for sender in rabbitmq_senders]
         await RabbitMQService.setup_senders(rabbitmq_senders, has_listeners)
-        logging.info(f"RabbitMQ发送器注册完成")
+        Services._registered_senders = RabbitMQService._sender_client_names
+        logging.info(f"已注册的RabbitMQ发送器: {Services._registered_senders}")
 
     async def _setup_listeners_async(self, rabbitmq_listeners, has_senders: bool):
         """设置监听器"""
@@ -251,12 +236,14 @@ class Services(metaclass=SingletonMeta):
 
         for attempt in range(max_retries):
             try:
-                # 依赖 RabbitMQService 的内部状态
-                sender = await RabbitMQService.get_sender(queue_name)
+                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 = await RabbitMQService.get_sender(queue_name)
                 if not sender:
-                    raise ValueError(
-                        f"发送器 '{queue_name}' 不存在或未在 RabbitMQService 中注册")
+                    raise ValueError(f"发送器 '{queue_name}' 不存在或连接无效")
 
                 await RabbitMQService.send_message(data, queue_name, **kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
@@ -278,20 +265,7 @@ class Services(metaclass=SingletonMeta):
             if RabbitMQService._is_shutdown:
                 logging.info("RabbitMQService已关闭，无需重复操作")
                 return
-
-            try:
-                await RabbitMQService.shutdown()
-            except Exception as e:
-                logging.error(f"关闭 RabbitMQService 时发生异常: {e}", exc_info=True)
-
+            await RabbitMQService.shutdown()
             cls._initialized = False
-
-            # 清理实例数据
-            if cls._instance:
-                cls._instance._pending_async_db_setup.clear()
-
-            # 这对于热重载（reload）时防止旧实例内存泄漏至关重要
-            if cls._app:
-                cls._app.state.services = None
-
+            cls._registered_senders.clear()
             logging.info("所有服务已关闭")