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

jettask/core/app.py

@@ -107,7 +107,7 @@ def get_async_redis_pool(redis_url: str, max_connections: int = 200):
     return _async_redis_pools[redis_url]
 
 def get_binary_redis_pool(redis_url: str, max_connections: int = 200):
-    """获取或创建用于二进制数据的Redis连接池（不解码响应）"""
+    """获取或创建用于二进制数据的Redis连接池（Stream操作需要）"""
     if redis_url not in _binary_redis_pools:
         # 构建socket keepalive选项，仅在Linux上使用
         socket_keepalive_options = {}
@@ -120,7 +120,7 @@ def get_binary_redis_pool(redis_url: str, max_connections: int = 200):
         
         _binary_redis_pools[redis_url] = redis.ConnectionPool.from_url(
             redis_url, 
-            decode_responses=False,  # 不解码，保持二进制
+            decode_responses=False,  # 不解码，因为Stream数据是msgpack二进制
             max_connections=max_connections,
             retry_on_timeout=True,
             retry_on_error=[ConnectionError, TimeoutError],
@@ -134,7 +134,7 @@ def get_binary_redis_pool(redis_url: str, max_connections: int = 200):
     return _binary_redis_pools[redis_url]
 
 def get_async_binary_redis_pool(redis_url: str, max_connections: int = 200):
-    """获取或创建用于二进制数据的异步Redis连接池（不解码响应）"""
+    """获取或创建用于二进制数据的异步Redis连接池（Stream操作需要）"""
     if redis_url not in _async_binary_redis_pools:
         # 构建socket keepalive选项，仅在Linux上使用
         socket_keepalive_options = {}
@@ -147,7 +147,7 @@ def get_async_binary_redis_pool(redis_url: str, max_connections: int = 200):
         
         _async_binary_redis_pools[redis_url] = aioredis.ConnectionPool.from_url(
             redis_url,
-            decode_responses=False,  # 不解码，保持二进制
+            decode_responses=False,  # 不解码，因为Stream数据是msgpack二进制
             max_connections=max_connections,
             retry_on_timeout=True,
             retry_on_error=[ConnectionError, TimeoutError],
@@ -183,8 +183,15 @@ class Jettask(object):
         local delay_seconds = tonumber(ARGV[i+3])
         local queue = ARGV[i+4]
         
-        -- 1. 添加消息到Stream
-        local stream_id = redis.call('XADD', stream_key, '*', 'data', stream_data)
+        -- 使用Hash存储所有队列的offset
+        local offsets_hash = prefix .. ':QUEUE_OFFSETS'
+        -- 使用HINCRBY原子递增offset
+        local offset = redis.call('HINCRBY', offsets_hash, queue, 1)
+        
+        -- 1. 添加消息到Stream（包含offset字段）
+        local stream_id = redis.call('XADD', stream_key, '*', 
+            'data', stream_data,
+            'offset', offset)
         
         -- 2. 添加到延迟队列ZSET
         local delayed_queue_key = prefix .. ':DELAYED_QUEUE:' .. queue
@@ -216,8 +223,17 @@ class Jettask(object):
         local stream_key = ARGV[i]
         local stream_data = ARGV[i+1]
         
-        -- 1. 添加消息到Stream
-        local stream_id = redis.call('XADD', stream_key, '*', 'data', stream_data)
+        -- 从stream_key中提取队列名（格式: prefix:STREAM:queue_name）
+        local queue_name = string.match(stream_key, prefix .. ':STREAM:(.*)')
+        
+        -- 获取并递增offset
+        local offset_key = prefix .. ':STREAM:' .. queue_name .. ':next_offset'
+        local offset = redis.call('INCR', offset_key)
+        
+        -- 1. 添加消息到Stream（包含offset字段）
+        local stream_id = redis.call('XADD', stream_key, '*', 
+            'data', stream_data,
+            'offset', offset)
         
         -- 2. 设置任务状态Hash（只存储status）
         local task_key = prefix .. ':TASK:' .. stream_id
@@ -235,10 +251,19 @@ class Jettask(object):
 
     def __init__(self, redis_url: str = None, include: list = None, max_connections: int = 200, 
                  consumer_strategy: str = None, consumer_config: dict = None, tasks=None,
-                 redis_prefix: str = None, scheduler_config: dict = None, pg_url: str = None) -> None:
+                 redis_prefix: str = None, scheduler_config: dict = None, pg_url: str = None,
+                 task_center=None) -> None:
         self._tasks = tasks or {}
+        self._queue_tasks = {}  # 记录每个队列对应的任务列表
         self.asyncio = False
         self.include = include or []
+        
+        # 任务中心相关属性
+        self.task_center = None  # 将通过mount_task_center方法挂载或初始化时指定
+        self._task_center_config = None
+        self._original_redis_url = redis_url
+        self._original_pg_url = pg_url
+        
         self.redis_url = redis_url
         self.pg_url = pg_url  # 存储PostgreSQL URL
         self.max_connections = max_connections
@@ -249,6 +274,10 @@ class Jettask(object):
         # Redis prefix configuration
         self.redis_prefix = redis_prefix or "jettask"
         
+        # 如果初始化时提供了task_center，直接挂载
+        if task_center:
+            self.mount_task_center(task_center)
+        
         # Update prefixes with the configured prefix using colon namespace
         self.STATUS_PREFIX = f"{self.redis_prefix}:STATUS:"
         self.RESULT_PREFIX = f"{self.redis_prefix}:RESULT:"
@@ -270,6 +299,236 @@ class Jettask(object):
         self._worker_started = False
         self._handlers_registered = False
     
+    async def _load_config_from_task_center_async(self):
+        """异步加载任务中心配置"""
+        try:
+            if not self.task_center:
+                return False
+            
+            # 连接并获取配置
+            connected = await self.task_center.connect()
+            if not connected:
+                return False
+            
+            config = {
+                'redis_config': self.task_center.redis_config,
+                'pg_config': self.task_center.pg_config,
+                'namespace_name': self.task_center.namespace_name,
+                'version': self.task_center.version
+            }
+            
+            if config['redis_config']:
+                # 任务中心配置优先级高于手动配置
+                redis_config = config.get('redis_config', {})
+                pg_config = config.get('pg_config', {})
+                # 构建Redis URL
+                if redis_config:
+                    redis_host = redis_config.get('host', 'localhost')
+                    redis_port = redis_config.get('port', 6379)
+                    redis_password = redis_config.get('password')
+                    redis_db = redis_config.get('db', 0)
+                    
+                    if redis_password:
+                        self.redis_url = f"redis://:{redis_password}@{redis_host}:{redis_port}/{redis_db}"
+                    else:
+                        self.redis_url = f"redis://{redis_host}:{redis_port}/{redis_db}"
+                    
+                    logger.info(f"从任务中心加载Redis配置: {redis_host}:{redis_port}/{redis_db}")
+                
+                # 构建PostgreSQL URL
+                if pg_config:
+                    pg_host = pg_config.get('host', 'localhost')
+                    pg_port = pg_config.get('port', 5432)
+                    pg_user = pg_config.get('user', 'postgres')
+                    pg_password = pg_config.get('password', '')
+                    pg_database = pg_config.get('database', 'jettask')
+                    
+                    self.pg_url = f"postgresql://{pg_user}:{pg_password}@{pg_host}:{pg_port}/{pg_database}"
+                    logger.info(f"从任务中心加载PostgreSQL配置: {pg_host}:{pg_port}/{pg_database}")
+                
+                # 保存配置供后续使用
+                self._task_center_config = config
+                
+                # 更新Redis前缀为命名空间名称
+                if self.task_center and self.task_center.redis_prefix != "jettask":
+                    self.redis_prefix = self.task_center.redis_prefix
+                    # 更新相关前缀
+                    self.STATUS_PREFIX = f"{self.redis_prefix}:STATUS:"
+                    self.RESULT_PREFIX = f"{self.redis_prefix}:RESULT:"
+                
+                # 清理已缓存的Redis连接，强制重新创建
+                if hasattr(self, '_redis'):
+                    delattr(self, '_redis')
+                if hasattr(self, '_async_redis'):
+                    delattr(self, '_async_redis')
+                if hasattr(self, '_ep'):
+                    delattr(self, '_ep')
+                    
+                return True
+        except Exception as e:
+            logger.warning(f"从任务中心加载配置失败: {e}")
+            return False
+    
+    def _load_config_from_task_center(self):
+        """从任务中心加载配置"""
+        try:
+            import asyncio
+            # 检查是否已经在事件循环中
+            try:
+                loop = asyncio.get_running_loop()
+                # 已在事件循环中，无法同步加载
+                return False
+            except RuntimeError:
+                # 不在事件循环中，可以创建新的
+                loop = asyncio.new_event_loop()
+                if self.task_center:
+                    # 如果已经初始化，直接获取配置
+                    if self.task_center._initialized:
+                        config = self.task_center._config
+                    else:
+                        # 使用异步模式连接
+                        success = loop.run_until_complete(self.task_center.connect(asyncio=True))
+                        if success:
+                            config = self.task_center._config
+                        else:
+                            config = None
+                else:
+                    config = None
+                loop.close()
+            
+            if config:
+                # 任务中心配置优先级高于手动配置
+                redis_config = config.get('redis_config', {})
+                pg_config = config.get('pg_config', {})
+                # 构建Redis URL
+                if redis_config:
+                    redis_host = redis_config.get('host', 'localhost')
+                    redis_port = redis_config.get('port', 6379)
+                    redis_password = redis_config.get('password')
+                    redis_db = redis_config.get('db', 0)
+                    
+                    if redis_password:
+                        self.redis_url = f"redis://:{redis_password}@{redis_host}:{redis_port}/{redis_db}"
+                    else:
+                        self.redis_url = f"redis://{redis_host}:{redis_port}/{redis_db}"
+                    
+                    logger.info(f"从任务中心加载Redis配置: {redis_host}:{redis_port}/{redis_db}")
+                
+                # 构建PostgreSQL URL
+                if pg_config:
+                    pg_host = pg_config.get('host', 'localhost')
+                    pg_port = pg_config.get('port', 5432)
+                    pg_user = pg_config.get('user', 'postgres')
+                    pg_password = pg_config.get('password', '')
+                    pg_database = pg_config.get('database', 'jettask')
+                    
+                    self.pg_url = f"postgresql://{pg_user}:{pg_password}@{pg_host}:{pg_port}/{pg_database}"
+                    logger.info(f"从任务中心加载PostgreSQL配置: {pg_host}:{pg_port}/{pg_database}")
+                
+                # 保存配置供后续使用
+                self._task_center_config = config
+                
+                # 更新Redis前缀为命名空间名称
+                if self.task_center and self.task_center.redis_prefix != "jettask":
+                    self.redis_prefix = self.task_center.redis_prefix
+                    # 更新相关前缀
+                    self.STATUS_PREFIX = f"{self.redis_prefix}:STATUS:"
+                    self.RESULT_PREFIX = f"{self.redis_prefix}:RESULT:"
+                
+                # 清理已缓存的Redis连接，强制重新创建
+                if hasattr(self, '_redis'):
+                    delattr(self, '_redis')
+                if hasattr(self, '_async_redis'):
+                    delattr(self, '_async_redis')
+                if hasattr(self, '_ep'):
+                    delattr(self, '_ep')
+                
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            logger.warning(f"从任务中心加载配置失败，使用手动配置: {e}")
+            # 恢复原始配置
+            self.redis_url = self._original_redis_url
+            self.pg_url = self._original_pg_url
+    
+    def mount_task_center(self, task_center):
+        """
+        挂载任务中心到Jettask应用
+        
+        如果task_center已经连接，会自动应用配置到当前app。
+        
+        Args:
+            task_center: TaskCenter实例
+            
+        使用示例：
+            from jettask.webui.task_center import TaskCenter
+            
+            # 创建任务中心客户端（可复用）
+            task_center = TaskCenter("http://localhost:8001/api/namespaces/demo")
+            await task_center.connect()  # 只需连接一次
+            
+            # 创建多个app实例，共享同一个task_center
+            app1 = Jettask()
+            app1.mount_task_center(task_center)  # 自动应用配置
+            
+            app2 = Jettask()
+            app2.mount_task_center(task_center)  # 复用配置
+        """
+        self.task_center = task_center
+        
+        # 如果任务中心已连接，立即应用所有配置
+        if task_center and task_center._initialized:
+            # 应用Redis配置
+            if task_center.redis_config:
+                redis_url = task_center.get_redis_url()
+                if redis_url:
+                    self.redis_url = redis_url
+                    
+            # 应用PostgreSQL配置
+            if task_center.pg_config:
+                pg_url = task_center.get_pg_url()
+                if pg_url:
+                    self.pg_url = pg_url
+            
+            # 更新Redis前缀
+            self.redis_prefix = task_center.redis_prefix
+            # 更新相关前缀
+            self.STATUS_PREFIX = f"{self.redis_prefix}:STATUS:"
+            self.RESULT_PREFIX = f"{self.redis_prefix}:RESULT:"
+            self.QUEUE_PREFIX = f"{self.redis_prefix}:QUEUE:"
+            self.DELAYED_QUEUE_PREFIX = f"{self.redis_prefix}:DELAYED_QUEUE:"
+            self.STREAM_PREFIX = f"{self.redis_prefix}:STREAM:"
+            self.TASK_PREFIX = f"{self.redis_prefix}:TASK:"
+            self.SCHEDULER_PREFIX = f"{self.redis_prefix}:SCHEDULED:"
+            self.LOCK_PREFIX = f"{self.redis_prefix}:LOCK:"
+            
+            # 标记配置已加载
+            self._task_center_config = {
+                'redis_config': task_center.redis_config,
+                'pg_config': task_center.pg_config,
+                'namespace_name': task_center.namespace_name,
+                'version': task_center.version
+            }
+    
+    async def init_from_task_center(self):
+        """
+        从任务中心初始化配置（异步方法）
+        
+        在异步环境中发送任务前调用此方法，确保配置已加载
+        
+        使用示例：
+            from jettask.webui.task_center import TaskCenter
+            
+            task_center = TaskCenter("http://localhost:8001/api/namespaces/demo")
+            app = Jettask()
+            app.mount_task_center(task_center)
+            await app.init_from_task_center()  # 会自动连接task_center
+            await task.apply_async(...)
+        """
+        if self.task_center and self.task_center.is_enabled and not self._task_center_config:
+            return await self._load_config_from_task_center_async()
+        return True
+    
     def _setup_cleanup_handlers(self):
         """设置清理处理器"""
         # 避免重复注册
@@ -343,6 +602,10 @@ class Jettask(object):
         if hasattr(self, name):
             return getattr(self, name)
         
+        # 如果配置了任务中心且还未加载配置，先加载配置
+        if self.task_center and self.task_center.is_enabled and not self._task_center_config:
+            self._load_config_from_task_center()
+        
         pool = get_async_redis_pool(self.redis_url, self.max_connections)
         async_redis = aioredis.StrictRedis(connection_pool=pool)
         setattr(self, name, async_redis)
@@ -354,7 +617,11 @@ class Jettask(object):
         name = "_redis"
         if hasattr(self, name):
             return getattr(self, name)
-            
+        
+        # 如果配置了任务中心且还未加载配置，先加载配置
+        if self.task_center and self.task_center.is_enabled and not self._task_center_config:
+            self._load_config_from_task_center()
+        
         pool = get_redis_pool(self.redis_url, self.max_connections)
         redis_cli = redis.StrictRedis(connection_pool=pool)
         setattr(self, name, redis_cli)
@@ -416,6 +683,9 @@ class Jettask(object):
     ) -> Task:
         name = name or gen_task_name(fun.__name__, fun.__module__)
         base = base or Task
+        
+        # 不再限制队列模式，因为每个task都有独立的consumer group
+        
         if name not in self._tasks:
             run = staticmethod(fun)
             task: Task = type(
@@ -441,6 +711,12 @@ class Jettask(object):
             with contextlib.suppress(AttributeError):
                 task.__qualname__ = fun.__qualname__
             self._tasks[task.name] = task
+            
+            # 记录队列和任务的映射（用于查找）
+            if queue:
+                if queue not in self._queue_tasks:
+                    self._queue_tasks[queue] = []
+                self._queue_tasks[queue].append(name)
         else:
             task = self._tasks[name]
         return task
@@ -477,56 +753,196 @@ class Jettask(object):
 
         return _create_task_cls
     
-    def publish_broadcast(
-        self,
-        queue: str,
-        message: dict,
-        target_tasks: list = None,
-        asyncio_mode: bool = False
-    ):
+    async def send_tasks(self, messages: list):
         """
-        发布广播消息到队列
+        统一的任务发送接口 - 只有这一个发送方法
         
         Args:
-            queue: 目标队列名
-            message: 消息内容
-            target_tasks: 目标任务列表（None表示所有监听该队列的任务）
-            asyncio_mode: 是否使用异步模式
-        
+            messages: TaskMessage对象列表（或字典列表）
+            
         Returns:
-            消息ID或协程对象
-        
-        使用示例：
-            # 同步模式
-            app.publish_broadcast(
-                queue="events",
-                message={"type": "customer_registered", "data": {...}}
-            )
+            List[str]: 任务ID列表
             
-            # 异步模式
-            await app.publish_broadcast(
-                queue="events",
-                message={"type": "order_created", "data": {...}},
-                target_tasks=["send_email", "update_inventory"],
-                asyncio_mode=True
+        使用示例:
+            from jettask.core.message import TaskMessage
+            
+            # 发送单个任务（也是用列表）
+            msg = TaskMessage(
+                queue="order_processing",
+                args=(12345,),
+                kwargs={"customer_id": "C001", "amount": 99.99}
             )
+            task_ids = await app.send_tasks([msg])
+            
+            # 批量发送
+            messages = [
+                TaskMessage(queue="email", kwargs={"to": "user1@example.com"}),
+                TaskMessage(queue="email", kwargs={"to": "user2@example.com"}),
+                TaskMessage(queue="sms", kwargs={"phone": "123456789"}),
+            ]
+            task_ids = await app.send_tasks(messages)
+            
+            # 跨项目发送（不需要task定义）
+            messages = [
+                TaskMessage(queue="remote_queue", kwargs={"data": "value"})
+            ]
+            task_ids = await app.send_tasks(messages)
         """
-        # 构建广播消息，直接序列化整个消息
+        if not messages:
+            return []
+        
+        # 导入TaskMessage
+        from .message import TaskMessage
+        
+        results = []
+        
+        # 按队列分组消息，以便批量处理
+        queue_messages = {}
+        for msg in messages:
+            # 支持TaskMessage对象或字典
+            if isinstance(msg, dict):
+                msg = TaskMessage.from_dict(msg)
+            elif not isinstance(msg, TaskMessage):
+                raise ValueError(f"Invalid message type: {type(msg)}. Expected TaskMessage or dict")
+            
+            # 验证消息
+            msg.validate()
+            
+            # 确定实际的队列名（考虑优先级）
+            actual_queue = msg.queue
+            if msg.priority is not None:
+                # 将优先级拼接到队列名后面
+                actual_queue = f"{msg.queue}:{msg.priority}"
+                # 更新消息体中的queue字段，确保与实际发送的stream key一致
+                msg.queue = actual_queue
+            
+            # 按队列分组
+            if actual_queue not in queue_messages:
+                queue_messages[actual_queue] = []
+            queue_messages[actual_queue].append(msg)
+        
+        # 处理每个队列的消息
+        for queue, queue_msgs in queue_messages.items():
+            # 统一使用批量发送，无论是否广播模式
+            # 广播/单播由消费端的consumer group name决定
+            batch_results = await self._send_batch_messages(queue, queue_msgs)
+            results.extend(batch_results)
+        
+        return results
+    
+    async def _send_batch_messages(self, queue: str, messages: list) -> list:
+        """批量发送single模式消息（内部方法）"""
         from ..utils.serializer import dumps_str
         
-        # 创建完整的广播消息
-        broadcast_message = {
-            **message,  # 用户的原始消息
-            "_broadcast": True,
-            "_target_tasks": target_tasks,
-            "_timestamp": time.time(),
-            "trigger_time": time.time()
-        }
-        # 使用EventPool的send_event方法，保持和apply_async一致的格式
-        if asyncio_mode:
-            return self.ep.send_event(queue, broadcast_message, asyncio=True)
-        else:
-            return self.ep.send_event(queue, broadcast_message, asyncio=False)
+        # 分离普通任务和延迟任务
+        normal_messages = []
+        delayed_messages = []
+        
+        for msg in messages:
+            msg_dict = msg.to_dict()
+            
+            # 处理延迟任务
+            if msg.delay and msg.delay > 0:
+                # 添加延迟执行标记
+                current_time = time.time()
+                msg_dict['execute_at'] = current_time + msg.delay
+                msg_dict['is_delayed'] = 1
+                delayed_messages.append((msg_dict, msg.delay))
+            else:
+                normal_messages.append(msg_dict)
+        
+        results = []
+        
+        # 发送普通任务（统一使用批量发送）
+        if normal_messages:
+            batch_results = await self.ep._batch_send_event(
+                self.ep.get_prefixed_queue_name(queue),
+                [{'data': dumps_str(msg)} for msg in normal_messages],
+                self.ep.get_redis_client(asyncio=True, binary=True).pipeline()
+            )
+            results.extend(batch_results)
+        
+        # 发送延迟任务（需要同时添加到DELAYED_QUEUE）
+        if delayed_messages:
+            delayed_results = await self._send_delayed_tasks(queue, delayed_messages)
+            results.extend(delayed_results)
+        
+        return results
+    
+    async def _send_delayed_tasks(self, queue: str, delayed_messages: list) -> list:
+        """发送延迟任务到Stream并添加到延迟队列"""
+        from ..utils.serializer import dumps_str
+        
+        # 使用Lua脚本原子性地处理延迟任务
+        lua_script = """
+        local prefix = ARGV[1]
+        local results = {}
+        
+        -- 从ARGV[2]开始，每4个参数为一组任务信息
+        -- [stream_key, stream_data, execute_at, queue]
+        for i = 2, #ARGV, 4 do
+            local stream_key = ARGV[i]
+            local stream_data = ARGV[i+1]
+            local execute_at = tonumber(ARGV[i+2])
+            local queue_name = ARGV[i+3]
+            
+            -- 使用Hash存储所有队列的offset
+            local offsets_hash = prefix .. ':QUEUE_OFFSETS'
+            
+            -- 从stream_key中提取队列名
+            local queue_name = string.gsub(stream_key, '^' .. prefix .. ':QUEUE:', '')
+            
+            -- 使用HINCRBY原子递增offset
+            local current_offset = redis.call('HINCRBY', offsets_hash, queue_name, 1)
+            
+            -- 1. 添加消息到Stream（包含offset字段）
+            local stream_id = redis.call('XADD', stream_key, '*', 
+                'data', stream_data,
+                'offset', current_offset)
+            
+            -- 2. 添加到延迟队列ZSET
+            local delayed_queue_key = prefix .. ':DELAYED_QUEUE:' .. queue_name
+            redis.call('ZADD', delayed_queue_key, execute_at, stream_id)
+            
+            -- 3. 设置任务状态Hash
+            local task_key = prefix .. ':TASK:' .. stream_id
+            redis.call('HSET', task_key, 'status', 'delayed')
+            redis.call('EXPIRE', task_key, 3600)
+            
+            -- 保存stream_id到结果
+            table.insert(results, stream_id)
+        end
+        
+        return results
+        """
+        
+        # 准备Lua脚本参数
+        lua_args = [self.redis_prefix]
+        prefixed_queue = self.ep.get_prefixed_queue_name(queue)
+        
+        for msg_dict, delay_seconds in delayed_messages:
+            stream_data = dumps_str(msg_dict)
+            execute_at = msg_dict['execute_at']
+            
+            lua_args.extend([
+                prefixed_queue,
+                stream_data,
+                str(execute_at),
+                queue
+            ])
+        
+        # 执行Lua脚本
+        client = self.ep.get_redis_client(asyncio=True, binary=True)
+        
+        # 注册Lua脚本
+        if not hasattr(self, '_delayed_task_script'):
+            self._delayed_task_script = client.register_script(lua_script)
+        
+        # 执行脚本
+        results = await self._delayed_task_script(keys=[], args=lua_args)
+        
+        # 解码结果
+        return [r.decode('utf-8') if isinstance(r, bytes) else r for r in results]
     
     def register_router(self, router, prefix: str = None):
         """
@@ -662,12 +1078,16 @@ class Jettask(object):
                 executor = AsyncioExecutor(async_event_queue, self, concurrency)
                 await executor.loop()
             
-            # try:
-            loop = asyncio.get_event_loop()
-            # except RuntimeError:
-            #     # 如果当前线程没有事件循环，创建一个新的
-            #     loop = asyncio.new_event_loop()
-            #     asyncio.set_event_loop(loop)
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    # 如果事件循环已经在运行，创建一个新的
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+            except RuntimeError:
+                # 如果当前线程没有事件循环，创建一个新的
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
             
             try:
                 loop.run_until_complete(run_asyncio_executor())
@@ -718,6 +1138,10 @@ class Jettask(object):
         # 标记worker已启动
         self._worker_started = True
         
+        # 如果配置了任务中心，从任务中心获取配置
+        if self.task_center and self.task_center.is_enabled:
+            self._load_config_from_task_center()
+        
         # 注册清理处理器（只在启动worker时注册）
         self._setup_cleanup_handlers()
         
@@ -754,147 +1178,6 @@ class Jettask(object):
                     logger.warning("Process did not terminate, killing...")
                     self.process.kill()
 
-    def bulk_write(self, tasks: list, asyncio: bool = None):
-        """
-        统一的批量写入方法，支持同步和异步模式，以及延迟任务
-        
-        Args:
-            tasks: 任务列表
-            asyncio: 是否使用异步模式。如果为None，自动检测
-        
-        Returns:
-            同步模式: 返回event_ids列表
-            异步模式: 如果在异步环境中调用，返回协程对象
-        """
-        if not tasks:
-            raise ValueError("tasks 参数不能为空！")
-        
-        # 自动检测异步模式
-        if asyncio is None:
-            import asyncio as aio
-            try:
-                loop = aio.get_running_loop()
-                asyncio = True
-            except RuntimeError:
-                asyncio = False
-        
-        # 如果需要异步执行
-        if asyncio:
-            return self._bulk_write_async(tasks)
-        
-        # 同步执行
-        import asyncio as aio
-        # 在同步模式下，使用 asyncio.run 来运行异步函数
-        return aio.run(self._bulk_write_impl(tasks, asyncio_mode=False))
-    
-    async def _bulk_write_impl(self, tasks: list, asyncio_mode: bool):
-        """批量写入的内部实现，支持同步和异步"""
-        # 获取对应的Redis客户端
-        redis_client = self.get_redis_client(asyncio=asyncio_mode)
-        
-        # 分离延迟任务和普通任务
-        delayed_tasks = []
-        normal_tasks = []
-        
-        for task in tasks:
-            if 'delay' in task:
-                delayed_tasks.append(task)
-            else:
-                normal_tasks.append(task)
-        
-        event_ids = []
-        
-        # 处理延迟任务 - 使用Lua脚本原子性处理
-        if delayed_tasks:
-            
-            # 准备Lua脚本参数
-            current_time = time.time()
-            lua_args = [self.redis_prefix, str(current_time)]
-            
-            for task in delayed_tasks:
-                delay_seconds = task.pop('delay')  # 移除delay参数
-                queue = task.get("queue")
-                
-                # 添加执行时间到消息中
-                execute_at = current_time + delay_seconds
-                task['execute_at'] = execute_at
-                task['is_delayed'] = 1  # 使用1代替True
-                task['trigger_time'] = current_time  # 添加trigger_time
-                
-                # 如果queue为None，使用任务名作为队列名
-                task_name = task.get("name", "")
-                actual_queue = queue or task_name
-                task['queue'] = actual_queue
-                
-                # 准备Stream数据
-                prefixed_queue = self.ep.get_prefixed_queue_name(actual_queue)
-                from ..utils.serializer import dumps_str
-                stream_data = dumps_str(task)
-                
-                # 添加到Lua脚本参数
-                lua_args.extend([
-                    prefixed_queue,
-                    stream_data,
-                    str(execute_at),
-                    str(delay_seconds),
-                    actual_queue
-                ])
-            
-            # 注册并执行Lua脚本（使用类常量）
-            script_attr = '_bulk_delayed_script_async' if asyncio_mode else '_bulk_delayed_script_sync'
-            if not hasattr(self, script_attr):
-                setattr(self, script_attr, redis_client.register_script(self._LUA_SCRIPT_DELAYED_TASKS))
-            
-            script = getattr(self, script_attr)
-            if asyncio_mode:
-                # 异步执行需要await
-                stream_ids = await script(keys=[], args=lua_args)
-            else:
-                stream_ids = script(keys=[], args=lua_args)
-            
-            event_ids.extend(stream_ids)
-        
-        # 处理普通任务 - 使用Lua脚本原子性处理
-        if normal_tasks:
-            
-            # 准备Lua脚本参数
-            current_time = str(time.time())
-            lua_args = [self.redis_prefix, current_time]
-            
-            # 按队列分组并准备参数
-            from ..utils.serializer import dumps_str
-            for task in normal_tasks:
-                queue = task.get("queue")
-                task_name = task.get("name", "")
-                actual_queue = queue or task_name
-                
-                # 准备Stream数据
-                prefixed_queue = self.ep.get_prefixed_queue_name(actual_queue)
-                stream_data = dumps_str(task)
-                
-                # 添加到Lua脚本参数
-                lua_args.extend([prefixed_queue, stream_data])
-            
-            # 注册并执行Lua脚本（使用类常量）
-            script_attr = '_bulk_normal_script_async' if asyncio_mode else '_bulk_normal_script_sync'
-            if not hasattr(self, script_attr):
-                setattr(self, script_attr, redis_client.register_script(self._LUA_SCRIPT_NORMAL_TASKS))
-            
-            script = getattr(self, script_attr)
-            if asyncio_mode:
-                # 异步执行需要await
-                stream_ids = await script(keys=[], args=lua_args)
-            else:
-                stream_ids = script(keys=[], args=lua_args)
-            
-            event_ids.extend(stream_ids)
-            
-        return event_ids
-
-    
-    async def _bulk_write_async(self, tasks: list):
-        """异步批量写入，直接调用统一的实现"""
-        return await self._bulk_write_impl(tasks, asyncio_mode=True)
 
     def get_task_info(self, event_id: str, asyncio: bool = False):
         """获取任务信息（从TASK:hash）"""
@@ -1001,7 +1284,7 @@ class Jettask(object):
     
     def get_result(self, event_id: str, delete: bool = False, asyncio: bool = False, 
                    delayed_deletion_ex: int = None, wait: bool = False, timeout: int = 300,
-                   poll_interval: float = 0.5, suppress_traceback: bool = False):
+                   poll_interval: float = 0.5):
         """获取任务结果（从TASK:hash的result字段）
         
         Args:
@@ -1040,12 +1323,33 @@ class Jettask(object):
                     client.expire(key, delayed_deletion_ex)
                     return result
                 elif delete:
-                    # 获取结果并删除整个hash
+                    # 如果配置了任务中心，不删除消息，等任务中心同步后删除
+                    if self.task_center and self.task_center.is_enabled:
+                        result = client.hget(key, "result")
+                        # 仅标记为待删除，不实际删除
+                        client.hset(key, "__pending_delete", "1")
+                        return result
+                    else:
+                        # 获取结果并删除整个hash
+                        result = client.hget(key, "result")
+                        client.delete(key)
+                        return result
+                else:
+                    # 先尝试从Redis获取
                     result = client.hget(key, "result")
-                    client.delete(key)
+                    # 如果Redis中没有且配置了任务中心，从任务中心获取
+                    if result is None and self.task_center_client.is_enabled:
+                        import asyncio
+                        loop = asyncio.new_event_loop()
+                        try:
+                            task_data = loop.run_until_complete(
+                                self.task_center_client.get_task_result(event_id)
+                            )
+                            if task_data:
+                                result = task_data.get('result')
+                        finally:
+                            loop.close()
                     return result
-                else:
-                    return client.hget(key, "result")
     
     def _get_result_sync_wait(self, event_id: str, delete: bool, delayed_deletion_ex: int, 
                               timeout: int, poll_interval: float):
@@ -1153,14 +1457,12 @@ class Jettask(object):
             
             # 创建调度器
             scheduler_config = self.scheduler_config.copy()
-            scheduler_config.setdefault('redis_prefix', f"{self.redis_prefix}:SCHEDULER")
             scheduler_config.setdefault('scan_interval', 0.1)
             scheduler_config.setdefault('batch_size', 100)
             scheduler_config.setdefault('leader_ttl', 10)
             
             self.scheduler = TaskScheduler(
                 app=self,
-                redis_url=self.redis_url,
                 db_manager=self.scheduler_manager,
                 **scheduler_config
             )
@@ -1272,12 +1574,21 @@ class Jettask(object):
         if not scheduler_id:
             raise ValueError("scheduler_id is required and must be provided")
         
+        # 获取当前命名空间
+        namespace = 'default'
+        if self.task_center and hasattr(self.task_center, 'namespace_name'):
+            namespace = self.task_center.namespace_name
+        elif self.redis_prefix and self.redis_prefix != 'jettask':
+            # 如果没有task_center，使用redis_prefix作为命名空间
+            namespace = self.redis_prefix
+        
         # 创建任务对象
         task = ScheduledTask(
             scheduler_id=scheduler_id,
             task_name=full_task_name,  # 使用完整的任务名称（包含模块前缀）
             task_type=TaskType(task_type),
             queue_name=queue_name,
+            namespace=namespace,  # 设置命名空间
             task_args=task_args or [],
             task_kwargs=task_kwargs or {},
             interval_seconds=interval_seconds,
@@ -1375,12 +1686,21 @@ class Jettask(object):
             if not scheduler_id:
                 raise ValueError(f"Task config for '{task_name}' missing required scheduler_id")
             
+            # 获取当前命名空间
+            namespace = 'default'
+            if self.task_center and hasattr(self.task_center, 'namespace_name'):
+                namespace = self.task_center.namespace_name
+            elif self.redis_prefix and self.redis_prefix != 'jettask':
+                # 如果没有task_center，使用redis_prefix作为命名空间
+                namespace = self.redis_prefix
+            
             # 创建任务对象
             task_obj = ScheduledTask(
                 scheduler_id=scheduler_id,
                 task_name=task_name,
                 task_type=TaskType(task_type),
                 queue_name=queue_name,
+                namespace=namespace,  # 设置命名空间
                 task_args=task_config.get('task_args', []),
                 task_kwargs=task_config.get('task_kwargs', {}),
                 interval_seconds=task_config.get('interval_seconds'),