jettask 0.2.23__py3-none-any.whl → 0.2.24__py3-none-any.whl

jettask/webui/services/redis_monitor_service.py

@@ -0,0 +1,87 @@
+"""
+Redis 监控基础服务
+
+提供 Redis 连接管理和基础功能
+"""
+import asyncio
+import logging
+from typing import Optional
+import redis.asyncio as aioredis
+
+logger = logging.getLogger(__name__)
+
+
+class RedisMonitorService:
+    """Redis 监控基础服务类"""
+
+    def __init__(self, redis_url: str = "redis://localhost:6379", redis_prefix: str = "jettask"):
+        """
+        初始化 Redis 监控服务
+
+        Args:
+            redis_url: Redis 连接URL
+            redis_prefix: Redis 键前缀
+        """
+        self.redis_url = redis_url
+        self.redis_prefix = redis_prefix
+        self.redis: Optional[aioredis.Redis] = None
+        self.worker_state_manager = None  # 延迟初始化
+
+        # 缓存配置
+        self._queues_cache = None
+        self._queues_cache_time = 0
+        self._queues_cache_ttl = 60  # 缓存60秒
+
+        self._workers_cache = None
+        self._workers_cache_time = 0
+        self._workers_cache_ttl = 5  # worker缓存5秒，因为更新频繁
+
+    async def connect(self):
+        """连接到 Redis"""
+        from jettask.db.connector import get_async_redis_pool
+
+        pool = get_async_redis_pool(
+            self.redis_url,
+            decode_responses=True,
+            max_connections=100,
+            socket_connect_timeout=5,
+            socket_timeout=10,
+            socket_keepalive=True,
+            health_check_interval=30
+        )
+        self.redis = aioredis.Redis(connection_pool=pool)
+
+        # 初始化 WorkerStateManager
+        from jettask.worker.lifecycle import WorkerStateManager
+        self.worker_state_manager = WorkerStateManager(
+            redis_client=self.redis,
+            redis_prefix=self.redis_prefix
+        )
+        logger.info(f"Redis 监控服务已连接: {self.redis_url}")
+
+    async def close(self):
+        """关闭 Redis 连接"""
+        if self.redis:
+            await self.redis.close()
+            logger.info("Redis 监控服务已关闭")
+
+    def get_prefixed_queue_name(self, queue_name: str) -> str:
+        """
+        为队列名称添加前缀
+
+        Args:
+            queue_name: 原始队列名称
+
+        Returns:
+            带前缀的队列名称
+        """
+        return f"{self.redis_prefix}:QUEUE:{queue_name}"
+
+    async def __aenter__(self):
+        """异步上下文管理器入口"""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """异步上下文管理器退出"""
+        await self.close()

jettask/webui/services/settings_service.py

@@ -9,7 +9,8 @@ from datetime import datetime
 from sqlalchemy import text
 from urllib.parse import urlparse
 
-from jettask.persistence.db_manager import get_db_manager
+from jettask.db.connector import get_async_redis_client, get_pg_engine_and_factory
+from jettask.config.task_center import task_center_config
 from jettask.schemas import (
     ConfigMode,
     NamespaceCreate,
@@ -111,8 +112,9 @@ class SettingsService:
         Returns:
             命名空间列表
         """
-        db_manager = get_db_manager()
-        async with db_manager.get_master_session() as session:
+        # 获取元数据库会话
+        _, session_factory = get_pg_engine_and_factory(task_center_config.meta_database_url)
+        async with session_factory() as session:
             query = """
                 SELECT id, name, description, redis_config, pg_config, 
                        is_active, version, created_at, updated_at
@@ -137,36 +139,45 @@ class SettingsService:
                 # 构建响应
                 redis_config_dict = row.redis_config if row.redis_config else {}
                 pg_config_dict = row.pg_config if row.pg_config else {}
-                
-                # 根据配置模式获取实际的URL
-                config_mode = redis_config_dict.get('config_mode', 'direct')
-                
-                # 获取Redis URL
-                if config_mode == 'nacos' and redis_config_dict.get('nacos_key'):
-                    try:
-                        redis_url = await SettingsService.get_config_from_nacos(redis_config_dict['nacos_key'])
-                    except Exception as e:
-                        logger.error(f"从Nacos获取Redis URL失败: {e} {row.name}")
-                        redis_url = redis_config_dict.get('url', '')
+
+                # 获取配置模式
+                redis_config_mode = redis_config_dict.get('config_mode', 'direct')
+                pg_config_mode = pg_config_dict.get('config_mode', 'direct')
+
+                # Redis 配置处理 - 根据模式返回不同内容
+                if redis_config_mode == 'nacos':
+                    # Nacos 模式 - 只返回 nacos_key，不返回真实 URL（保密）
+                    redis_url = None
+                    redis_nacos_key = redis_config_dict.get('nacos_key')
+                    logger.debug(f"命名空间 {row.name} 使用 Nacos 模式，返回 Redis key: {redis_nacos_key}")
                 else:
+                    # Direct 模式 - 返回真实完整的 URL（客户端需要使用）
                     redis_url = redis_config_dict.get('url', '')
-                
-                # 获取PostgreSQL URL
-                pg_url = None
-                if config_mode == 'nacos' and pg_config_dict.get('nacos_key'):
-                    try:
-                        pg_url = await SettingsService.get_config_from_nacos(pg_config_dict['nacos_key'])
-                    except Exception as e:
-                        logger.error(f"从Nacos获取PostgreSQL URL失败: {e} {row.name}")
-                        pg_url = pg_config_dict.get('url')
+                    redis_nacos_key = None
+                    logger.debug(f"命名空间 {row.name} 使用 Direct 模式，返回真实 Redis URL")
+
+                # PostgreSQL 配置处理 - 根据模式返回不同内容
+                if pg_config_mode == 'nacos':
+                    # Nacos 模式 - 只返回 nacos_key，不返回真实 URL（保密）
+                    pg_url = None
+                    pg_nacos_key = pg_config_dict.get('nacos_key')
+                    logger.debug(f"命名空间 {row.name} 使用 Nacos 模式，返回 PG key: {pg_nacos_key}")
                 else:
+                    # Direct 模式 - 返回真实完整的 URL（客户端需要使用）
                     pg_url = pg_config_dict.get('url')
-                
+                    pg_nacos_key = None
+                    if pg_url:
+                        logger.debug(f"命名空间 {row.name} 使用 Direct 模式，返回真实 PG URL")
+
                 response = NamespaceResponse(
                     name=row.name,
                     description=row.description,
                     redis_url=redis_url,
+                    redis_config_mode=redis_config_mode,
+                    redis_nacos_key=redis_nacos_key,
                     pg_url=pg_url,
+                    pg_config_mode=pg_config_mode,
+                    pg_nacos_key=pg_nacos_key,
                     connection_url=f"/api/v1/namespaces/{row.name}",
                     version=row.version or 1,
                     enabled=row.is_active,
@@ -188,8 +199,9 @@ class SettingsService:
         Returns:
             创建的命名空间信息
         """
-        db_manager = get_db_manager()
-        async with db_manager.get_master_session() as session:
+        # 获取元数据库会话
+        _, session_factory = get_pg_engine_and_factory(task_center_config.meta_database_url)
+        async with session_factory() as session:
             # 检查命名空间是否已存在
             check_query = text("SELECT COUNT(*) FROM namespaces WHERE name = :name")
             result = await session.execute(check_query, {'name': namespace.name})
@@ -264,19 +276,44 @@ class SettingsService:
             
             row = result.fetchone()
             await session.commit()
-            
-            # 构建响应 - 只返回最终的URL，不返回配置细节
-            response = NamespaceResponse(
-                name=row.name,
-                description=row.description,
-                redis_url=redis_config['url'],  # 这里已经是最终的URL
-                pg_url=pg_config.get('url', '') if pg_config.get('url') else None,
-                connection_url=f"/api/v1/namespaces/{row.name}",
-                version=row.version or 1,
-                enabled=row.is_active,
-                created_at=row.created_at,
-                updated_at=row.updated_at
-            )
+
+            # 构建响应 - 根据配置模式返回不同内容
+            config_mode_str = namespace.config_mode.value
+
+            if namespace.config_mode == ConfigMode.NACOS:
+                # Nacos 模式 - 只返回 nacos_key，不返回真实 URL（保密）
+                response = NamespaceResponse(
+                    name=row.name,
+                    description=row.description,
+                    redis_url=None,
+                    redis_config_mode=config_mode_str,
+                    redis_nacos_key=redis_config.get('nacos_key'),
+                    pg_url=None,
+                    pg_config_mode=config_mode_str,
+                    pg_nacos_key=pg_config.get('nacos_key'),
+                    connection_url=f"/api/v1/namespaces/{row.name}",
+                    version=row.version or 1,
+                    enabled=row.is_active,
+                    created_at=row.created_at,
+                    updated_at=row.updated_at
+                )
+            else:
+                # Direct 模式 - 返回真实完整的 URL（客户端需要使用）
+                response = NamespaceResponse(
+                    name=row.name,
+                    description=row.description,
+                    redis_url=redis_config.get('url'),
+                    redis_config_mode=config_mode_str,
+                    redis_nacos_key=None,
+                    pg_url=pg_config.get('url'),
+                    pg_config_mode=config_mode_str,
+                    pg_nacos_key=None,
+                    connection_url=f"/api/v1/namespaces/{row.name}",
+                    version=row.version or 1,
+                    enabled=row.is_active,
+                    created_at=row.created_at,
+                    updated_at=row.updated_at
+                )
             
             logger.info(f"成功创建命名空间: {namespace.name}")
             return response
@@ -292,10 +329,11 @@ class SettingsService:
         Returns:
             命名空间信息
         """
-        db_manager = get_db_manager()
-        async with db_manager.get_master_session() as session:
+        # 获取元数据库会话
+        _, session_factory = get_pg_engine_and_factory(task_center_config.meta_database_url)
+        async with session_factory() as session:
             query = text("""
-                SELECT id, name, description, redis_config, pg_config, 
+                SELECT id, name, description, redis_config, pg_config,
                        is_active, version, created_at, updated_at
                 FROM namespaces
                 WHERE name = :name
@@ -306,40 +344,49 @@ class SettingsService:
             
             if not row:
                 raise ValueError(f"命名空间 '{namespace_name}' 不存在")
-            
+
             # 构建响应
             redis_config_dict = row.redis_config if row.redis_config else {}
             pg_config_dict = row.pg_config if row.pg_config else {}
-            
-            # 根据配置模式获取实际的URL
-            config_mode = redis_config_dict.get('config_mode', 'direct')
-            
-            # 获取Redis URL
-            if config_mode == 'nacos' and redis_config_dict.get('nacos_key'):
-                try:
-                    redis_url = await SettingsService.get_config_from_nacos(redis_config_dict['nacos_key'])
-                except Exception as e:
-                    logger.error(f"从Nacos获取Redis URL失败: {e}")
-                    redis_url = redis_config_dict.get('url', '')
+
+            # 获取配置模式
+            redis_config_mode = redis_config_dict.get('config_mode', 'direct')
+            pg_config_mode = pg_config_dict.get('config_mode', 'direct')
+
+            # Redis 配置处理 - 根据模式返回不同内容
+            if redis_config_mode == 'nacos':
+                # Nacos 模式 - 只返回 nacos_key，不返回真实 URL（保密）
+                redis_url = None
+                redis_nacos_key = redis_config_dict.get('nacos_key')
+                logger.debug(f"命名空间 {namespace_name} 使用 Nacos 模式，返回 Redis key: {redis_nacos_key}")
             else:
+                # Direct 模式 - 返回真实完整的 URL（客户端需要使用）
                 redis_url = redis_config_dict.get('url', '')
-            
-            # 获取PostgreSQL URL  
-            pg_url = None
-            if config_mode == 'nacos' and pg_config_dict.get('nacos_key'):
-                try:
-                    pg_url = await SettingsService.get_config_from_nacos(pg_config_dict['nacos_key'])
-                except Exception as e:
-                    logger.error(f"从Nacos获取PostgreSQL URL失败: {e}")
-                    pg_url = pg_config_dict.get('url')
+                redis_nacos_key = None
+                logger.debug(f"命名空间 {namespace_name} 使用 Direct 模式，返回真实 Redis URL")
+
+            # PostgreSQL 配置处理 - 根据模式返回不同内容
+            if pg_config_mode == 'nacos':
+                # Nacos 模式 - 只返回 nacos_key，不返回真实 URL（保密）
+                pg_url = None
+                pg_nacos_key = pg_config_dict.get('nacos_key')
+                logger.debug(f"命名空间 {namespace_name} 使用 Nacos 模式，返回 PG key: {pg_nacos_key}")
             else:
+                # Direct 模式 - 返回真实完整的 URL（客户端需要使用）
                 pg_url = pg_config_dict.get('url')
-            
+                pg_nacos_key = None
+                if pg_url:
+                    logger.debug(f"命名空间 {namespace_name} 使用 Direct 模式，返回真实 PG URL")
+
             response = NamespaceResponse(
                 name=row.name,
                 description=row.description,
                 redis_url=redis_url,
+                redis_config_mode=redis_config_mode,
+                redis_nacos_key=redis_nacos_key,
                 pg_url=pg_url,
+                pg_config_mode=pg_config_mode,
+                pg_nacos_key=pg_nacos_key,
                 connection_url=f"/api/v1/namespaces/{row.name}",
                 version=row.version or 1,
                 enabled=row.is_active,
@@ -361,8 +408,9 @@ class SettingsService:
         Returns:
             更新后的命名空间信息
         """
-        db_manager = get_db_manager()
-        async with db_manager.get_master_session() as session:
+        # 获取元数据库会话
+        _, session_factory = get_pg_engine_and_factory(task_center_config.meta_database_url)
+        async with session_factory() as session:
             # 检查命名空间是否存在
             check_query = text("""
                 SELECT id, redis_config, pg_config FROM namespaces WHERE name = :name
@@ -510,40 +558,49 @@ class SettingsService:
             result = await session.execute(update_query, params)
             updated_row = result.fetchone()
             await session.commit()
-            
+
             # 构建响应
-            redis_config_dict = updated_row.redis_config
+            redis_config_dict = updated_row.redis_config if updated_row.redis_config else {}
             pg_config_dict = updated_row.pg_config if updated_row.pg_config else {}
-            
-            # 根据配置模式获取实际的URL
-            config_mode = redis_config_dict.get('config_mode', 'direct')
-            
-            # 获取Redis URL
-            if config_mode == 'nacos' and redis_config_dict.get('nacos_key'):
-                try:
-                    redis_url = await SettingsService.get_config_from_nacos(redis_config_dict['nacos_key'])
-                except Exception as e:
-                    logger.error(f"从Nacos获取Redis URL失败: {e}")
-                    redis_url = redis_config_dict.get('url', '')
+
+            # 获取配置模式
+            redis_config_mode = redis_config_dict.get('config_mode', 'direct')
+            pg_config_mode = pg_config_dict.get('config_mode', 'direct')
+
+            # Redis 配置处理 - 根据模式返回不同内容
+            if redis_config_mode == 'nacos':
+                # Nacos 模式 - 只返回 nacos_key，不返回真实 URL（保密）
+                redis_url = None
+                redis_nacos_key = redis_config_dict.get('nacos_key')
+                logger.debug(f"更新后命名空间 {namespace_name} 使用 Nacos 模式，返回 Redis key: {redis_nacos_key}")
             else:
+                # Direct 模式 - 返回真实完整的 URL（客户端需要使用）
                 redis_url = redis_config_dict.get('url', '')
-            
-            # 获取PostgreSQL URL
-            pg_url = None
-            if config_mode == 'nacos' and pg_config_dict.get('nacos_key'):
-                try:
-                    pg_url = await SettingsService.get_config_from_nacos(pg_config_dict['nacos_key'])
-                except Exception as e:
-                    logger.error(f"从Nacos获取PostgreSQL URL失败: {e}")
-                    pg_url = pg_config_dict.get('url')
+                redis_nacos_key = None
+                logger.debug(f"更新后命名空间 {namespace_name} 使用 Direct 模式，返回真实 Redis URL")
+
+            # PostgreSQL 配置处理 - 根据模式返回不同内容
+            if pg_config_mode == 'nacos':
+                # Nacos 模式 - 只返回 nacos_key，不返回真实 URL（保密）
+                pg_url = None
+                pg_nacos_key = pg_config_dict.get('nacos_key')
+                logger.debug(f"更新后命名空间 {namespace_name} 使用 Nacos 模式，返回 PG key: {pg_nacos_key}")
             else:
+                # Direct 模式 - 返回真实完整的 URL（客户端需要使用）
                 pg_url = pg_config_dict.get('url')
-            
+                pg_nacos_key = None
+                if pg_url:
+                    logger.debug(f"更新后命名空间 {namespace_name} 使用 Direct 模式，返回真实 PG URL")
+
             response = NamespaceResponse(
                 name=updated_row.name,
                 description=updated_row.description,
                 redis_url=redis_url,
+                redis_config_mode=redis_config_mode,
+                redis_nacos_key=redis_nacos_key,
                 pg_url=pg_url,
+                pg_config_mode=pg_config_mode,
+                pg_nacos_key=pg_nacos_key,
                 connection_url=f"/api/v1/namespaces/{updated_row.name}",
                 version=updated_row.version or 1,
                 enabled=updated_row.is_active,
@@ -567,9 +624,10 @@ class SettingsService:
         """
         if namespace_name == 'default':
             raise ValueError("不能删除默认命名空间")
-        
-        db_manager = get_db_manager()
-        async with db_manager.get_master_session() as session:
+
+        # 获取元数据库会话
+        _, session_factory = get_pg_engine_and_factory(task_center_config.meta_database_url)
+        async with session_factory() as session:
             # 检查命名空间是否存在
             check_query = text("SELECT id FROM namespaces WHERE name = :name")
             result = await session.execute(check_query, {'name': namespace_name})
@@ -596,11 +654,12 @@ class SettingsService:
         Returns:
             激活结果
         """
-        db_manager = get_db_manager()
-        async with db_manager.get_master_session() as session:
+        # 获取元数据库会话
+        _, session_factory = get_pg_engine_and_factory(task_center_config.meta_database_url)
+        async with session_factory() as session:
             # 检查并激活命名空间
             update_query = text("""
-                UPDATE namespaces 
+                UPDATE namespaces
                 SET is_active = true, updated_at = CURRENT_TIMESTAMP
                 WHERE name = :name
             """)
@@ -628,12 +687,13 @@ class SettingsService:
         """
         if namespace_name == 'default':
             raise ValueError("不能停用默认命名空间")
-        
-        db_manager = get_db_manager()
-        async with db_manager.get_master_session() as session:
+
+        # 获取元数据库会话
+        _, session_factory = get_pg_engine_and_factory(task_center_config.meta_database_url)
+        async with session_factory() as session:
             # 检查并停用命名空间
             update_query = text("""
-                UPDATE namespaces 
+                UPDATE namespaces
                 SET is_active = false, updated_at = CURRENT_TIMESTAMP
                 WHERE name = :name
             """)
@@ -652,18 +712,18 @@ class SettingsService:
     async def get_namespace_statistics(namespace_name: str) -> Dict[str, Any]:
         """
         获取命名空间统计信息
-        
+
         Args:
             namespace_name: 命名空间名称
-            
+
         Returns:
-            统计信息
+            统计信息（符合 NamespaceStatisticsResponse 格式）
         """
         # 这里可以根据实际需求实现统计逻辑
         # 暂时返回模拟数据
         return {
-            "namespace": namespace_name,
-            "statistics": {
+            "success": True,
+            "data": {
                 "total_queues": 0,
                 "total_tasks": 0,
                 "active_workers": 0,
@@ -672,6 +732,7 @@ class SettingsService:
                 "completed_tasks": 0,
                 "failed_tasks": 0
             },
+            "namespace": namespace_name,
             "timestamp": datetime.now().isoformat()
         }
     
@@ -686,11 +747,12 @@ class SettingsService:
         Returns:
             激活结果
         """
-        db_manager = get_db_manager()
-        async with db_manager.get_master_session() as session:
+        # 获取元数据库会话
+        _, session_factory = get_pg_engine_and_factory(task_center_config.meta_database_url)
+        async with session_factory() as session:
             # 批量激活
             update_query = text("""
-                UPDATE namespaces 
+                UPDATE namespaces
                 SET is_active = true, updated_at = CURRENT_TIMESTAMP
                 WHERE name = ANY(:names)
             """)
@@ -726,12 +788,13 @@ class SettingsService:
                 "namespaces": [],
                 "skipped": ["default"]
             }
-        
-        db_manager = get_db_manager()
-        async with db_manager.get_master_session() as session:
+
+        # 获取元数据库会话
+        _, session_factory = get_pg_engine_and_factory(task_center_config.meta_database_url)
+        async with session_factory() as session:
             # 批量停用
             update_query = text("""
-                UPDATE namespaces 
+                UPDATE namespaces
                 SET is_active = false, updated_at = CURRENT_TIMESTAMP
                 WHERE name = ANY(:names)
             """)