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

jettask/core/message.py

@@ -0,0 +1,147 @@
+"""
+任务消息类 - 完全独立的任务发送对象
+与task定义完全解耦，可以在任何项目中使用
+"""
+from typing import Optional, Dict, Any, Tuple
+from dataclasses import dataclass, field, asdict
+import time
+
+
+@dataclass
+class TaskMessage:
+    """
+    任务消息对象
+    
+    这是一个完全独立的类，不依赖任何task定义。
+    可以在没有执行器代码的项目中单独使用。
+    
+    使用示例:
+        # 创建任务消息
+        msg = TaskMessage(
+            queue="order_processing",
+            args=(12345,),
+            kwargs={"customer_id": "C001", "amount": 99.99},
+            delay=5  # 延迟5秒执行
+        )
+        
+        # 批量创建
+        messages = [
+            TaskMessage(queue="email", kwargs={"to": "user1@example.com"}),
+            TaskMessage(queue="email", kwargs={"to": "user2@example.com"}),
+        ]
+        
+        # 发送
+        await app.send_tasks([msg])
+        await app.send_tasks(messages)
+    """
+    
+    # 必需参数
+    queue: str  # 队列名称（必需）
+    
+    # 任务参数
+    args: Tuple = field(default_factory=tuple)
+    kwargs: Dict[str, Any] = field(default_factory=dict)
+    
+    # 执行选项
+    delay: Optional[int] = None  # 延迟执行（秒）
+    priority: Optional[int] = None  # 优先级（1最高，数字越大优先级越低）
+    
+    # 调度相关
+    scheduled_task_id: Optional[int] = None  # 定时任务ID
+    
+    # 路由信息（用于复杂的路由场景）
+    routing: Optional[Dict[str, Any]] = None
+    
+    # 元数据
+    trigger_time: Optional[float] = None  # 触发时间
+    
+    def __post_init__(self):
+        """初始化后处理"""
+        # 自动设置触发时间
+        if self.trigger_time is None:
+            self.trigger_time = time.time()
+    
+    def to_dict(self) -> dict:
+        """
+        转换为字典格式（用于序列化发送到Redis）
+        
+        Returns:
+            dict: 消息字典，只包含非None的字段
+        """
+        data = {
+            'queue': self.queue,
+            'args': self.args,
+            'kwargs': self.kwargs,
+            'trigger_time': self.trigger_time
+        }
+        
+        # 添加可选字段（只添加非None的）
+        optional_fields = [
+            'delay', 'priority', 'scheduled_task_id', 'routing'
+        ]
+        
+        for field_name in optional_fields:
+            value = getattr(self, field_name)
+            if value is not None:
+                # 对于空列表/字典，也不添加
+                if isinstance(value, (list, dict)) and not value:
+                    continue
+                data[field_name] = value
+        
+        return data
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> 'TaskMessage':
+        """
+        从字典创建TaskMessage实例
+        
+        Args:
+            data: 消息字典
+            
+        Returns:
+            TaskMessage: 任务消息实例
+        """
+        # 提取构造函数需要的参数
+        init_fields = {
+            'queue', 'args', 'kwargs', 
+            'delay', 'priority', 'scheduled_task_id', 'routing', 'trigger_time'
+        }
+        
+        init_data = {k: v for k, v in data.items() if k in init_fields}
+        return cls(**init_data)
+    
+    def validate(self) -> bool:
+        """
+        验证消息是否有效
+        
+        Returns:
+            bool: 是否有效
+            
+        Raises:
+            ValueError: 如果消息无效
+        """
+        if not self.queue:
+            raise ValueError("Queue name is required")
+        
+        if self.delay and self.delay < 0:
+            raise ValueError(f"Delay must be non-negative, got {self.delay}")
+        
+        if self.priority is not None and self.priority < 1:
+            raise ValueError(f"Priority must be positive (1 is highest), got {self.priority}")
+        
+        return True
+    
+    def __repr__(self) -> str:
+        """友好的字符串表示"""
+        parts = [f"TaskMessage(queue='{self.queue}'"]
+        
+        if self.args:
+            parts.append(f"args={self.args}")
+        
+        if self.kwargs:
+            parts.append(f"kwargs={self.kwargs}")
+        
+        if self.delay:
+            parts.append(f"delay={self.delay}s")
+        
+        return ", ".join(parts) + ")"

jettask/core/offline_worker_recovery.py

@@ -33,34 +33,44 @@ class OfflineWorkerRecovery:
         恢复指定队列的离线worker的pending消息
         """
         total_recovered = 0
-        
+        logger.debug(f'恢复指定队列的离线worker的pending消息')
         try:
             # 获取当前consumer名称
             if not current_consumer_name and self.consumer_manager:
-                current_consumer_name = self.consumer_manager.get_consumer_name(queue)
+                # 对于优先级队列，使用基础队列名来获取consumer
+                base_queue = queue
+                if ':' in queue and queue.rsplit(':', 1)[-1].isdigit():
+                    base_queue = queue.rsplit(':', 1)[0]
+                
+                current_consumer_name = self.consumer_manager.get_consumer_name(base_queue)
+                
+                # 对于优先级队列，consumer名称需要添加队列后缀
+                if current_consumer_name and base_queue != queue:
+                    priority_suffix = queue.rsplit(':', 1)[-1]
+                    current_consumer_name = f"{current_consumer_name}:{priority_suffix}"
             
             if not current_consumer_name:
                 logger.error(f"Cannot get current consumer name for queue {queue}")
                 return 0
                 
-            # logger.info(f"Starting recovery for queue {queue} with consumer {current_consumer_name}")
+            logger.debug(f"Starting recovery for queue {queue} with consumer {current_consumer_name}")
             
             # 获取所有离线worker
             offline_workers = await self._find_offline_workers(queue)
-            # logger.info(f'{offline_workers=}')
             if not offline_workers:
                 logger.debug(f"No offline workers found for queue {queue}")
                 return 0
                 
-            logger.info(f"Found {len(offline_workers)} offline workers for queue {queue}")
+            logger.debug(f"Found {len(offline_workers)} offline workers for queue {queue}")
             
             # 处理每个离线worker
             for worker_key, worker_data in offline_workers:
                 if self._stop_recovery:
-                    logger.info("Stopping recovery due to shutdown signal")
+                    logger.debug("Stopping recovery due to shutdown signal")
                     break
                 
-                # logger.info(f"Processing offline worker: {worker_key}")
+                # logger.debug(f'恢复指定队列的离线worker的pending消息 {offline_workers=}')
+                # logger.info(f"Processing offline worker: {worker_key} {worker_data=} {queue=}")
                 recovered = await self._recover_worker_messages(
                     queue=queue,
                     worker_key=worker_key,
@@ -113,20 +123,29 @@ class OfflineWorkerRecovery:
                             value = v.decode('utf-8') if isinstance(v, bytes) else v
                             decoded_worker_data[key] = value
                         
-                        # logger.info(f'{worker_key=} {decoded_worker_data=}')
-                        # logger.info(f'{decoded_worker_data=}')
+                        # logger.debug(f'{worker_key=} {decoded_worker_data=}')
+                        # logger.debug(f'{decoded_worker_data=}')
                         # 检查worker是否离线且消息未转移
                         is_alive = decoded_worker_data.get('is_alive', 'false').lower() == 'true'
                         messages_transferred = decoded_worker_data.get('messages_transferred', 'false').lower() == 'true'
-                        # logger.info(f'{worker_key=} {is_alive=} {messages_transferred=} {not is_alive and not messages_transferred}')
+                        # logger.debug(f'{worker_key=} {is_alive=} {messages_transferred=} {not is_alive and not messages_transferred}')
                         # 找到离线且消息未转移的worker
                         if not is_alive and not messages_transferred:
                             queues_str = decoded_worker_data.get('queues', '')
                             worker_queues = queues_str.split(',') if queues_str else []
                             
-                            # logger.info(f'{worker_queues=} {queue=}')
+                            # logger.debug(f'{worker_queues=} {queue=}')
                             # 检查这个worker是否负责当前队列
-                            if queue in worker_queues:
+                            # 支持优先级队列：如果queue是"base:priority"格式，检查worker是否负责base队列
+                            queue_matched = False
+                            if ':' in queue and queue.rsplit(':', 1)[-1].isdigit():
+                                # 这是优先级队列，提取基础队列名
+                                base_queue = queue.rsplit(':', 1)[0]
+                                queue_matched = base_queue in worker_queues
+                            else:
+                                # 普通队列
+                                queue_matched = queue in worker_queues
+                            if queue_matched:
                                 offline_workers.append((worker_key, decoded_worker_data))
                                 
                     except Exception as e:
@@ -153,10 +172,7 @@ class OfflineWorkerRecovery:
         """
         恢复单个worker的pending消息
         
-        简化逻辑：
-        1. 使用离线worker的consumer_id构建consumer名称：{consumer_id}-{queue}
-        2. 默认group名称就是{prefixed_queue}
-        3. 直接获取并转移该consumer的pending消息
+        从worker_data中获取所有的group_info字段，恢复对应的pending消息
         """
         total_claimed = 0
         
@@ -164,110 +180,123 @@ class OfflineWorkerRecovery:
             # worker_data 现在已经是解码后的字典
             consumer_id = worker_data.get('consumer_id')
             
-            # 构建离线worker的consumer名称
-            offline_consumer = f"{consumer_id}-{queue}"
-            
-            logger.info(f"Recovering messages from offline worker: {offline_consumer}")
+            # 从worker_data中提取group_info字段
+            group_infos = []
+            import json
+            for key, value in worker_data.items():
+                if key.startswith('group_info:'):
+                    try:
+                        group_info = json.loads(value)
+                        # 只处理属于当前队列的group
+                        if group_info.get('queue') == queue:
+                            group_infos.append(group_info)
+                            logger.info(f"Found group info for queue {queue}: {group_info}")
+                    except Exception as e:
+                        logger.error(f"Error parsing group_info: {e}")
             
-            # 检查是否是同一个worker（避免自己接管自己的消息）
-            if current_consumer_name == offline_consumer or current_consumer_name.startswith(f"{offline_consumer}:"):
-                logger.info(f"Skipping {offline_consumer} - same worker")
+            if not group_infos:
+                logger.debug(f"No group_info found for queue {queue} in worker {worker_key}")
+                # 即使没有group_info，也要标记为已处理，避免重复扫描
+                await self.async_redis_client.hset(worker_key, 'messages_transferred', 'true')
                 return 0
-                
-            # 使用分布式锁防止并发处理
-            lock_key = f"{self.redis_prefix}:CLAIM:LOCK:{offline_consumer}"
-            lock = AsyncLock(
-                self.async_redis_client,
-                lock_key,
-                timeout=60,
-                blocking=False  # 不阻塞，直接跳过
-            )
             
-            if not await lock.acquire():
-                logger.info(f"Another process is claiming messages for {offline_consumer}")
-                return 0
-                
-            try:
-                # 获取Stream的key
-                prefixed_queue = self.queue_formatter(queue)
-                logger.debug(f"Stream key: {prefixed_queue}, type: {type(prefixed_queue)}")
-                
-                # 获取所有的consumer groups
-                all_groups = await self._get_consumer_groups(prefixed_queue)
-                logger.info(f"Found {len(all_groups)} groups for stream {prefixed_queue}")
-                
-                for group_name in all_groups:
-                    # 获取该group的所有consumers
+            # 在处理任何group之前，先标记该worker的消息已开始转移
+            # 避免其他进程重复处理
+            await self.async_redis_client.hset(worker_key, 'messages_transferred', 'true')
+            logger.info(f"Marked worker {worker_key} as messages_transferred=true")
+            
+            # 处理每个group_info
+            for group_info in group_infos:
+                    stream_key = group_info.get('stream_key')
+                    group_name = group_info.get('group_name')
+                    offline_consumer_name = group_info.get('consumer_name')
+                    task_name = group_info.get('task_name')
+                    
+                    if not all([stream_key, group_name, offline_consumer_name]):
+                        logger.warning(f"Incomplete group_info: {group_info}")
+                        continue
+                    
+                    logger.info(f"Recovering task {task_name}: stream={stream_key}, group={group_name}, consumer={offline_consumer_name}")
+                    
+                    # 跳过自己的consumer
+                    if current_consumer_name == offline_consumer_name:
+                        logger.debug(f"Skipping own consumer: {offline_consumer_name}")
+                        continue
+                    
+                    # 使用分布式锁
+                    lock_key = f"{self.redis_prefix}:CLAIM:LOCK:{offline_consumer_name}:{group_name}"
+                    lock = AsyncLock(
+                        self.async_redis_client,
+                        lock_key,
+                        timeout=30,
+                        blocking=False
+                    )
+                    
+                    if not await lock.acquire():
+                        logger.debug(f"Lock busy for {offline_consumer_name}:{group_name}")
+                        continue
+                    
                     try:
-                        consumers_info = await self.async_redis_client.xinfo_consumers(prefixed_queue, group_name)
-                        logger.debug(f"Consumers in group {group_name}: {consumers_info}")
+                        # 获取pending消息数量
+                        pending_info = await self.async_redis_client.xpending(
+                            stream_key, group_name
+                        )
                         
-                        for consumer_info in consumers_info:
-                            # 二进制Redis客户端返回的字典键是字符串，值是bytes
-                            consumer_name = consumer_info.get('name', b'')
-                            if isinstance(consumer_name, bytes):
-                                consumer_name = consumer_name.decode('utf-8')
+                        if pending_info and pending_info.get('pending', 0) > 0:
+                            # 获取具体的pending消息信息
+                            detailed_pending = await self.async_redis_client.xpending_range(
+                                stream_key, group_name,
+                                min='-', max='+', count=100,
+                                consumername=offline_consumer_name
+                            )
                             
-                            pending_count = consumer_info.get('pending', 0)
-                            logger.info(f'{offline_consumer=} {consumer_name=}')
-                            # 检查是否是离线worker的consumer
-                            # 离线consumer名称格式：{consumer_id}-{queue} 或 {consumer_id}-{queue}:{task_name}
-                            if consumer_name.startswith(f"{offline_consumer}"):
-                                logger.info(f'{consumer_info=}')
-                                if pending_count > 0:
-                                    logger.info(f"Found {pending_count} pending messages for {consumer_name} in group {group_name}")
-                                    
-                                    # 确定新的consumer名称
-                                    # 如果原consumer有task后缀，新consumer也要有相同的task后缀
-                                    if ':' in consumer_name and ':' in group_name:
-                                        # 提取task后缀
-                                        task_suffix = consumer_name.split(':', 1)[1]
-                                        # 新consumer也要有相同的task后缀
-                                        if ':' in current_consumer_name:
-                                            # 如果当前consumer已经有后缀，保持它
-                                            new_consumer = current_consumer_name
-                                        else:
-                                            # 添加task后缀
-                                            new_consumer = f"{current_consumer_name}:{task_suffix}"
-                                    else:
-                                        new_consumer = current_consumer_name
-                                    
-                                    logger.info(f"Claiming messages from {consumer_name} to {new_consumer}")
-                                    
-                                    # 转移pending消息
-                                    claimed = await self._claim_messages(
-                                        prefixed_queue, group_name,
-                                        consumer_name, new_consumer
-                                    )
+                            if detailed_pending:
+                                logger.info(f"Found {len(detailed_pending)} pending messages for {task_name}")
+                                
+                                # 批量认领消息
+                                message_ids = [msg['message_id'] for msg in detailed_pending]
+                                claimed_messages = await self.async_redis_client.xclaim(
+                                    stream_key, group_name,
+                                    current_consumer_name,
+                                    min_idle_time=0,
+                                    message_ids=message_ids
+                                )
+                                
+                                if claimed_messages:
+                                    logger.info(f"Claimed {len(claimed_messages)} messages for task {task_name}")
+                                    total_claimed += len(claimed_messages)
                                     
-                                    if claimed:
-                                        total_claimed += len(claimed)
-                                        logger.info(f"Successfully claimed {len(claimed)} messages")
-                                        
-                                        # 处理转移的消息
-                                        if process_message_callback:
-                                            for msg_id, msg_data in claimed:
-                                                await process_message_callback(msg_id, msg_data, queue, consumer_id)
-                                        elif event_queue:
-                                            for msg_id, msg_data in claimed:
-                                                await self._put_to_event_queue(
-                                                    msg_id, msg_data, queue,
-                                                    event_queue, new_consumer,
-                                                    group_name, consumer_name
-                                                )
-                    except Exception as e:
-                        logger.error(f"Error processing group {group_name}: {e}")
-                
-                # 标记该worker的消息已转移（即使没有消息也要标记，避免重复处理）
-                await self.async_redis_client.hset(worker_key, 'messages_transferred', 'true')
-                if total_claimed > 0:
-                    logger.info(f"Transferred total {total_claimed} messages from worker {consumer_id}")
-                else:
-                    logger.info(f"No messages to transfer from worker {consumer_id}, marked as processed")
-                    
-            finally:
-                await lock.release()
-                
+                                    # 如果提供了event_queue，将消息放入队列
+                                    if event_queue:
+                                        for msg_id, msg_data in claimed_messages:
+                                            if isinstance(msg_id, bytes):
+                                                msg_id = msg_id.decode('utf-8')
+                                            
+                                            # 解析消息数据
+                                            data_field = msg_data.get(b'data') or msg_data.get('data')
+                                            if data_field:
+                                                try:
+                                                    import msgpack
+                                                    parsed_data = msgpack.unpackb(data_field, raw=False)
+                                                    # 添加必要的元数据
+                                                    parsed_data['_task_name'] = task_name
+                                                    parsed_data['queue'] = queue
+                                                    
+                                                    # 构建任务项
+                                                    task_item = {
+                                                        'queue': queue,
+                                                        'event_id': msg_id,
+                                                        'event_data': parsed_data,
+                                                        'consumer': current_consumer_name,
+                                                        'group_name': group_name
+                                                    }
+                                                    
+                                                    await event_queue.put(task_item)
+                                                except Exception as e:
+                                                    logger.error(f"Error processing claimed message: {e}")
+                    finally:
+                        await lock.release()
+            
         except Exception as e:
             logger.error(f"Error recovering messages: {e}")
             
@@ -346,7 +375,7 @@ class OfflineWorkerRecovery:
                 
                 if message_ids:
                     # 使用XCLAIM转移消息
-                    logger.info(f"Claiming {len(message_ids)} messages from {old_consumer} to {new_consumer}")
+                    logger.debug(f"Claiming {len(message_ids)} messages from {old_consumer} to {new_consumer}")
                     
                     claimed = await self.async_redis_client.xclaim(
                         stream_key, group_name,
@@ -388,6 +417,44 @@ class OfflineWorkerRecovery:
             else:
                 event_data = msg_data
             
+            # 从 group_name 中提取 task_name
+            # group_name 的格式是: "jettask:QUEUE:{queue}:{task_name}"
+            task_name = None
+            if group_name and ':' in group_name:
+                parts = group_name.split(':')
+                # 查找最后一个非数字部分作为task_name
+                for i in range(len(parts) - 1, -1, -1):
+                    part = parts[i]
+                    # 跳过优先级数字
+                    if not part.isdigit() and part not in ['jettask', 'QUEUE', queue]:
+                        task_name = part
+                        logger.debug(f"Extracted task_name '{task_name}' from group_name '{group_name}'")
+                        break
+            
+            # 如果从group_name提取失败，尝试从consumer名称提取
+            if not task_name and ':' in consumer and ':' in group_name:
+                # consumer格式可能是: "{consumer_id}:{task_name}" 
+                consumer_parts = consumer.split(':')
+                if len(consumer_parts) > 1:
+                    potential_task = consumer_parts[-1]
+                    # 确保不是优先级数字
+                    if not potential_task.isdigit():
+                        task_name = potential_task
+                        logger.debug(f"Extracted task_name '{task_name}' from consumer '{consumer}'")
+            
+            # 如果还是没有task_name，检查event_data中是否已有
+            if not task_name and '_task_name' in event_data:
+                task_name = event_data['_task_name']
+                logger.debug(f"Using existing _task_name from event_data: '{task_name}'")
+            
+            # 确保event_data中有_task_name字段
+            if task_name:
+                event_data['_task_name'] = task_name
+                logger.debug(f"Added _task_name '{task_name}' to recovered message")
+            else:
+                # 如果无法确定task_name，记录警告
+                logger.warning(f"Could not determine task_name for recovered message. group_name='{group_name}', consumer='{consumer}'")
+            
             # 构建事件
             event = {
                 'event_id': msg_id.decode() if isinstance(msg_id, bytes) else msg_id,