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

jettask/utils/namespace_dep.py

@@ -0,0 +1,167 @@
+"""
+命名空间依赖注入工具
+提供统一的命名空间参数处理和数据库连接管理
+"""
+import logging
+from typing import Optional
+from fastapi import Depends, HTTPException, Path, Request
+from jettask.core.namespace import NamespaceConnection, NamespaceDataAccessManager
+
+logger = logging.getLogger(__name__)
+
+
+class NamespaceContext:
+    """
+    命名空间上下文对象
+    封装命名空间的所有信息和数据库连接
+    """
+
+    def __init__(
+        self,
+        namespace_name: str,
+        connection: NamespaceConnection,
+        manager: NamespaceDataAccessManager
+    ):
+        self.namespace_name = namespace_name
+        self.connection = connection
+        self.manager = manager
+
+    async def get_redis_client(self, decode: bool = True):
+        """获取 Redis 客户端"""
+        return await self.connection.get_redis_client(decode=decode)
+
+    async def get_pg_session(self):
+        """获取 PostgreSQL 会话"""
+        return await self.connection.get_pg_session()
+
+    @property
+    def redis_prefix(self) -> str:
+        """获取 Redis 键前缀"""
+        return self.connection.redis_prefix
+
+    @property
+    def redis_config(self) -> dict:
+        """获取 Redis 配置"""
+        return self.connection.redis_config
+
+    @property
+    def pg_config(self) -> dict:
+        """获取 PostgreSQL 配置"""
+        return self.connection.pg_config
+
+
+def get_namespace_manager(request: Request) -> NamespaceDataAccessManager:
+    """
+    获取命名空间数据访问管理器
+    从 app.state 中获取全局实例
+    """
+    if not hasattr(request.app.state, 'namespace_data_access'):
+        raise HTTPException(
+            status_code=500,
+            detail="Namespace data access not initialized"
+        )
+
+    # namespace_data_access 是 NamespaceJetTaskDataAccess 实例
+    # 它包含一个 manager 属性
+    return request.app.state.namespace_data_access.manager
+
+
+async def get_namespace_context(
+    namespace: str = Path(..., description="命名空间名称", example="default"),
+    manager: NamespaceDataAccessManager = Depends(get_namespace_manager)
+) -> NamespaceContext:
+    """
+    获取命名空间上下文（依赖注入函数）
+
+    这个函数会：
+    1. 从路径参数中提取 namespace 名称
+    2. 从任务中心API或Nacos获取命名空间配置
+    3. 建立数据库连接（Redis + PostgreSQL）
+    4. 返回封装好的命名空间上下文对象
+
+    使用示例：
+    ```python
+    @router.get("/{namespace}/queues")
+    async def get_queues(
+        ns: NamespaceContext = Depends(get_namespace_context)
+    ):
+        # 直接使用 ns 对象访问数据库
+        redis_client = await ns.get_redis_client()
+        # ... 执行操作
+        return {"namespace": ns.namespace_name}
+    ```
+
+    Args:
+        namespace: 从路径参数中提取的命名空间名称
+        manager: 命名空间数据访问管理器（自动注入）
+
+    Returns:
+        NamespaceContext: 命名空间上下文对象
+
+    Raises:
+        HTTPException: 当命名空间不存在或配置错误时
+    """
+    try:
+        # 获取命名空间的数据库连接
+        connection = await manager.get_connection(namespace)
+
+        # 创建并返回上下文对象
+        return NamespaceContext(
+            namespace_name=namespace,
+            connection=connection,
+            manager=manager
+        )
+
+    except ValueError as e:
+        logger.error(f"命名空间 '{namespace}' 配置错误: {e}")
+        raise HTTPException(
+            status_code=404,
+            detail=f"命名空间 '{namespace}' 不存在或配置错误"
+        )
+    except Exception as e:
+        logger.error(f"获取命名空间 '{namespace}' 上下文失败: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"获取命名空间连接失败: {str(e)}"
+        )
+
+
+# 为了向后兼容，提供一个简化的依赖函数
+async def get_namespace_connection(
+    namespace: str = Path(..., description="命名空间名称", example="default"),
+    manager: NamespaceDataAccessManager = Depends(get_namespace_manager)
+) -> NamespaceConnection:
+    """
+    获取命名空间数据库连接（简化版本）
+
+    直接返回 NamespaceConnection 对象，适用于简单场景
+
+    Args:
+        namespace: 命名空间名称
+        manager: 命名空间数据访问管理器
+
+    Returns:
+        NamespaceConnection: 数据库连接对象
+    """
+    try:
+        return await manager.get_connection(namespace)
+    except ValueError as e:
+        logger.error(f"命名空间 '{namespace}' 配置错误: {e}")
+        raise HTTPException(
+            status_code=404,
+            detail=f"命名空间 '{namespace}' 不存在或配置错误"
+        )
+    except Exception as e:
+        logger.error(f"获取命名空间 '{namespace}' 连接失败: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"获取命名空间连接失败: {str(e)}"
+        )
+
+
+__all__ = [
+    'NamespaceContext',
+    'get_namespace_context',
+    'get_namespace_connection',
+    'get_namespace_manager'
+]

jettask/utils/queue_matcher.py

@@ -0,0 +1,186 @@
+"""
+队列通配符匹配工具
+
+提供队列名称的通配符匹配功能，支持动态队列发现场景。
+"""
+
+import fnmatch
+from typing import List, Dict, Set, Tuple
+
+
+def is_wildcard_pattern(queue: str) -> bool:
+    """
+    检查队列名是否包含通配符
+
+    Args:
+        queue: 队列名称
+
+    Returns:
+        bool: 如果包含 * 或 ? 通配符则返回 True
+
+    Examples:
+        >>> is_wildcard_pattern('robust_*')
+        True
+        >>> is_wildcard_pattern('test?')
+        True
+        >>> is_wildcard_pattern('normal_queue')
+        False
+    """
+    return '*' in queue or '?' in queue
+
+
+def separate_wildcard_and_static_queues(queues: List[str]) -> Tuple[List[str], List[str]]:
+    """
+    分离通配符队列和静态队列
+
+    Args:
+        queues: 队列列表
+
+    Returns:
+        tuple: (wildcard_patterns, static_queues)
+            - wildcard_patterns: 包含通配符的队列模式列表
+            - static_queues: 不包含通配符的静态队列列表
+
+    Examples:
+        >>> separate_wildcard_and_static_queues(['test*', 'robot', 'data?'])
+        (['test*', 'data?'], ['robot'])
+    """
+    wildcard_patterns = []
+    static_queues = []
+
+    for queue in queues:
+        if is_wildcard_pattern(queue):
+            wildcard_patterns.append(queue)
+        else:
+            static_queues.append(queue)
+
+    return wildcard_patterns, static_queues
+
+
+def match_queue_to_pattern(queue: str, patterns: List[str]) -> str:
+    """
+    将实际队列名匹配到通配符模式
+
+    Args:
+        queue: 实际队列名，如 'robust_bench2'
+        patterns: 通配符模式列表，如 ['robust_*', 'test*']
+
+    Returns:
+        str: 匹配到的模式，如果没有匹配则返回 None
+
+    Examples:
+        >>> match_queue_to_pattern('robust_bench2', ['robust_*', 'test*'])
+        'robust_*'
+        >>> match_queue_to_pattern('robot', ['robust_*', 'test*'])
+        None
+    """
+    for pattern in patterns:
+        if fnmatch.fnmatch(queue, pattern):
+            return pattern
+    return None
+
+
+def find_matching_tasks(
+    queue: str,
+    tasks_by_queue: Dict[str, List[str]],
+    wildcard_mode: bool = False
+) -> List[str]:
+    """
+    为实际队列名查找对应的任务列表
+
+    支持两种方式：
+    1. 直接匹配：queue 在 tasks_by_queue 的键中
+    2. 通配符匹配：使用通配符模式匹配 tasks_by_queue 的键
+
+    Args:
+        queue: 实际队列名，如 'robust_bench2'
+        tasks_by_queue: 任务映射字典，键可能是通配符，如 {'robust_*': ['task1']}
+        wildcard_mode: 是否启用通配符匹配模式
+
+    Returns:
+        List[str]: 匹配到的任务名称列表
+
+    Examples:
+        >>> tasks_by_queue = {'robust_*': ['benchmark_task'], 'robot': ['clean_task']}
+        >>> find_matching_tasks('robust_bench2', tasks_by_queue, wildcard_mode=True)
+        ['benchmark_task']
+        >>> find_matching_tasks('robot', tasks_by_queue, wildcard_mode=True)
+        ['clean_task']
+    """
+    # 先尝试直接匹配
+    task_names = tasks_by_queue.get(queue, [])
+
+    # 如果没有直接匹配且启用了通配符模式，尝试通配符匹配
+    if not task_names and wildcard_mode:
+        for pattern, pattern_tasks in tasks_by_queue.items():
+            # 检查实际队列名是否匹配 tasks_by_queue 中的通配符模式
+            if fnmatch.fnmatch(queue, pattern):
+                task_names.extend(pattern_tasks)
+
+    return task_names
+
+
+def match_task_queue_to_patterns(
+    task_queue: str,
+    queue_patterns: List[str]
+) -> bool:
+    """
+    检查任务的队列名是否匹配任何队列模式
+
+    Args:
+        task_queue: 任务的队列名（可能是通配符），如 'robust_*'
+        queue_patterns: 队列模式列表（可能包含通配符），如 ['robust_*', 'test']
+
+    Returns:
+        bool: 如果匹配则返回 True
+
+    Examples:
+        >>> match_task_queue_to_patterns('robust_*', ['robust_*'])
+        True
+        >>> match_task_queue_to_patterns('robust_*', ['test*'])
+        True  # 'robust_*' 匹配 'test*' 的模式
+        >>> match_task_queue_to_patterns('robot', ['robust_*'])
+        False
+    """
+    for queue_pattern in queue_patterns:
+        # 如果队列模式包含通配符
+        if is_wildcard_pattern(queue_pattern):
+            # 检查 task_queue 是否匹配这个通配符模式
+            if fnmatch.fnmatch(task_queue, queue_pattern) or task_queue == queue_pattern:
+                return True
+        else:
+            # 精确匹配
+            if task_queue == queue_pattern:
+                return True
+
+    return False
+
+
+def discover_matching_queues(
+    wildcard_patterns: List[str],
+    all_queues: Set[str]
+) -> Set[str]:
+    """
+    从所有队列中发现匹配通配符模式的队列
+
+    Args:
+        wildcard_patterns: 通配符模式列表，如 ['test*', 'robust_*']
+        all_queues: 所有可用的队列集合
+
+    Returns:
+        Set[str]: 匹配到的队列集合
+
+    Examples:
+        >>> all_queues = {'test1', 'test2', 'robust_bench', 'robot'}
+        >>> discover_matching_queues(['test*'], all_queues)
+        {'test1', 'test2'}
+    """
+    matched_queues = set()
+
+    for pattern in wildcard_patterns:
+        # 使用fnmatch进行通配符匹配
+        for queue in all_queues:
+            if fnmatch.fnmatch(queue, pattern):
+                matched_queues.add(queue)
+
+    return matched_queues

jettask/utils/rate_limit/concurrency_limiter.py

@@ -17,7 +17,7 @@ from redis.asyncio import Redis
 from typing import Dict, Optional, Set, List, Tuple
 from collections import defaultdict
 
-from jettask.utils.db_connector import get_sync_redis_client
+from jettask.db.connector import get_sync_redis_client
 
 logger = logging.getLogger('app')
 
@@ -269,6 +269,12 @@ class ConcurrencyRateLimiter:
             # 订阅 Pub/Sub 频道
             self._pubsub = self.redis.pubsub()
             await self._pubsub.subscribe(self.release_channel)
+
+            # 标记PubSub连接，防止被空闲连接清理
+            if hasattr(self._pubsub, 'connection') and self._pubsub.connection:
+                self._pubsub.connection._is_pubsub_connection = True
+                logger.info(f"[CONCURRENCY] Marked PubSub connection {id(self._pubsub.connection)} to prevent cleanup")
+
             logger.debug(f"[CONCURRENCY] Subscribed to channel {self.release_channel}")
 
             # 启动 Pub/Sub 监听协程

jettask/utils/stream_backlog.py

@@ -39,7 +39,7 @@ class StreamBacklogMonitor:
     async def initialize(self):
         """初始化连接（使用统一的连接池管理）"""
         # 初始化Redis连接
-        from jettask.utils.db_connector import get_async_redis_client
+        from jettask.db.connector import get_async_redis_client
 
         self.redis_client = get_async_redis_client(
             redis_url=self.redis_url,

jettask/webui/__init__.py

@@ -6,7 +6,6 @@ Web UI 模块
 
 # 不在 __init__ 中导入 app，避免循环导入
 # 使用时直接: from jettask.webui.app import app
-from .config import *
 
 # 异常类直接从主模块导入（webui/exceptions.py已废弃并删除）
 from jettask.exceptions import (

jettask/webui/api/__init__.py

@@ -3,26 +3,26 @@ API v1 路由模块集合
 """
 from fastapi import APIRouter
 
-# 导入7个主要模块的路由
+# 导入8个主要模块的路由
 from .overview import router as overview_router      # 概览
 from .namespaces import router as namespaces_router  # 命名空间
 from .queues import router as queues_router         # 队列
 from .scheduled import router as scheduled_router    # 定时任务
 from .alerts import router as alerts_router         # 告警
-from .analytics import router as analytics_router    # 分析
 from .settings import router as settings_router      # 设置
+from .workers import router as workers_router        # Worker 监控
 
 # 创建 v1 总路由，添加统一的 /api/v1 前缀
 api_router = APIRouter(prefix="/api/v1")
 
-# 按功能模块组织路由（namespaces和settings现在是平级的）
+# 按功能模块组织路由
 api_router.include_router(overview_router)    # 系统概览、健康检查
 api_router.include_router(namespaces_router)  # 命名空间管理（独立路由）
 api_router.include_router(queues_router)      # 队列管理、任务处理
 api_router.include_router(scheduled_router)   # 定时任务管理
 api_router.include_router(alerts_router)      # 告警规则管理
-api_router.include_router(analytics_router)   # 数据分析查询
 api_router.include_router(settings_router)    # 系统配置
+api_router.include_router(workers_router)     # Worker 监控
 
 __all__ = ['api_router']