jettask 0.2.1__py3-none-any.whl → 0.2.4__py3-none-any.whl

jettask/core/task.py

@@ -1,13 +1,15 @@
 from ..utils.serializer import dumps_str, loads_str
 import time
 import inspect
+import asyncio
 from dataclasses import dataclass
-from typing import Any, Optional, TYPE_CHECKING, get_type_hints
+from typing import Any, Optional, TYPE_CHECKING, get_type_hints, Union
 
 if TYPE_CHECKING:
     from .app import Jettask
 
 from .context import TaskContext
+from .enums import TaskStatus
 
 
 @dataclass
@@ -56,6 +58,10 @@ class Task:
             # 如果获取签名失败，返回原始参数
             return args, kwargs
         
+        # 从kwargs中提取scheduled_task_id（如果存在）
+        # 这个值由执行器从event_data中提取并传递
+        scheduled_task_id = kwargs.pop('__scheduled_task_id', None)
+        
         # 创建TaskContext实例
         context = TaskContext(
             event_id=event_id,
@@ -63,6 +69,7 @@ class Task:
             trigger_time=trigger_time,
             app=self._app,
             queue=self.queue,
+            scheduled_task_id=scheduled_task_id,  # 传递scheduled_task_id
             # worker_id和retry_count可以从其他地方获取
             # 暂时使用默认值
         )
@@ -119,70 +126,6 @@ class Task:
     def bind_app(cls, app):
         cls._app = app
 
-    def apply_async(
-        self,
-        args: tuple = None,
-        kwargs: dict = None,
-        queue: str = None,
-        at_once: bool = True,
-        asyncio: bool = False,
-        routing: dict = None,
-        delay: int = None,
-        timeout: int = None,
-    ):
-        """
-        异步执行任务
-        
-        Args:
-            args: 位置参数
-            kwargs: 关键字参数
-            queue: 队列名
-            at_once: 是否立即发送
-            asyncio: 是否使用异步模式
-            routing: 路由信息
-            delay: 延迟执行秒数（最多86400秒/1天）
-            timeout: 任务超时时间
-        
-        Returns:
-            任务ID或任务消息
-        """
-        queue = queue or self.queue
-        message = {
-            "queue": queue,
-            "name": self.name,
-            "args": args or (),
-            "kwargs": kwargs or {},
-            'trigger_time': time.time()
-        }
-        
-        if routing:
-            message['routing'] = routing or {}
-        
-        # 添加任务选项
-        if timeout:
-            message['timeout'] = timeout
-        
-        # 如果有延迟参数，添加到消息中
-        if delay:
-            message['delay'] = delay
-        
-        if not at_once:
-            return message
-        
-        # 处理延迟任务
-        if delay:
-            if asyncio:
-                import asyncio as aio
-                return aio.create_task(self._send_delayed_task(queue, message, delay))
-            else:
-                return self.send_delayed_task(queue, message, delay)
-        
-        # 立即发送任务
-        if asyncio:
-            import asyncio as aio
-            return aio.create_task(self._send_task(queue, message))
-        else:
-            return self.send_task(queue, message)
 
     def on_before(self, event_id, pedding_count, args, kwargs) -> ExecuteResponse:
         return ExecuteResponse()
@@ -193,114 +136,6 @@ class Task:
     def on_success(self, event_id, args, kwargs, result) -> ExecuteResponse:
         return ExecuteResponse()
 
-    def send_task(self, queue, message):
-        # 如果queue为None，使用任务名作为队列名
-        actual_queue = queue or self.name
-        message['queue'] = actual_queue
-        
-        # 如果任务有默认重试配置且消息中没有重试配置，则添加默认配置
-        if self.retry_config and 'retry_config' not in message:
-            message['retry_config'] = self.retry_config
-        
-        event_id = self._app.ep.send_event(actual_queue, message, False)
-        # 只设置status，其他信息从Stream消息获取
-        key = f"{self._app.ep.redis_prefix or 'jettask'}:TASK:{event_id}"
-        self._app.redis.hset(key, "status", "pending")
-        self._app.redis.expire(key, 3600)
-        return event_id
-
-    async def _send_task(self, queue, message):
-        # 如果queue为None，使用任务名作为队列名
-        actual_queue = queue or self.name
-        message['queue'] = actual_queue
-        
-        # 如果任务有默认重试配置且消息中没有重试配置，则添加默认配置
-        if self.retry_config and 'retry_config' not in message:
-            message['retry_config'] = self.retry_config
-        
-        event_id = await self._app.ep.send_event(actual_queue, message, True)
-        # 只设置status，其他信息从Stream消息获取
-        key = f"{self._app.ep.redis_prefix or 'jettask'}:TASK:{event_id}"
-        await self._app.async_redis.hset(key, "status", "pending")
-        await self._app.async_redis.expire(key, 3600)
-        return event_id
-    
-    def send_delayed_task(self, queue, message, delay_seconds):
-        """发送延迟任务（同步）- 使用Redis zset管理延迟队列"""
-        # 添加执行时间到消息中
-        current_time = time.time()
-        execute_at = current_time + delay_seconds
-        message['execute_at'] = execute_at
-        message['is_delayed'] = 1  # 使用1代替True
-        message['trigger_time'] = current_time  # 添加trigger_time字段
-        
-        # 如果queue为None，使用任务名作为队列名
-        actual_queue = queue or self.name
-        
-        # 更新message中的queue字段
-        message['queue'] = actual_queue
-        
-        # 直接发送到正常的队列（Stream），使用stream_id作为event_id
-        stream_id = self._app.ep.send_event(actual_queue, message, asyncio=False)
-        
-        # 将stream_id保存到message中，供worker使用
-        message['event_id'] = stream_id
-        
-        # 将任务添加到延迟队列zset中
-        # key格式: {prefix}:DELAYED_QUEUE:{queue}
-        delayed_queue_key = f"{self._app.ep.redis_prefix or 'jettask'}:DELAYED_QUEUE:{actual_queue}"
-        # 使用执行时间作为score，stream_id作为member
-        self._app.redis.zadd(delayed_queue_key, {stream_id: execute_at})
-        
-        # 只设置status，其他信息从Stream消息获取
-        # 确保stream_id是字符串
-        stream_id_str = stream_id.decode() if isinstance(stream_id, bytes) else stream_id
-        key = f"{self._app.ep.redis_prefix or 'jettask'}:TASK:{stream_id_str}"
-        self._app.redis.hset(key, "status", "delayed")
-        # 确保过期时间是整数（Redis EXPIRE要求整数秒）
-        expire_seconds = max(1, int(delay_seconds + 3600))
-        self._app.redis.expire(key, expire_seconds)
-        
-        return stream_id  # 返回stream_id作为event_id
-    
-    async def _send_delayed_task(self, queue, message, delay_seconds):
-        """发送延迟任务（异步）- 使用Redis zset管理延迟队列"""
-        # 添加执行时间到消息中
-        current_time = time.time()
-        execute_at = current_time + delay_seconds
-        message['execute_at'] = execute_at
-        message['is_delayed'] = 1  # 使用1代替True
-        message['trigger_time'] = current_time  # 添加trigger_time字段
-        
-        # 如果queue为None，使用任务名作为队列名
-        actual_queue = queue or self.name
-        
-        # 更新message中的queue字段
-        message['queue'] = actual_queue
-        
-        # 直接发送到正常的队列（Stream），使用stream_id作为event_id
-        stream_id = await self._app.ep.send_event(actual_queue, message, asyncio=True)
-        
-        # 将stream_id保存到message中，供worker使用
-        message['event_id'] = stream_id
-        
-        # 将任务添加到延迟队列zset中
-        # key格式: {prefix}:DELAYED_QUEUE:{queue}
-        delayed_queue_key = f"{self._app.ep.redis_prefix or 'jettask'}:DELAYED_QUEUE:{actual_queue}"
-        # 使用执行时间作为score，stream_id作为member
-        await self._app.async_redis.zadd(delayed_queue_key, {stream_id: execute_at})
-        
-        # 只设置status，其他信息从Stream消息获取
-        # 确保stream_id是字符串
-        stream_id_str = stream_id.decode() if isinstance(stream_id, bytes) else stream_id
-        key = f"{self._app.ep.redis_prefix or 'jettask'}:TASK:{stream_id_str}"
-        await self._app.async_redis.hset(key, "status", "delayed")
-        # 确保过期时间是整数（Redis EXPIRE要求整数秒）
-        expire_seconds = max(1, int(delay_seconds + 3600))
-        await self._app.async_redis.expire(key, expire_seconds)
-        
-        return stream_id  # 返回stream_id作为event_id
-
     def read_pending(
         self,
         queue: str = None,
@@ -312,4 +147,5 @@ class Task:
         return self._app.ep.read_pending(queue, queue)
 
     async def _get_pending(self, queue: str):
-        return await self._app.ep.read_pending(queue, queue, asyncio=True)
+        return await self._app.ep.read_pending(queue, queue, asyncio=True)
+    

jettask/core/task_batch.py

@@ -0,0 +1,153 @@
+"""
+任务批量发送构建器
+提供类型安全的批量任务发送接口
+"""
+from typing import List, Dict, Any, Optional, Union, TYPE_CHECKING
+import asyncio
+from dataclasses import dataclass, field
+
+if TYPE_CHECKING:
+    from .task import Task
+    from .app import JetTaskApp
+
+
+@dataclass
+class TaskMessage:
+    """单个任务消息"""
+    task_name: str
+    queue: str
+    args: tuple = field(default_factory=tuple)
+    kwargs: dict = field(default_factory=dict)
+    delay: Optional[int] = None
+    timeout: Optional[int] = None
+    max_retries: Optional[int] = None
+    retry_delay: Optional[int] = None
+    scheduled_task_id: Optional[int] = None
+    routing: Optional[dict] = None
+    
+    def to_dict(self) -> dict:
+        """转换为字典格式"""
+        data = {
+            'task_name': self.task_name,
+            'args': self.args,
+            'kwargs': self.kwargs,
+        }
+        
+        # 只添加非None的可选参数
+        optional_fields = ['delay', 'timeout', 'max_retries', 'retry_delay', 
+                          'scheduled_task_id', 'routing']
+        for field in optional_fields:
+            value = getattr(self, field)
+            if value is not None:
+                data[field] = value
+        
+        return data
+
+
+class TaskBatch:
+    """
+    任务批量构建器
+    
+    使用示例:
+        batch = task.batch()
+        batch.add(args=(1,), kwargs={'user': 'alice'})
+        batch.add(args=(2,), kwargs={'user': 'bob'}, delay=5)
+        results = await batch.send()
+    """
+    
+    def __init__(self, task: 'Task', app: 'JetTaskApp'):
+        self.task = task
+        self.app = app
+        self.messages: List[TaskMessage] = []
+        self._queue = task.queue
+        
+    def add(
+        self,
+        args: tuple = None,
+        kwargs: dict = None,
+        queue: str = None,
+        delay: int = None,
+        timeout: int = None,
+        max_retries: int = None,
+        retry_delay: int = None,
+        scheduled_task_id: int = None,
+        routing: dict = None,
+    ) -> 'TaskBatch':
+        """
+        添加一个任务到批量队列
+        
+        参数签名与 apply_async 完全一致，保证IDE提示
+        
+        Args:
+            args: 位置参数
+            kwargs: 关键字参数
+            queue: 指定队列（默认使用task的队列）
+            delay: 延迟执行时间（秒）
+            timeout: 任务超时时间（秒）
+            max_retries: 最大重试次数
+            retry_delay: 重试间隔（秒）
+            scheduled_task_id: 定时任务ID
+            routing: 路由信息
+            
+        Returns:
+            self: 支持链式调用
+        """
+        message = TaskMessage(
+            task_name=self.task.name,
+            queue=queue or self._queue,
+            args=args or (),
+            kwargs=kwargs or {},
+            delay=delay,
+            timeout=timeout,
+            max_retries=max_retries,
+            retry_delay=retry_delay,
+            scheduled_task_id=scheduled_task_id,
+            routing=routing,
+        )
+        self.messages.append(message)
+        return self
+    
+    async def send(self) -> List[str]:
+        """
+        批量发送所有任务
+        
+        Returns:
+            List[str]: 任务ID列表
+        """
+        if not self.messages:
+            return []
+        
+        # 转换为批量写入格式
+        batch_data = []
+        for msg in self.messages:
+            batch_data.append({
+                'queue': msg.queue,
+                'data': msg.to_dict()
+            })
+        
+        # 调用app的批量写入方法
+        # 这里假设app有一个内部的批量写入方法
+        result = await self.app._bulk_write_messages(batch_data)
+        
+        # 清空消息列表，允许复用
+        self.messages.clear()
+        
+        return result
+    
+    def send_sync(self) -> List[str]:
+        """
+        同步版本的批量发送
+        
+        Returns:
+            List[str]: 任务ID列表
+        """
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(self.send())
+    
+    def __len__(self) -> int:
+        """返回当前批量任务的数量"""
+        return len(self.messages)
+    
+    def clear(self) -> None:
+        """清空批量任务列表"""
+        self.messages.clear()

jettask/core/unified_manager_base.py

@@ -0,0 +1,243 @@
+"""
+统一的多命名空间管理器基类
+提供单/多命名空间模式的通用功能
+"""
+import re
+import logging
+import aiohttp
+from typing import Optional, Set, Dict, Any
+from abc import ABC, abstractmethod
+
+logger = logging.getLogger(__name__)
+
+
+class UnifiedManagerBase(ABC):
+    """
+    统一管理器基类
+    根据task_center_url自动判断是单命名空间还是多命名空间模式
+    """
+    
+    def __init__(self, 
+                 task_center_url: str,
+                 check_interval: int = 30,
+                 debug: bool = False):
+        """
+        初始化基础管理器
+        
+        Args:
+            task_center_url: 任务中心URL
+                - 单命名空间: http://localhost:8001/api/namespaces/{name}
+                - 多命名空间: http://localhost:8001 或 http://localhost:8001/api
+            check_interval: 命名空间检测间隔（秒）
+            debug: 是否启用调试模式
+        """
+        self.task_center_url = task_center_url.rstrip('/')
+        self.check_interval = check_interval
+        self.debug = debug
+        
+        # 判断模式
+        self.namespace_name: Optional[str] = None
+        self.is_single_namespace = self._detect_mode()
+        
+        # 运行状态
+        self.running = False
+        
+        # 设置日志
+        if debug:
+            logging.basicConfig(level=logging.DEBUG)
+        else:
+            logging.basicConfig(level=logging.INFO)
+    
+    def _detect_mode(self) -> bool:
+        """
+        检测是单命名空间还是多命名空间模式
+        
+        Returns:
+            True: 单命名空间模式
+            False: 多命名空间模式
+        """
+        # 检查URL格式
+        # 单命名空间: /api/namespaces/{name}
+        # 多命名空间: 不包含 /api/namespaces/ 或以 /api 结尾
+        
+        if '/api/namespaces/' in self.task_center_url:
+            # 提取命名空间名称
+            match = re.search(r'/api/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
+    
+    def get_base_url(self) -> str:
+        """
+        获取任务中心的基础URL
+        
+        Returns:
+            基础URL（去除命名空间路径）
+        """
+        if self.is_single_namespace and '/api/namespaces/' in self.task_center_url:
+            # 从 http://localhost:8001/api/namespaces/default 提取 http://localhost:8001
+            return self.task_center_url.split('/api/namespaces/')[0]
+        return self.task_center_url
+    
+    def get_target_namespaces(self) -> Optional[Set[str]]:
+        """
+        获取目标命名空间集合
+        
+        Returns:
+            单命名空间模式: 返回包含单个命名空间的集合
+            多命名空间模式: 返回 None（表示所有命名空间）
+        """
+        if self.is_single_namespace and self.namespace_name:
+            return {self.namespace_name}
+        return None
+    
+    async def fetch_namespaces_info(self, namespace_names: Optional[Set[str]] = None) -> list:
+        """
+        从任务中心API获取命名空间配置
+        
+        Args:
+            namespace_names: 要获取的命名空间名称集合，None表示获取所有
+            
+        Returns:
+            命名空间配置列表
+        """
+        namespaces = []
+        
+        try:
+            # 获取基础URL
+            base_url = self.get_base_url()
+            
+            if namespace_names:
+                # 获取指定的命名空间
+                for name in namespace_names:
+                    try:
+                        async with aiohttp.ClientSession() as session:
+                            url = f"{base_url}/api/namespaces/{name}"
+                            logger.debug(f"请求命名空间配置: {url}")
+                            
+                            async with session.get(url) as response:
+                                if response.status == 200:
+                                    data = await response.json()
+                                    ns_info = {
+                                        'id': data['id'],
+                                        'name': data['name'],
+                                        'redis_config': data.get('redis_config', {}),
+                                        'pg_config': data.get('pg_config', {}),
+                                        'redis_prefix': data['name']  # 直接使用命名空间名称作为前缀
+                                    }
+                                    namespaces.append(ns_info)
+                                    logger.info(f"成功获取命名空间 {name} 的配置")
+                                else:
+                                    logger.warning(f"获取命名空间 {name} 失败: HTTP {response.status}")
+                    except Exception as e:
+                        logger.error(f"获取命名空间 {name} 失败: {e}")
+            else:
+                # 获取所有命名空间
+                async with aiohttp.ClientSession() as session:
+                    url = f"{base_url}/api/namespaces"
+                    logger.debug(f"请求所有命名空间配置: {url}")
+                    
+                    async with session.get(url) as response:
+                        if response.status == 200:
+                            data_list = await response.json()
+                            for data in data_list:
+                                ns_info = {
+                                    'id': data['id'],
+                                    'name': data['name'],
+                                    'redis_config': data.get('redis_config', {}),
+                                    'pg_config': data.get('pg_config', {}),
+                                    'redis_prefix': data['name']  # 直接使用命名空间名称作为前缀
+                                }
+                                namespaces.append(ns_info)
+                            logger.info(f"成功获取 {len(namespaces)} 个命名空间的配置")
+                        else:
+                            logger.error(f"获取命名空间列表失败: HTTP {response.status}")
+                            
+        except Exception as e:
+            logger.error(f"从任务中心获取命名空间配置失败: {e}")
+            # 如果API调用失败，可以使用默认配置作为回退
+            if not namespaces and (not namespace_names or 'default' in namespace_names):
+                logger.warning("使用默认命名空间配置作为回退")
+                namespaces.append({
+                    'id': 1,
+                    'name': 'default',
+                    'redis_config': {
+                        'host': 'localhost',
+                        'port': 6379,
+                        'db': 0,
+                        'password': None
+                    },
+                    'pg_config': {
+                        'host': 'localhost',
+                        'port': 5432,
+                        'database': 'jettask',
+                        'user': 'jettask',
+                        'password': '123456'
+                    },
+                    'redis_prefix': 'default'
+                })
+                
+        return namespaces
+    
+    async def run(self):
+        """运行管理器（统一处理单/多命名空间）"""
+        self.running = True
+        
+        logger.info(f"启动 {self.__class__.__name__}")
+        logger.info(f"任务中心: {self.task_center_url}")
+        logger.info(f"模式: {'单命名空间' if self.is_single_namespace else '多命名空间'}")
+        
+        if not self.is_single_namespace:
+            logger.info(f"检测间隔: {self.check_interval}秒")
+        
+        # 获取目标命名空间
+        target_namespaces = self.get_target_namespaces()
+        
+        try:
+            if self.is_single_namespace:
+                # 单命名空间模式
+                await self.run_single_namespace(self.namespace_name)
+            else:
+                # 多命名空间模式
+                await self.run_multi_namespace(target_namespaces)
+        except KeyboardInterrupt:
+            logger.info("收到中断信号")
+        except Exception as e:
+            logger.error(f"运行错误: {e}", exc_info=self.debug)
+        finally:
+            self.stop()
+            await self.cleanup()
+    
+    @abstractmethod
+    async def run_single_namespace(self, namespace_name: str):
+        """
+        运行单命名空间模式
+        
+        Args:
+            namespace_name: 命名空间名称
+        """
+        pass
+    
+    @abstractmethod
+    async def run_multi_namespace(self, namespace_names: Optional[Set[str]]):
+        """
+        运行多命名空间模式
+        
+        Args:
+            namespace_names: 目标命名空间集合，None表示所有命名空间
+        """
+        pass
+    
+    def stop(self):
+        """停止管理器"""
+        self.running = False
+        logger.info(f"停止 {self.__class__.__name__}")
+    
+    async def cleanup(self):
+        """清理资源（子类可重写）"""
+        pass