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

jettask/core/heartbeat_process.py

@@ -1,222 +0,0 @@
-"""
-独立的心跳上报进程，避免被CPU密集型任务阻塞
-"""
-import multiprocessing
-import time
-import os
-import logging
-import signal
-import redis
-from typing import Dict, Set, Optional
-
-logger = logging.getLogger(__name__)
-
-
-class HeartbeatProcess:
-    """独立的心跳上报进程"""
-    
-    def __init__(self, redis_url: str, worker_key: str, consumer_id: str, 
-                 heartbeat_interval: float = 5.0, heartbeat_timeout: float = 15.0):
-        self.redis_url = redis_url
-        self.worker_key = worker_key
-        self.consumer_id = consumer_id
-        self.heartbeat_interval = heartbeat_interval
-        self.heartbeat_timeout = heartbeat_timeout
-        self.process: Optional[multiprocessing.Process] = None
-        self.stop_event = multiprocessing.Event()
-        # 使用共享内存记录最后心跳时间
-        self.last_heartbeat_time = multiprocessing.Value('d', time.time())
-        
-    def start(self):
-        """启动心跳进程"""
-        if self.process and self.process.is_alive():
-            logger.warning("Heartbeat process already running")
-            return
-            
-        self.stop_event.clear()
-        self.process = multiprocessing.Process(
-            target=self._heartbeat_loop,
-            args=(self.redis_url, self.worker_key, self.consumer_id, 
-                  self.heartbeat_interval, self.heartbeat_timeout, self.stop_event,
-                  self.last_heartbeat_time),
-            daemon=True,
-            name=f"heartbeat-{self.consumer_id}"
-        )
-        self.process.start()
-        logger.debug(f"Started heartbeat process for {self.consumer_id}, PID: {self.process.pid}")
-        
-    def stop(self):
-        """停止心跳进程"""
-        if not self.process:
-            return
-            
-        try:
-            # 检查process是否有必要的属性
-            if hasattr(self.process, 'is_alive') and callable(self.process.is_alive):
-                if self.process.is_alive():
-                    self.stop_event.set()
-                    if hasattr(self.process, 'terminate'):
-                        self.process.terminate()
-                        self.process.join(timeout=5)
-                        if self.process.is_alive():
-                            logger.warning("Heartbeat process did not stop gracefully, forcing kill")
-                            if hasattr(self.process, 'kill'):
-                                self.process.kill()
-                                self.process.join()
-                    logger.debug(f"Stopped heartbeat process for {self.consumer_id}")
-            else:
-                logger.debug(f"Heartbeat process for {self.consumer_id} is not a valid process object")
-        except AttributeError as e:
-            logger.debug(f"Heartbeat process attributes error: {e}")
-        except Exception as e:
-            logger.warning(f"Error stopping heartbeat process: {e}")
-        finally:
-            self.process = None
-    
-    def get_last_heartbeat_time(self) -> float:
-        """获取最后一次心跳时间"""
-        with self.last_heartbeat_time.get_lock():
-            return self.last_heartbeat_time.value
-            
-    @staticmethod
-    def _heartbeat_loop(redis_url: str, worker_key: str, consumer_id: str,
-                        heartbeat_interval: float, heartbeat_timeout: float, 
-                        stop_event: multiprocessing.Event,
-                        last_heartbeat_time: multiprocessing.Value):
-        """心跳循环 - 在独立进程中运行"""
-        # 忽略中断信号，让主进程处理
-        signal.signal(signal.SIGINT, signal.SIG_IGN)
-        
-        # 创建独立的Redis连接
-        redis_client = redis.from_url(redis_url, decode_responses=True)
-        
-        # 获取主机信息
-        import socket
-        try:
-            hostname = socket.gethostname()
-            if not hostname or hostname == 'localhost':
-                hostname = socket.gethostbyname(socket.gethostname())
-        except:
-            hostname = os.environ.get('HOSTNAME', 'unknown')
-            
-        logger.debug(f"Heartbeat process started for {consumer_id} in PID {os.getpid()}")
-        
-        heartbeat_count = 0
-        last_log_time = time.time()
-        
-        while not stop_event.is_set():
-            try:
-                current_time = time.time()
-                
-                # 更新心跳信息
-                redis_client.hset(worker_key, mapping={
-                    'last_heartbeat': str(current_time),
-                    'heartbeat_pid': str(os.getpid()),  # 记录心跳进程PID
-                    'is_alive': 'true'
-                })
-                
-                # 同时更新 sorted set
-                redis_prefix = worker_key.split(':')[0]  # 获取前缀（如 'jettask'）
-                worker_id = worker_key.split(':')[-1]  # 获取 worker ID
-                redis_client.zadd(f"{redis_prefix}:ACTIVE_WORKERS", {worker_id: current_time})
-                
-                # 更新本地心跳时间记录
-                with last_heartbeat_time.get_lock():
-                    last_heartbeat_time.value = current_time
-                
-                heartbeat_count += 1
-                
-                # 每30秒记录一次日志
-                if current_time - last_log_time >= 30:
-                    logger.debug(f"Heartbeat process for {consumer_id} sent {heartbeat_count} heartbeats")
-                    last_log_time = current_time
-                    heartbeat_count = 0
-                
-                # 等待下一次心跳
-                stop_event.wait(heartbeat_interval)
-                
-            except Exception as e:
-                logger.error(f"Error in heartbeat process for {consumer_id}: {e}")
-                time.sleep(1)  # 出错时短暂等待
-                
-        logger.debug(f"Heartbeat process for {consumer_id} exiting")
-
-
-class HeartbeatProcessManager:
-    """管理worker的心跳进程（只需要一个进程）"""
-    
-    def __init__(self, redis_url: str, consumer_id: str, heartbeat_interval: float = 5.0,
-                 heartbeat_timeout: float = 15.0):
-        self.redis_url = redis_url
-        self.consumer_id = consumer_id
-        self.heartbeat_interval = heartbeat_interval
-        self.heartbeat_timeout = heartbeat_timeout
-        self.heartbeat_process: Optional[HeartbeatProcess] = None
-        self.worker_key: Optional[str] = None
-        self.queues: Set[str] = set()  # 记录worker处理的队列
-        self.redis_client = redis.from_url(redis_url, decode_responses=True)
-        
-    def add_queue(self, queue: str, worker_key: str):
-        """添加队列（只在第一次时启动心跳进程）"""
-        self.queues.add(queue)
-        
-        # 只需要启动一次心跳进程
-        if self.heartbeat_process is not None:
-            logger.debug(f"Heartbeat process already running, added queue {queue}")
-            return
-            
-        # 第一次调用时启动心跳进程
-        self.worker_key = worker_key
-        self.heartbeat_process = HeartbeatProcess(
-            redis_url=self.redis_url,
-            worker_key=worker_key,
-            consumer_id=self.consumer_id,
-            heartbeat_interval=self.heartbeat_interval,
-            heartbeat_timeout=self.heartbeat_timeout
-        )
-        self.heartbeat_process.start()
-        logger.debug(f"Started single heartbeat process for worker {self.consumer_id}")
-        
-    def remove_queue(self, queue: str):
-        """移除队列"""
-        if queue in self.queues:
-            self.queues.remove(queue)
-            logger.debug(f"Removed queue {queue} from heartbeat monitoring")
-            
-            # 如果没有队列了，停止心跳进程
-            if not self.queues and self.heartbeat_process:
-                self.heartbeat_process.stop()
-                self.heartbeat_process = None
-                logger.debug("No more queues, stopped heartbeat process")
-            
-    def stop_all(self):
-        """停止心跳进程"""
-        if self.heartbeat_process:
-            self.heartbeat_process.stop()
-            self.heartbeat_process = None
-        self.queues.clear()
-        
-    def is_healthy(self) -> bool:
-        """检查心跳进程是否健康"""
-        if not self.heartbeat_process:
-            return len(self.queues) == 0  # 如果没有队列，则是健康的
-            
-        if not self.heartbeat_process.process or not self.heartbeat_process.process.is_alive():
-            logger.error(f"Heartbeat process for worker {self.consumer_id} is not alive")
-            return False
-        return True
-    
-    def get_last_heartbeat_time(self) -> Optional[float]:
-        """获取最后一次心跳时间"""
-        if self.heartbeat_process:
-            return self.heartbeat_process.get_last_heartbeat_time()
-        return None
-    
-    def is_heartbeat_timeout(self) -> bool:
-        """检查心跳是否已超时"""
-        last_heartbeat = self.get_last_heartbeat_time()
-        if last_heartbeat is None:
-            return False  # 心跳进程未启动
-        
-        current_time = time.time()
-        return (current_time - last_heartbeat) > self.heartbeat_timeout

jettask/core/task_batch.py

@@ -1,153 +0,0 @@
-"""
-任务批量发送构建器
-提供类型安全的批量任务发送接口
-"""
-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/worker_scanner.py

@@ -1,271 +0,0 @@
-"""
-Worker 扫描器 - 高效检测超时 Worker
-使用 Redis Sorted Set 实现 O(log N) 复杂度
-"""
-
-import time
-import logging
-import asyncio
-from typing import Dict, List, Optional
-
-logger = logging.getLogger('app')
-
-
-class WorkerScanner:
-    """
-    使用 Redis Sorted Set 优化的 Worker 扫描器
-    
-    核心优化：
-    1. O(log N) 的超时检测复杂度
-    2. 自动一致性维护
-    3. 原子性操作保证数据一致
-    """
-    
-    def __init__(self, sync_redis, async_redis, redis_prefix: str = 'jettask',
-                 heartbeat_timeout: float = 3.0):
-        self.redis = sync_redis
-        self.async_redis = async_redis
-        self.redis_prefix = redis_prefix
-        self.heartbeat_timeout = heartbeat_timeout
-        self.active_workers_key = f"{redis_prefix}:ACTIVE_WORKERS"
-        
-        # 一致性维护
-        self._initialized = False
-        self._last_full_sync = 0
-        self._full_sync_interval = 60  # 每60秒完整同步
-        self._scan_counter = 0
-        self._partial_check_interval = 10  # 每10次扫描做部分检查
-        
-    # async def ensure_initialized(self):
-    #     """确保 Sorted Set 已初始化并保持一致"""
-    #     current_time = time.time()
-        
-    #     # 首次初始化或定期完整同步
-    #     if not self._initialized or (current_time - self._last_full_sync > self._full_sync_interval):
-    #         await self._full_sync()
-    #         self._initialized = True
-    #         self._last_full_sync = current_time
-            
-    # async def _full_sync(self):
-    #     """完整同步 Hash 和 Sorted Set"""
-    #     try:
-    #         logger.debug("Starting full synchronization of ACTIVE_WORKERS")
-            
-    #         # 1. 收集所有活跃 worker 的 Hash 数据
-    #         pattern = f"{self.redis_prefix}:WORKER:*"
-    #         hash_workers = {}
-            
-    #         async for key in self.async_redis.scan_iter(match=pattern, count=100):
-    #             if ':HISTORY:' not in key and ':REUSE:' not in key:
-    #                 worker_id = key.split(':')[-1]
-    #                 worker_data = await self.async_redis.hgetall(key)
-                    
-    #                 if worker_data and worker_data.get('is_alive', 'true').lower() == 'true':
-    #                     try:
-    #                         heartbeat = float(worker_data.get('last_heartbeat', 0))
-    #                         hash_workers[worker_id] = heartbeat
-    #                     except (ValueError, TypeError):
-    #                         continue
-            
-    #         # 2. 获取 Sorted Set 中的数据
-    #         zset_workers = await self.async_redis.zrange(
-    #             self.active_workers_key, 0, -1, withscores=True
-    #         )
-    #         zset_dict = {worker_id: score for worker_id, score in zset_workers}
-            
-    #         # 3. 计算差异
-    #         hash_ids = set(hash_workers.keys())
-    #         zset_ids = set(zset_dict.keys())
-            
-    #         to_add = hash_ids - zset_ids  # Hash有但ZSet无
-    #         to_remove = zset_ids - hash_ids  # ZSet有但Hash无
-    #         to_update = {}  # 时间戳不一致的
-            
-    #         for worker_id in hash_ids & zset_ids:
-    #             if abs(hash_workers[worker_id] - zset_dict[worker_id]) > 0.1:
-    #                 to_update[worker_id] = hash_workers[worker_id]
-            
-    #         # 4. 批量修复
-    #         if to_add or to_remove or to_update:
-    #             pipeline = self.async_redis.pipeline()
-                
-    #             if to_add:
-    #                 members = {worker_id: hash_workers[worker_id] for worker_id in to_add}
-    #                 pipeline.zadd(self.active_workers_key, members)
-                    
-    #             if to_remove:
-    #                 pipeline.zrem(self.active_workers_key, *to_remove)
-                    
-    #             if to_update:
-    #                 pipeline.zadd(self.active_workers_key, to_update)
-                    
-    #             await pipeline.execute()
-    #             logger.info(f"Full sync: +{len(to_add)}, -{len(to_remove)}, ~{len(to_update)}")
-                
-    #     except Exception as e:
-    #         logger.error(f"Full sync failed: {e}")
-    
-    async def scan_timeout_workers(self) -> List[Dict]:
-        """
-        快速扫描超时的 worker - O(log N) 复杂度
-        注意：需要考虑每个worker自己的heartbeat_timeout
-        """
-        # await self.ensure_initialized()
-        
-        # 定期部分检查
-        self._scan_counter += 1
-        if self._scan_counter >= self._partial_check_interval:
-            self._scan_counter = 0
-            asyncio.create_task(self._partial_check())
-        
-        current_time = time.time()
-        # 使用最大可能的超时时间作为初始筛选（避免遗漏）
-        # 实际超时判断会在后面使用每个worker自己的timeout
-        max_possible_timeout = 300  # 5分钟，足够覆盖大多数情况
-        cutoff_time = current_time - max_possible_timeout
-        
-        # O(log N) 获取可能超时的 workers（宽松筛选）
-        potential_timeout_worker_ids = await self.async_redis.zrangebyscore(
-            self.active_workers_key, 
-            min=0, 
-            max=current_time - 1  # 至少1秒没更新的
-        )
-        
-        if not potential_timeout_worker_ids:
-            return []
-        
-        # 批量获取 worker 详细信息
-        pipeline = self.async_redis.pipeline()
-        for worker_id in potential_timeout_worker_ids:
-            worker_key = f"{self.redis_prefix}:WORKER:{worker_id}"
-            pipeline.hgetall(worker_key)
-        
-        workers_data = await pipeline.execute()
-        
-        # 验证并构造结果
-        result = []
-        cleanup_pipeline = self.async_redis.pipeline()
-        need_cleanup = False
-        
-        for worker_id, worker_data in zip(potential_timeout_worker_ids, workers_data):
-            if not worker_data:
-                # Hash 不存在，清理 ZSet
-                cleanup_pipeline.zrem(self.active_workers_key, worker_id)
-                need_cleanup = True
-                continue
-            
-            # 获取该worker自己的heartbeat_timeout
-            worker_heartbeat_timeout = float(worker_data.get('heartbeat_timeout', self.heartbeat_timeout))
-            
-            # 双重检查实际心跳时间（使用worker自己的timeout）
-            last_heartbeat = float(worker_data.get('last_heartbeat', 0))
-            worker_cutoff_time = current_time - worker_heartbeat_timeout
-            
-            if last_heartbeat >= worker_cutoff_time:
-                # 未超时，更新 ZSet 并跳过
-                cleanup_pipeline.zadd(self.active_workers_key, {worker_id: last_heartbeat})
-                need_cleanup = True
-                continue
-            
-            # 检查存活状态
-            is_alive = worker_data.get('is_alive', 'true').lower() == 'true'
-            if not is_alive:
-                # 已离线，清理 ZSet
-                cleanup_pipeline.zrem(self.active_workers_key, worker_id)
-                need_cleanup = True
-                continue
-            
-            # 确认超时（使用worker自己的timeout判断）
-            logger.debug(f"Worker {worker_id} timeout: last_heartbeat={last_heartbeat}, "
-                        f"timeout={worker_heartbeat_timeout}s, cutoff={worker_cutoff_time}")
-            worker_key = f"{self.redis_prefix}:WORKER:{worker_id}"
-            result.append({
-                'worker_key': worker_key,
-                'worker_data': worker_data,
-                'worker_id': worker_id
-            })
-        
-        if need_cleanup:
-            await cleanup_pipeline.execute()
-        
-        if result:
-            logger.info(f"Found {len(result)} timeout workers")
-        
-        return result
-    
-    async def update_heartbeat(self, worker_id: str, heartbeat_time: Optional[float] = None):
-        """原子性更新心跳（同时更新 Hash 和 ZSet）"""
-        if heartbeat_time is None:
-            heartbeat_time = time.time()
-            
-        pipeline = self.async_redis.pipeline()
-        worker_key = f"{self.redis_prefix}:WORKER:{worker_id}"
-        
-        # 同时更新两个数据结构
-        pipeline.hset(worker_key, 'last_heartbeat', str(heartbeat_time))
-        pipeline.zadd(self.active_workers_key, {worker_id: heartbeat_time})
-        
-        await pipeline.execute()
-    
-    async def add_worker(self, worker_id: str, worker_data: Dict):
-        """添加新 worker（同时加入 Hash 和 ZSet）"""
-        heartbeat_time = float(worker_data.get('last_heartbeat', time.time()))
-        
-        pipeline = self.async_redis.pipeline()
-        worker_key = f"{self.redis_prefix}:WORKER:{worker_id}"
-        
-        # 创建 Hash
-        pipeline.hset(worker_key, mapping=worker_data)
-        # 加入 ZSet
-        pipeline.zadd(self.active_workers_key, {worker_id: heartbeat_time})
-        
-        await pipeline.execute()
-        logger.debug(f"Added worker {worker_id} to system")
-    
-    async def remove_worker(self, worker_id: str):
-        """移除 worker（同时更新 Hash 和 ZSet）"""
-        pipeline = self.async_redis.pipeline()
-        worker_key = f"{self.redis_prefix}:WORKER:{worker_id}"
-        
-        # 标记 Hash 为离线
-        pipeline.hset(worker_key, 'is_alive', 'false')
-        # 从 ZSet 移除
-        pipeline.zrem(self.active_workers_key, worker_id)
-        
-        await pipeline.execute()
-        logger.debug(f"Removed worker {worker_id} from active set")
-    
-    async def _partial_check(self):
-        """部分一致性检查"""
-        try:
-            # 随机检查10个 worker
-            sample_size = min(10, await self.async_redis.zcard(self.active_workers_key))
-            if sample_size == 0:
-                return
-            
-            # 随机抽样
-            random_workers = await self.async_redis.zrandmember(
-                self.active_workers_key, sample_size, withscores=True
-            )
-            
-            for worker_id, zset_score in random_workers:
-                worker_key = f"{self.redis_prefix}:WORKER:{worker_id}"
-                hash_heartbeat = await self.async_redis.hget(worker_key, 'last_heartbeat')
-                
-                if not hash_heartbeat:
-                    # Hash 不存在，删除 ZSet 条目
-                    await self.async_redis.zrem(self.active_workers_key, worker_id)
-                    logger.debug(f"Partial check: removed {worker_id}")
-                else:
-                    # 检查时间戳一致性
-                    hash_time = float(hash_heartbeat)
-                    if abs(hash_time - zset_score) > 1.0:
-                        await self.async_redis.zadd(self.active_workers_key, {worker_id: hash_time})
-                        logger.debug(f"Partial check: synced {worker_id}")
-                        
-        except Exception as e:
-            logger.debug(f"Partial check error: {e}")
-    
-    async def get_active_count(self) -> int:
-        """获取活跃 worker 数量 - O(1)"""
-        return await self.async_redis.zcard(self.active_workers_key)

jettask/executors/__init__.py

@@ -1,5 +0,0 @@
-from .base import BaseExecutor
-from .asyncio import AsyncioExecutor
-from .multi_asyncio import MultiAsyncioExecutor
-
-__all__ = ["BaseExecutor", "AsyncioExecutor", "MultiAsyncioExecutor"]