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

jettask/scheduler/{unified_scheduler_manager.py → scheduler_coordinator.py}

@@ -8,9 +8,9 @@ import multiprocessing
 from typing import Dict, Optional, Set
 from jettask.core.unified_manager_base import UnifiedManagerBase
 from jettask import Jettask
-from jettask.task_center import TaskCenter
+from jettask.task.task_center.client import TaskCenter
 from .scheduler import TaskScheduler
-from .manager import ScheduledTaskManager
+from .task_crud import ScheduledTaskManager
 
 logger = logging.getLogger(__name__)
 
@@ -66,10 +66,10 @@ class UnifiedSchedulerManager(UnifiedManagerBase):
             
             # 创建 Jettask 应用
             app = Jettask(task_center=tc)
-            
+
             # 创建调度器管理器（不需要传递namespace参数）
             manager = ScheduledTaskManager(app)
-            
+
             # 创建并启动调度器
             self.scheduler_instance = TaskScheduler(
                 app=app,
@@ -77,7 +77,7 @@ class UnifiedSchedulerManager(UnifiedManagerBase):
                 scan_interval=self.scan_interval,
                 batch_size=self.batch_size
             )
-            
+
             # 运行调度器
             await self.scheduler_instance.run()
             
@@ -171,21 +171,26 @@ class UnifiedSchedulerManager(UnifiedManagerBase):
         async def run_scheduler():
             try:
                 # 构建命名空间特定的URL
-                if task_center_url.endswith('/api/v1/') or task_center_url.endswith('/api/v1'):
-                    # 多命名空间模式，URL是 http://localhost:8001/api/v1/
-                    url = f"{task_center_url.rstrip('/')}/namespaces/{namespace_name}"
-                elif '/api/v1/namespaces/' in task_center_url:
-                    # 单命名空间模式的URL，需要替换命名空间
+                # 需要处理多种格式:
+                # 1. http://localhost:8001 -> http://localhost:8001/api/v1/namespaces/{name}
+                # 2. http://localhost:8001/api/v1 -> http://localhost:8001/api/v1/namespaces/{name}
+                # 3. http://localhost:8001/api/v1/namespaces/old -> http://localhost:8001/api/v1/namespaces/{name}
+
+                if '/api/v1/namespaces/' in task_center_url:
+                    # 替换现有的命名空间
                     base_url = task_center_url.split('/api/v1/namespaces/')[0]
                     url = f"{base_url}/api/v1/namespaces/{namespace_name}"
                 elif '/api/namespaces/' in task_center_url:
                     # 兼容旧格式
                     base_url = task_center_url.split('/api/namespaces/')[0]
                     url = f"{base_url}/api/namespaces/{namespace_name}"
+                elif task_center_url.endswith('/api/v1') or task_center_url.endswith('/api/v1/'):
+                    # 多命名空间模式，URL 是 http://localhost:8001/api/v1
+                    url = f"{task_center_url.rstrip('/')}/namespaces/{namespace_name}"
                 else:
-                    # 如果是基础URL，添加命名空间路径
+                    # 基础URL，添加完整路径
                     url = f"{task_center_url.rstrip('/')}/api/v1/namespaces/{namespace_name}"
-                
+
                 # 创建任务中心连接
                 tc = TaskCenter(url)
                 if not tc._connect_sync():
@@ -197,7 +202,7 @@ class UnifiedSchedulerManager(UnifiedManagerBase):
                 # 创建调度器管理器 - ScheduledTaskManager 只接受一个参数
                 manager = ScheduledTaskManager(app)
                 
-                # 创建并启动调度器
+                # 创建并启动调度器 - 使用正确的参数名
                 scheduler = TaskScheduler(
                     app=app,
                     db_manager=manager,

jettask/task/__init__.py

@@ -0,0 +1,16 @@
+"""
+任务管理层
+
+提供统一的任务注册、执行和生命周期管理
+"""
+
+from .task_registry import TaskRegistry, TaskDefinition
+from .task_executor import TaskExecutor
+from .router import TaskRouter
+
+__all__ = [
+    'TaskRegistry',
+    'TaskDefinition',
+    'TaskExecutor',
+    'TaskRouter',
+]

jettask/{router.py → task/router.py}

@@ -3,9 +3,9 @@ Task Router for modular task organization
 Similar to FastAPI's APIRouter
 """
 
-from typing import Optional, Dict, List, Any, Callable
-from functools import wraps
+from typing import Dict, List, Any, Callable
 import logging
+from jettask.utils.rate_limit.config import RateLimitConfig
 
 logger = logging.getLogger(__name__)
 
@@ -71,18 +71,35 @@ class TaskRouter:
         timeout: int = None,
         max_retries: int = None,
         retry_delay: int = None,
+        rate_limit: RateLimitConfig = None,
         **kwargs
     ):
         """
         任务装饰器
-        
+
         Args:
             name: 任务名称（可选，默认使用函数名）
             queue: 队列名（可选，默认使用路由器的默认队列）
             timeout: 超时时间
             max_retries: 最大重试次数
             retry_delay: 重试延迟
+            rate_limit: 限流配置（QPSLimit 或 ConcurrencyLimit）
             **kwargs: 其他任务参数
+
+        Example:
+            from jettask import TaskRouter, QPSLimit, ConcurrencyLimit
+
+            router = TaskRouter(prefix="email")
+
+            # QPS 限流
+            @router.task(rate_limit=QPSLimit(qps=100))
+            async def send_email(to: str):
+                pass
+
+            # 并发限流
+            @router.task(rate_limit=ConcurrencyLimit(max_concurrency=10))
+            async def heavy_task():
+                pass
         """
         def decorator(func: Callable):
             # 生成任务名
@@ -91,7 +108,7 @@ class TaskRouter:
                 full_task_name = f"{self.prefix}.{task_name}"
             else:
                 full_task_name = task_name
-            
+
             # 合并参数（优先使用任务级别的参数）
             task_config = {
                 'func': func,
@@ -100,19 +117,20 @@ class TaskRouter:
                 'timeout': timeout or self.default_timeout,
                 'max_retries': max_retries or self.default_max_retries,
                 'retry_delay': retry_delay or self.default_retry_delay,
+                'rate_limit': rate_limit,
                 'tags': self.tags,
                 **kwargs
             }
-            
+
             # 移除None值
             task_config = {k: v for k, v in task_config.items() if v is not None}
-            
+
             # 存储任务配置
             self._tasks[full_task_name] = task_config
-            
+
             # 返回原函数，保持函数可以被直接调用
             return func
-            
+
         return decorator
     
     def include_router(self, router: 'TaskRouter', prefix: str = None):

jettask/task/task_center/__init__.py

@@ -0,0 +1,9 @@
+"""
+任务中心客户端模块
+
+提供与任务中心的通信功能
+"""
+
+from .client import TaskCenter
+
+__all__ = ['TaskCenter']

jettask/task/task_executor.py

@@ -0,0 +1,318 @@
+"""
+任务执行器
+
+负责任务的执行、超时控制、错误处理
+"""
+
+from typing import List, Dict, Any, Optional
+import asyncio
+import logging
+import traceback
+from datetime import datetime
+
+from .task_registry import TaskRegistry, TaskDefinition
+
+logger = logging.getLogger('app')
+
+
+class TaskExecutor:
+    """
+    任务执行器
+
+    职责：
+    1. 任务执行
+    2. 超时控制
+    3. 错误处理
+    4. 结果存储
+
+    从ExecutorCore提取的纯任务执行逻辑
+    """
+
+    def __init__(self,
+                 task_registry: TaskRegistry,
+                 data_access=None,
+                 retry_manager=None):
+        """
+        初始化任务执行器
+
+        Args:
+            task_registry: 任务注册器
+            data_access: 数据访问层（可选）
+            retry_manager: 重试管理器（可选）
+        """
+        self.registry = task_registry
+        self.data_access = data_access
+        self.retry_manager = retry_manager
+
+        logger.debug("TaskExecutor initialized")
+
+    async def execute(self, message: dict) -> Any:
+        """
+        执行任务
+
+        Args:
+            message: 任务消息
+                - task_name: 任务名称
+                - task_id: 任务ID
+                - args: 位置参数
+                - kwargs: 关键字参数
+
+        Returns:
+            Any: 任务执行结果
+
+        Raises:
+            ValueError: 任务不存在
+            asyncio.TimeoutError: 任务超时
+            Exception: 任务执行错误
+        """
+        task_name = message.get('task_name')
+        task_id = message.get('task_id')
+        args = message.get('args', [])
+        kwargs = message.get('kwargs', {})
+
+        logger.debug(f"Executing task: {task_name} (id: {task_id})")
+
+        # 获取任务定义
+        task_def = self.registry.get(task_name)
+        if not task_def:
+            error_msg = f"Task {task_name} not found in registry"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        # 执行任务（带超时）
+        try:
+            # 记录开始时间
+            start_time = datetime.now()
+
+            # 执行任务
+            if asyncio.iscoroutinefunction(task_def.func):
+                # 异步任务
+                result = await asyncio.wait_for(
+                    task_def.func(*args, **kwargs),
+                    timeout=task_def.timeout
+                )
+            else:
+                # 同步任务，在线程池中执行
+                loop = asyncio.get_event_loop()
+                result = await asyncio.wait_for(
+                    loop.run_in_executor(None, task_def.func, *args, **kwargs),
+                    timeout=task_def.timeout
+                )
+
+            # 计算执行时间
+            execution_time = (datetime.now() - start_time).total_seconds()
+
+            logger.info(
+                f"Task {task_name} (id: {task_id}) completed "
+                f"in {execution_time:.2f}s"
+            )
+
+            # 保存成功结果
+            if self.data_access:
+                await self.data_access.save_task_result(
+                    task_id=task_id,
+                    status='completed',
+                    result=result,
+                    execution_time=execution_time
+                )
+
+            return result
+
+        except asyncio.TimeoutError:
+            # 超时处理
+            logger.error(
+                f"Task {task_name} (id: {task_id}) timeout "
+                f"after {task_def.timeout}s"
+            )
+            await self._handle_timeout(task_id, task_def, message)
+            raise
+
+        except Exception as e:
+            # 错误处理
+            logger.error(
+                f"Task {task_name} (id: {task_id}) failed: {e}\n"
+                f"{traceback.format_exc()}"
+            )
+            await self._handle_error(task_id, task_def, message, e)
+            raise
+
+    async def _handle_timeout(self,
+                             task_id: str,
+                             task_def: TaskDefinition,
+                             message: dict):
+        """
+        处理超时
+
+        Args:
+            task_id: 任务ID
+            task_def: 任务定义
+            message: 任务消息
+        """
+        # 保存超时状态
+        if self.data_access:
+            await self.data_access.save_task_result(
+                task_id=task_id,
+                status='timeout',
+                result=None,
+                error=f"Task timeout after {task_def.timeout}s"
+            )
+
+        # 重试逻辑
+        if task_def.max_retries > 0 and self.retry_manager:
+            current_retry = message.get('retry_count', 0)
+            if current_retry < task_def.max_retries:
+                logger.info(
+                    f"Scheduling retry for task {task_def.name} "
+                    f"(attempt {current_retry + 1}/{task_def.max_retries})"
+                )
+                await self.retry_manager.schedule_retry(
+                    task_id=task_id,
+                    task_def=task_def,
+                    message=message,
+                    retry_count=current_retry + 1,
+                    delay=task_def.retry_delay
+                )
+
+    async def _handle_error(self,
+                           task_id: str,
+                           task_def: TaskDefinition,
+                           message: dict,
+                           error: Exception):
+        """
+        处理错误
+
+        Args:
+            task_id: 任务ID
+            task_def: 任务定义
+            message: 任务消息
+            error: 错误对象
+        """
+        # 保存失败状态
+        if self.data_access:
+            await self.data_access.save_task_result(
+                task_id=task_id,
+                status='failed',
+                result=None,
+                error=str(error),
+                traceback=traceback.format_exc()
+            )
+
+        # 重试逻辑
+        if task_def.max_retries > 0 and self.retry_manager:
+            current_retry = message.get('retry_count', 0)
+            if current_retry < task_def.max_retries:
+                logger.info(
+                    f"Scheduling retry for task {task_def.name} "
+                    f"(attempt {current_retry + 1}/{task_def.max_retries})"
+                )
+                await self.retry_manager.schedule_retry(
+                    task_id=task_id,
+                    task_def=task_def,
+                    message=message,
+                    retry_count=current_retry + 1,
+                    delay=task_def.retry_delay
+                )
+            else:
+                logger.error(
+                    f"Task {task_def.name} failed after {task_def.max_retries} retries"
+                )
+
+    async def batch_update_status(self, status_updates: List[dict]):
+        """
+        批量更新任务状态
+
+        Args:
+            status_updates: 状态更新列表
+                - task_id: 任务ID
+                - status: 状态
+                - result: 结果（可选）
+                - error: 错误信息（可选）
+        """
+        if not self.data_access:
+            logger.warning("No data_access configured, skipping batch status update")
+            return
+
+        for update in status_updates:
+            try:
+                await self.data_access.update_task_status(
+                    task_id=update['task_id'],
+                    status=update['status'],
+                    result=update.get('result'),
+                    error=update.get('error')
+                )
+            except Exception as e:
+                logger.error(f"Error updating task status: {e}")
+
+    async def execute_batch(self, messages: List[dict]) -> List[Dict[str, Any]]:
+        """
+        批量执行任务
+
+        Args:
+            messages: 任务消息列表
+
+        Returns:
+            List[Dict]: 执行结果列表
+                - task_id: 任务ID
+                - status: 状态（completed/failed/timeout）
+                - result: 结果（可选）
+                - error: 错误信息（可选）
+        """
+        results = []
+
+        # 并发执行所有任务
+        tasks = []
+        for message in messages:
+            task = asyncio.create_task(self._execute_with_result(message))
+            tasks.append(task)
+
+        # 等待所有任务完成
+        task_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # 整理结果
+        for i, task_result in enumerate(task_results):
+            message = messages[i]
+            task_id = message.get('task_id')
+
+            if isinstance(task_result, Exception):
+                # 任务失败
+                if isinstance(task_result, asyncio.TimeoutError):
+                    status = 'timeout'
+                    error = 'Task timeout'
+                else:
+                    status = 'failed'
+                    error = str(task_result)
+
+                results.append({
+                    'task_id': task_id,
+                    'status': status,
+                    'result': None,
+                    'error': error
+                })
+            else:
+                # 任务成功
+                results.append({
+                    'task_id': task_id,
+                    'status': 'completed',
+                    'result': task_result,
+                    'error': None
+                })
+
+        return results
+
+    async def _execute_with_result(self, message: dict) -> Any:
+        """
+        执行任务并返回结果（用于批量执行）
+
+        Args:
+            message: 任务消息
+
+        Returns:
+            Any: 任务执行结果
+
+        Raises:
+            Exception: 任务执行错误
+        """
+        try:
+            return await self.execute(message)
+        except Exception:
+            raise  # 让gather捕获异常