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

jettask/core/container.py

@@ -74,7 +74,7 @@ class ServiceContainer:
 
     def _get_sync_text_client(self) -> redis.Redis:
         """获取同步文本模式客户端（使用全局客户端实例）"""
-        from jettask.utils.db_connector import get_sync_redis_client
+        from jettask.db.connector import get_sync_redis_client
         return get_sync_redis_client(
             redis_url=self.config.redis.url,
             decode_responses=True,
@@ -83,7 +83,7 @@ class ServiceContainer:
 
     def _get_sync_binary_client(self) -> redis.Redis:
         """获取同步二进制模式客户端（使用全局客户端实例）"""
-        from jettask.utils.db_connector import get_sync_redis_client
+        from jettask.db.connector import get_sync_redis_client
         return get_sync_redis_client(
             redis_url=self.config.redis.url,
             decode_responses=False,
@@ -92,7 +92,7 @@ class ServiceContainer:
 
     def _get_async_text_client(self) -> aioredis.Redis:
         """获取异步文本模式客户端（使用全局客户端实例）"""
-        from jettask.utils.db_connector import get_async_redis_client
+        from jettask.db.connector import get_async_redis_client
         return get_async_redis_client(
             redis_url=self.config.redis.url,
             decode_responses=True,
@@ -101,7 +101,7 @@ class ServiceContainer:
 
     def _get_async_binary_client(self) -> aioredis.Redis:
         """获取异步二进制模式客户端（使用全局客户端实例）"""
-        from jettask.utils.db_connector import get_async_redis_client
+        from jettask.db.connector import get_async_redis_client
         return get_async_redis_client(
             redis_url=self.config.redis.url,
             decode_responses=False,

jettask/{persistence → core}/namespace.py

@@ -2,20 +2,16 @@
 命名空间数据访问层 - 支持多租户的数据隔离访问
 """
 import os
-import asyncio
-import json
 import logging
-import time
 import traceback
-from datetime import datetime, timedelta, timezone
-from typing import Dict, List, Optional, Tuple, Any
+from typing import Dict, List, Optional
 import redis.asyncio as redis
-from sqlalchemy import text, bindparam
+from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession
 import aiohttp
 
 # 导入统一的数据库连接工具
-from ..utils.db_connector import (
+from jettask.db.connector import (
     get_dual_mode_async_redis_client,
     get_pg_engine_and_factory
 )
@@ -49,13 +45,20 @@ class NamespaceConnection:
         try:
             # 初始化 PostgreSQL 连接（使用全局单例）
             if self.pg_config:
-                self.async_engine, self.AsyncSessionLocal = get_pg_engine_and_factory(
-                    config=self.pg_config,
-                    pool_size=10,
-                    max_overflow=5,
-                    pool_pre_ping=True,
-                    echo=False
-                )
+                # pg_config 可以是字符串（DSN）或者字典（包含url字段）
+                pg_dsn = self.pg_config if isinstance(self.pg_config, str) else self.pg_config.get('url')
+                if pg_dsn:
+                    # 将 postgresql:// 转换为 postgresql+asyncpg://
+                    if pg_dsn.startswith('postgresql://'):
+                        pg_dsn = pg_dsn.replace('postgresql://', 'postgresql+asyncpg://', 1)
+
+                    self.async_engine, self.AsyncSessionLocal = get_pg_engine_and_factory(
+                        dsn=pg_dsn,
+                        pool_size=10,
+                        max_overflow=5,
+                        pool_recycle=3600,
+                        echo=False
+                    )
 
             # 初始化 Redis 连接（使用全局单例，双模式）
             if self.redis_config:
@@ -142,29 +145,92 @@ class NamespaceDataAccessManager:
         return self._session
     
     async def get_namespace_config(self, namespace_name: str) -> dict:
-        """从任务中心API获取命名空间配置"""
+        """从任务中心API获取命名空间配置
+
+        支持两种配置模式：
+        - nacos 模式：API 返回 nacos_key，本地通过 Nacos 获取真实配置
+        - direct 模式：API 直接返回完整的数据库 URL
+        """
         # 使用127.0.0.1替代localhost，确保容器内能正确连接
         base_url = self.task_center_base_url
         if 'localhost' in base_url:
             base_url = base_url.replace('localhost', '127.0.0.1')
         url = f"{base_url}/api/v1/namespaces/{namespace_name}"
-        
+
         try:
             session = await self._get_session()
             async with session.get(url) as resp:
                 if resp.status == 200:
                     data = await resp.json()
-                    # API返回的是redis_config和pg_config，直接使用
-                    redis_config = data.get('redis_config', {})
-                    pg_config = data.get('pg_config', {})
-                    
-                    # 兼容旧格式：如果有redis_url和pg_url字段
-                    if not redis_config and data.get('redis_url'):
-                        redis_config = {'url': data.get('redis_url')}
-                    
-                    if not pg_config and data.get('pg_url'):
-                        pg_config = {'url': data.get('pg_url')}
-                    
+
+                    # 处理新格式（带 config_mode 字段）
+                    redis_config_mode = data.get('redis_config_mode', 'direct')
+                    pg_config_mode = data.get('pg_config_mode', 'direct')
+
+                    # 处理 Redis 配置
+                    redis_config = {}
+                    if redis_config_mode == 'nacos':
+                        # Nacos 模式 - 需要通过 nacos_config 获取真实 URL
+                        redis_nacos_key = data.get('redis_nacos_key')
+                        if redis_nacos_key:
+                            logger.info(f"命名空间 {namespace_name} 使用 Nacos 模式获取 Redis 配置，key: {redis_nacos_key}")
+                            try:
+                                from jettask.config.nacos_config import config as nacos_config
+                                redis_url = nacos_config.get(redis_nacos_key)
+                                if redis_url:
+                                    redis_config = {'url': redis_url}
+                                    logger.debug(f"从 Nacos 获取 Redis URL 成功: {redis_nacos_key}")
+                                else:
+                                    logger.warning(f"Nacos 配置键 {redis_nacos_key} 未找到或为空")
+                            except Exception as e:
+                                logger.error(f"从 Nacos 获取 Redis 配置失败: {e}")
+                                raise ValueError(f"无法从 Nacos 获取 Redis 配置 (key: {redis_nacos_key}): {e}")
+                    else:
+                        # Direct 模式 - 直接使用 API 返回的 URL
+                        redis_url = data.get('redis_url')
+                        if redis_url:
+                            redis_config = {'url': redis_url}
+                            logger.debug(f"命名空间 {namespace_name} 使用 Direct 模式，Redis URL 已获取")
+
+                    # 处理 PostgreSQL 配置
+                    pg_config = {}
+                    if pg_config_mode == 'nacos':
+                        # Nacos 模式 - 需要通过 nacos_config 获取真实 URL
+                        pg_nacos_key = data.get('pg_nacos_key')
+                        if pg_nacos_key:
+                            logger.info(f"命名空间 {namespace_name} 使用 Nacos 模式获取 PG 配置，key: {pg_nacos_key}")
+                            try:
+                                from jettask.config.nacos_config import config as nacos_config
+                                pg_url = nacos_config.get(pg_nacos_key)
+                                if pg_url:
+                                    pg_config = {'url': pg_url}
+                                    logger.debug(f"从 Nacos 获取 PG URL 成功: {pg_nacos_key}")
+                                else:
+                                    logger.warning(f"Nacos 配置键 {pg_nacos_key} 未找到或为空")
+                            except Exception as e:
+                                logger.error(f"从 Nacos 获取 PG 配置失败: {e}")
+                                # PostgreSQL 是可选的，不抛出异常
+                                logger.warning(f"PostgreSQL 配置获取失败，将跳过 PG 相关功能")
+                    else:
+                        # Direct 模式 - 直接使用 API 返回的 URL
+                        pg_url = data.get('pg_url')
+                        if pg_url:
+                            pg_config = {'url': pg_url}
+                            logger.debug(f"命名空间 {namespace_name} 使用 Direct 模式，PG URL 已获取")
+
+                    # 兼容旧格式：如果没有 config_mode 字段（旧版 API）
+                    if not redis_config:
+                        if data.get('redis_config'):
+                            redis_config = data.get('redis_config')
+                        elif data.get('redis_url'):
+                            redis_config = {'url': data.get('redis_url')}
+
+                    if not pg_config:
+                        if data.get('pg_config'):
+                            pg_config = data.get('pg_config')
+                        elif data.get('pg_url'):
+                            pg_config = {'url': data.get('pg_url')}
+
                     return {
                         'name': data.get('name'),
                         'redis_config': redis_config,

jettask/core/task.py

@@ -36,36 +36,41 @@ class Task:
     trigger_time: float = None
     retry_config: Optional[dict] = None  # 存储任务级别的重试配置
 
-    def __call__(self, event_id: str, trigger_time: float, *args: Any, **kwds: Any) -> Any:
+    def __call__(self, event_id: str, trigger_time: float, queue:str, *args: Any, **kwds: Any) -> Any:
         # 检查函数签名以进行依赖注入
         injected_args, injected_kwargs = self._inject_dependencies(
-            event_id, trigger_time, args, kwds
+            event_id, trigger_time, queue, args, kwds
         )
         return self.run(*injected_args, **injected_kwargs)
     
-    def _inject_dependencies(self, event_id: str, trigger_time: float, args: tuple, kwargs: dict) -> tuple:
+    def _inject_dependencies(self, event_id: str, trigger_time: float, queue:str, args: tuple, kwargs: dict) -> tuple:
         """
         基于类型注解自动注入TaskContext
         """
+        import logging
+        logger = logging.getLogger(__name__)
+
         # 获取run方法的签名
         try:
             sig = inspect.signature(self.run)
             type_hints = get_type_hints(self.run)
-        except (ValueError, TypeError, NameError):
+            logger.debug(f"[TaskContext注入] 任务 {self.name} - 签名: {sig}, 类型提示: {type_hints}")
+        except (ValueError, TypeError, NameError) as e:
             # 如果获取签名失败，返回原始参数
+            logger.warning(f"[TaskContext注入] 任务 {self.name} - 获取签名失败: {e}")
             return args, kwargs
         
-        # 从kwargs中提取scheduled_task_id（如果存在）
-        # 这个值由执行器从event_data中提取并传递
+        # 从kwargs中提取scheduled_task_id和真实队列名（如果存在）
+        # 这些值由执行器从event_data中提取并传递
         scheduled_task_id = kwargs.pop('__scheduled_task_id', None)
-        
+
         # 创建TaskContext实例
         context = TaskContext(
             event_id=event_id,
             name=self.name,
             trigger_time=trigger_time,
             app=self._app,
-            queue=self.queue,
+            queue=queue,  # 优先使用真实队列名，fallback到任务定义的队列
             scheduled_task_id=scheduled_task_id,  # 传递scheduled_task_id
             # worker_id和retry_count可以从其他地方获取
             # 暂时使用默认值
@@ -112,7 +117,9 @@ class Task:
         # 如果还有剩余的位置参数，添加到末尾（处理*args的情况）
         if args_consumed < len(args_list):
             final_args.extend(args_list[args_consumed:])
-        
+
+        logger.debug(f"[TaskContext注入] 任务 {self.name} - 注入后参数: args={final_args}, kwargs={list(final_kwargs.keys())}")
+
         return tuple(final_args), final_kwargs
 
     def run(self, *args, **kwargs):

jettask/core/unified_manager_base.py

@@ -51,15 +51,15 @@ class UnifiedManagerBase(ABC):
     def _detect_mode(self) -> bool:
         """
         检测是单命名空间还是多命名空间模式
-        
+
         Returns:
             True: 单命名空间模式
             False: 多命名空间模式
         """
         # 检查URL格式
-        # 单命名空间: /api/v1/namespaces/{name} 或 /api/namespaces/{name}
+        # 单命名空间: /api/v1/namespaces/{name} 或 /api/namespaces/{name} 或 /namespaces/{name}
         # 多命名空间: 不包含这些路径或以 /api 结尾
-        
+
         # 检查新格式
         if '/api/v1/namespaces/' in self.task_center_url:
             # 提取命名空间名称
@@ -68,7 +68,7 @@ class UnifiedManagerBase(ABC):
                 self.namespace_name = match.group(1)
                 logger.info(f"检测到单命名空间模式: {self.namespace_name}")
                 return True
-        
+
         # 兼容旧格式
         elif '/api/namespaces/' in self.task_center_url:
             # 提取命名空间名称
@@ -77,7 +77,16 @@ class UnifiedManagerBase(ABC):
                 self.namespace_name = match.group(1)
                 logger.info(f"检测到单命名空间模式: {self.namespace_name}")
                 return True
-        
+
+        # 支持简化格式（无/api前缀）
+        elif '/namespaces/' in self.task_center_url:
+            # 提取命名空间名称
+            match = re.search(r'/namespaces/([^/]+)/?$', self.task_center_url)
+            if match:
+                self.namespace_name = match.group(1)
+                logger.info(f"检测到单命名空间模式（简化格式）: {self.namespace_name}")
+                return True
+
         # 多命名空间模式
         logger.info("检测到多命名空间模式")
         return False
@@ -85,7 +94,7 @@ class UnifiedManagerBase(ABC):
     def get_base_url(self) -> str:
         """
         获取任务中心的基础URL
-        
+
         Returns:
             基础URL（去除命名空间路径）
         """
@@ -97,12 +106,16 @@ class UnifiedManagerBase(ABC):
             elif '/api/namespaces/' in self.task_center_url:
                 # 兼容旧格式
                 return self.task_center_url.split('/api/namespaces/')[0]
-        
+            elif '/namespaces/' in self.task_center_url:
+                # 简化格式（无/api前缀）
+                # 从 http://localhost:8001/namespaces/test5 提取 http://localhost:8001
+                return self.task_center_url.split('/namespaces/')[0]
+
         # 多命名空间模式，如果URL以 /api/v1/ 结尾，去掉 /api/v1/ 部分
         if self.task_center_url.endswith('/api/v1/') or self.task_center_url.endswith('/api/v1'):
             # 从 http://localhost:8001/api/v1/ 提取 http://localhost:8001
             return self.task_center_url.rstrip('/').rsplit('/api/v1', 1)[0]
-        
+
         return self.task_center_url
     
     def get_target_namespaces(self) -> Optional[Set[str]]:
@@ -144,18 +157,67 @@ class UnifiedManagerBase(ABC):
                             async with session.get(url) as response:
                                 if response.status == 200:
                                     data = await response.json()
-                                    # 构建redis和pg配置
+
+                                    # 处理新格式（带 config_mode 字段）
+                                    redis_config_mode = data.get('redis_config_mode', 'direct')
+                                    pg_config_mode = data.get('pg_config_mode', 'direct')
+
+                                    # 处理 Redis 配置
+                                    redis_config = {}
+                                    if redis_config_mode == 'nacos':
+                                        # Nacos 模式 - 需要通过 nacos_config 获取真实 URL
+                                        redis_nacos_key = data.get('redis_nacos_key')
+                                        if redis_nacos_key:
+                                            try:
+                                                from jettask.config.nacos_config import config as nacos_config
+                                                redis_url = nacos_config.get(redis_nacos_key)
+                                                if redis_url:
+                                                    redis_config = {'url': redis_url}
+                                            except Exception as e:
+                                                logger.error(f"从 Nacos 获取 Redis 配置失败: {e}")
+                                                continue
+                                    else:
+                                        # Direct 模式 - 直接使用 API 返回的 URL
+                                        redis_url = data.get('redis_url')
+                                        if redis_url:
+                                            redis_config = {'url': redis_url}
+
+                                    # 处理 PostgreSQL 配置
+                                    pg_config = {}
+                                    if pg_config_mode == 'nacos':
+                                        # Nacos 模式 - 需要通过 nacos_config 获取真实 URL
+                                        pg_nacos_key = data.get('pg_nacos_key')
+                                        if pg_nacos_key:
+                                            try:
+                                                from jettask.config.nacos_config import config as nacos_config
+                                                pg_url = nacos_config.get(pg_nacos_key)
+                                                if pg_url:
+                                                    pg_config = {'url': pg_url}
+                                            except Exception as e:
+                                                logger.warning(f"从 Nacos 获取 PG 配置失败: {e}")
+                                                # PostgreSQL 是可选的
+                                    else:
+                                        # Direct 模式 - 直接使用 API 返回的 URL
+                                        pg_url = data.get('pg_url')
+                                        if pg_url:
+                                            pg_config = {'url': pg_url}
+
+                                    # 兼容旧格式：如果没有 config_mode 字段（旧版 API）
+                                    if not redis_config:
+                                        redis_url = data.get('redis_url', '')
+                                        if redis_url:
+                                            redis_config = {'url': redis_url}
+
+                                    if not pg_config:
+                                        pg_url = data.get('pg_url', '')
+                                        if pg_url:
+                                            pg_config = {'url': pg_url}
+
                                     # 跳过没有有效配置的命名空间
-                                    redis_url = data.get('redis_url', '')
-                                    pg_url = data.get('pg_url', '')
-                                    
-                                    if not redis_url or not pg_url:
+                                    if not redis_config or not pg_config:
                                         # logger.warning(f"跳过命名空间 {data['name']}：缺少 Redis 或 PostgreSQL 配置")
                                         continue
-                                    
-                                    redis_config = {'url': redis_url}
-                                    pg_config = {'url': pg_url}
-                                    
+
                                     ns_info = {
                                         'id': data.get('id', data['name']),  # 如果没有id，使用name作为id
                                         'name': data['name'],
@@ -179,18 +241,66 @@ class UnifiedManagerBase(ABC):
                         if response.status == 200:
                             data_list = await response.json()
                             for data in data_list:
-                                # 构建redis和pg配置
+                                # 处理新格式（带 config_mode 字段）
+                                redis_config_mode = data.get('redis_config_mode', 'direct')
+                                pg_config_mode = data.get('pg_config_mode', 'direct')
+
+                                # 处理 Redis 配置
+                                redis_config = {}
+                                if redis_config_mode == 'nacos':
+                                    # Nacos 模式 - 需要通过 nacos_config 获取真实 URL
+                                    redis_nacos_key = data.get('redis_nacos_key')
+                                    if redis_nacos_key:
+                                        try:
+                                            from jettask.config.nacos_config import config as nacos_config
+                                            redis_url = nacos_config.get(redis_nacos_key)
+                                            if redis_url:
+                                                redis_config = {'url': redis_url}
+                                        except Exception as e:
+                                            logger.error(f"从 Nacos 获取 Redis 配置失败: {e}")
+                                            continue
+                                else:
+                                    # Direct 模式 - 直接使用 API 返回的 URL
+                                    redis_url = data.get('redis_url')
+                                    if redis_url:
+                                        redis_config = {'url': redis_url}
+
+                                # 处理 PostgreSQL 配置
+                                pg_config = {}
+                                if pg_config_mode == 'nacos':
+                                    # Nacos 模式 - 需要通过 nacos_config 获取真实 URL
+                                    pg_nacos_key = data.get('pg_nacos_key')
+                                    if pg_nacos_key:
+                                        try:
+                                            from jettask.config.nacos_config import config as nacos_config
+                                            pg_url = nacos_config.get(pg_nacos_key)
+                                            if pg_url:
+                                                pg_config = {'url': pg_url}
+                                        except Exception as e:
+                                            logger.warning(f"从 Nacos 获取 PG 配置失败: {e}")
+                                            # PostgreSQL 是可选的
+                                else:
+                                    # Direct 模式 - 直接使用 API 返回的 URL
+                                    pg_url = data.get('pg_url')
+                                    if pg_url:
+                                        pg_config = {'url': pg_url}
+
+                                # 兼容旧格式：如果没有 config_mode 字段（旧版 API）
+                                if not redis_config:
+                                    redis_url = data.get('redis_url', '')
+                                    if redis_url:
+                                        redis_config = {'url': redis_url}
+
+                                if not pg_config:
+                                    pg_url = data.get('pg_url', '')
+                                    if pg_url:
+                                        pg_config = {'url': pg_url}
+
                                 # 跳过没有有效配置的命名空间
-                                redis_url = data.get('redis_url', '')
-                                pg_url = data.get('pg_url', '')
-                                
-                                if not redis_url or not pg_url:
+                                if not redis_config or not pg_config:
                                     # logger.warning(f"跳过命名空间 {data['name']}：缺少 Redis 或 PostgreSQL 配置")
                                     continue
-                                
-                                redis_config = {'url': redis_url}
-                                pg_config = {'url': pg_url}
-                                
+
                                 ns_info = {
                                     'id': data.get('id', data['name']),  # 如果没有id，使用name作为id
                                     'name': data['name'],

jettask/db/__init__.py

@@ -0,0 +1,67 @@
+"""
+数据库模块
+
+提供统一的数据库模型定义、操作接口和连接管理
+"""
+
+from .base import Base, get_engine, get_session, init_db
+from .connector import (
+    # 连接池函数
+    get_sync_redis_pool,
+    get_async_redis_pool,
+    get_async_redis_pool_for_pubsub,
+    get_pg_engine_and_factory,
+    get_asyncpg_pool,
+    # 客户端实例函数
+    get_sync_redis_client,
+    get_async_redis_client,
+    get_dual_mode_async_redis_client,
+    # 缓存清理
+    clear_all_cache,
+    # 配置解析
+    DBConfig,
+    # 连接器类
+    SyncRedisConnector,
+    RedisConnector,
+    PostgreSQLConnector,
+    ConnectionManager,
+    # 便捷函数
+    create_redis_client,
+    create_pg_session,
+)
+
+__all__ = [
+    # SQLAlchemy 基础
+    'Base',
+    'get_engine',
+    'get_session',
+    'init_db',
+
+    # 连接池函数
+    'get_sync_redis_pool',
+    'get_async_redis_pool',
+    'get_async_redis_pool_for_pubsub',
+    'get_pg_engine_and_factory',
+    'get_asyncpg_pool',
+
+    # 客户端实例函数
+    'get_sync_redis_client',
+    'get_async_redis_client',
+    'get_dual_mode_async_redis_client',
+
+    # 缓存清理
+    'clear_all_cache',
+
+    # 配置解析
+    'DBConfig',
+
+    # 连接器类
+    'SyncRedisConnector',
+    'RedisConnector',
+    'PostgreSQLConnector',
+    'ConnectionManager',
+
+    # 便捷函数
+    'create_redis_client',
+    'create_pg_session',
+]