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

jettask/backend/api/v1/tasks.py

@@ -1,367 +0,0 @@
-"""
-Task management API v1
-"""
-from typing import List, Optional
-from fastapi import APIRouter, Depends, HTTPException, Query, Body
-from sqlalchemy.ext.asyncio import AsyncSession
-import redis.asyncio as redis
-
-from dependencies import (
-    get_validated_namespace, get_pg_connection, get_redis_client,
-    validate_page_params, validate_time_range, get_request_metrics, RequestMetrics
-)
-from models.requests import TaskListRequest, TaskActionRequest
-from models.responses import TaskListResponse, TaskDetailResponse, BaseResponse
-from core.cache import cache_result, CACHE_CONFIGS
-from core.exceptions import TaskNotFoundError, ValidationError
-from data_access import JetTaskDataAccess
-import logging
-
-logger = logging.getLogger(__name__)
-router = APIRouter()
-
-
-@router.post("/search", response_model=TaskListResponse)
-async def search_tasks(
-    request: TaskListRequest,
-    namespace: str = Depends(get_validated_namespace),
-    pg_session: AsyncSession = Depends(get_pg_connection),
-    metrics: RequestMetrics = Depends(get_request_metrics)
-):
-    """搜索任务（支持复杂筛选条件）"""
-    metrics.start(namespace, "POST /tasks/search")
-    
-    try:
-        # 创建数据访问实例
-        data_access = JetTaskDataAccess()
-        
-        # 转换筛选条件
-        filters = []
-        for condition in request.filters:
-            filters.append({
-                'field': condition.field,
-                'operator': condition.operator.value,
-                'value': condition.value
-            })
-        
-        # 添加基础筛选条件
-        if request.queue_name:
-            filters.append({'field': 'queue', 'operator': 'eq', 'value': request.queue_name})
-        if request.status:
-            filters.append({'field': 'status', 'operator': 'eq', 'value': request.status})
-        if request.consumer_group:
-            filters.append({'field': 'consumer_group', 'operator': 'eq', 'value': request.consumer_group})
-        if request.worker_id:
-            filters.append({'field': 'worker_id', 'operator': 'eq', 'value': request.worker_id})
-        if request.task_name:
-            filters.append({'field': 'task_name', 'operator': 'like', 'value': f"%{request.task_name}%"})
-        
-        # 执行查询
-        result = await data_access.fetch_tasks_with_filters(
-            queue_name=request.queue_name or "",
-            page=request.page,
-            page_size=request.page_size,
-            filters=filters,
-            start_time=request.start_time,
-            end_time=request.end_time,
-            sort_field=request.sort_field,
-            sort_order=request.sort_order.value if request.sort_order else 'desc',
-            search=request.search
-        )
-        
-        return TaskListResponse.create(
-            data=result['data'],
-            total=result['total'],
-            page=request.page,
-            page_size=request.page_size
-        )
-        
-    except Exception as e:
-        logger.error(f"搜索任务失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        metrics.finish()
-
-
-@router.get("", response_model=TaskListResponse)
-@cache_result(**CACHE_CONFIGS['task_details'])
-async def list_tasks(
-    namespace: str = Depends(get_validated_namespace),
-    queue_name: Optional[str] = Query(None, description="队列名称"),
-    status: Optional[str] = Query(None, description="任务状态"),
-    consumer_group: Optional[str] = Query(None, description="消费者组"),
-    worker_id: Optional[str] = Query(None, description="工作者ID"),
-    task_name: Optional[str] = Query(None, description="任务名称"),
-    page: int = Query(1, ge=1, description="页码"),
-    page_size: int = Query(20, ge=1, le=100, description="每页大小"),
-    sort_field: Optional[str] = Query("created_at", description="排序字段"),
-    sort_order: str = Query("desc", pattern="^(asc|desc)$", description="排序方向"),
-    search: Optional[str] = Query(None, description="搜索关键词"),
-    time_params: dict = Depends(validate_time_range),
-    pg_session: AsyncSession = Depends(get_pg_connection),
-    metrics: RequestMetrics = Depends(get_request_metrics)
-):
-    """获取任务列表（简单查询）"""
-    metrics.start(namespace, "GET /tasks")
-    
-    try:
-        # 创建数据访问实例
-        data_access = JetTaskDataAccess()
-        
-        # 构建筛选条件
-        filters = []
-        if status:
-            filters.append({'field': 'status', 'operator': 'eq', 'value': status})
-        if consumer_group:
-            filters.append({'field': 'consumer_group', 'operator': 'eq', 'value': consumer_group})
-        if worker_id:
-            filters.append({'field': 'worker_id', 'operator': 'eq', 'value': worker_id})
-        if task_name:
-            filters.append({'field': 'task_name', 'operator': 'like', 'value': f"%{task_name}%"})
-        
-        # 执行查询
-        result = await data_access.fetch_tasks_with_filters(
-            queue_name=queue_name or "",
-            page=page,
-            page_size=page_size,
-            filters=filters,
-            start_time=time_params.get('start_time'),
-            end_time=time_params.get('end_time'),
-            sort_field=sort_field,
-            sort_order=sort_order,
-            search=search
-        )
-        
-        return TaskListResponse.create(
-            data=result['data'],
-            total=result['total'],
-            page=page,
-            page_size=page_size
-        )
-        
-    except Exception as e:
-        logger.error(f"获取任务列表失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        metrics.finish()
-
-
-@router.get("/{task_id}", response_model=TaskDetailResponse)
-@cache_result(**CACHE_CONFIGS['task_details'])
-async def get_task_detail(
-    task_id: str,
-    namespace: str = Depends(get_validated_namespace),
-    consumer_group: Optional[str] = Query(None, description="消费者组"),
-    pg_session: AsyncSession = Depends(get_pg_connection),
-    metrics: RequestMetrics = Depends(get_request_metrics)
-):
-    """获取任务详情"""
-    metrics.start(namespace, f"GET /tasks/{task_id}")
-    
-    try:
-        # 创建数据访问实例
-        data_access = JetTaskDataAccess()
-        
-        # 获取任务详情
-        task_detail = await data_access.fetch_task_details(task_id, consumer_group)
-        
-        if not task_detail:
-            raise TaskNotFoundError(task_id)
-        
-        return TaskDetailResponse(data=task_detail)
-        
-    except TaskNotFoundError:
-        raise
-    except Exception as e:
-        logger.error(f"获取任务详情失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        metrics.finish()
-
-
-@router.post("/actions", response_model=BaseResponse)
-async def execute_task_actions(
-    action_request: TaskActionRequest,
-    namespace: str = Depends(get_validated_namespace),
-    redis_client: redis.Redis = Depends(get_redis_client),
-    pg_session: AsyncSession = Depends(get_pg_connection),
-    metrics: RequestMetrics = Depends(get_request_metrics)
-):
-    """批量执行任务操作"""
-    metrics.start(namespace, "POST /tasks/actions")
-    
-    try:
-        action = action_request.action.lower()
-        task_ids = action_request.task_ids
-        parameters = action_request.parameters
-        
-        if not task_ids:
-            raise ValidationError("task_ids cannot be empty")
-        
-        # 验证任务ID格式
-        for task_id in task_ids:
-            if not task_id or not isinstance(task_id, str):
-                raise ValidationError(f"Invalid task_id: {task_id}")
-        
-        success_count = 0
-        failed_count = 0
-        errors = []
-        
-        if action == "retry":
-            # 重试失败任务
-            for task_id in task_ids:
-                try:
-                    # 这里需要实现重试逻辑
-                    # 1. 检查任务状态是否为failed
-                    # 2. 重新入队任务
-                    # 3. 更新任务状态
-                    success_count += 1
-                except Exception as e:
-                    failed_count += 1
-                    errors.append(f"Task {task_id}: {str(e)}")
-        
-        elif action == "cancel":
-            # 取消待处理任务
-            for task_id in task_ids:
-                try:
-                    # 这里需要实现取消逻辑
-                    # 1. 检查任务状态
-                    # 2. 从队列中移除
-                    # 3. 更新任务状态为cancelled
-                    success_count += 1
-                except Exception as e:
-                    failed_count += 1
-                    errors.append(f"Task {task_id}: {str(e)}")
-        
-        elif action == "delete":
-            # 删除任务记录
-            for task_id in task_ids:
-                try:
-                    # 这里需要实现删除逻辑
-                    # 1. 从数据库删除任务记录
-                    # 2. 清理相关数据
-                    success_count += 1
-                except Exception as e:
-                    failed_count += 1
-                    errors.append(f"Task {task_id}: {str(e)}")
-        
-        else:
-            raise ValidationError(f"Unsupported action: {action}")
-        
-        # 构造响应消息
-        message = f"Action '{action}' executed: {success_count} succeeded"
-        if failed_count > 0:
-            message += f", {failed_count} failed"
-        
-        response_data = {
-            'action': action,
-            'total_tasks': len(task_ids),
-            'success_count': success_count,
-            'failed_count': failed_count,
-            'errors': errors[:10]  # 只返回前10个错误
-        }
-        
-        return BaseResponse(
-            message=message,
-            data=response_data
-        )
-        
-    except ValidationError:
-        raise
-    except Exception as e:
-        logger.error(f"执行任务操作失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        metrics.finish()
-
-
-@router.get("/{task_id}/logs")
-async def get_task_logs(
-    task_id: str,
-    namespace: str = Depends(get_validated_namespace),
-    lines: int = Query(100, ge=1, le=1000, description="日志行数"),
-    follow: bool = Query(False, description="是否跟踪日志"),
-    pg_session: AsyncSession = Depends(get_pg_connection),
-    metrics: RequestMetrics = Depends(get_request_metrics)
-):
-    """获取任务执行日志"""
-    metrics.start(namespace, f"GET /tasks/{task_id}/logs")
-    
-    try:
-        # 这里需要实现日志获取逻辑
-        # 1. 从数据库或日志系统获取任务执行日志
-        # 2. 支持实时日志跟踪（WebSocket）
-        
-        # 暂时返回模拟数据
-        logs = [
-            {"timestamp": "2025-09-08T12:00:00Z", "level": "INFO", "message": "Task started"},
-            {"timestamp": "2025-09-08T12:00:01Z", "level": "DEBUG", "message": "Processing data..."},
-            {"timestamp": "2025-09-08T12:00:02Z", "level": "INFO", "message": "Task completed successfully"}
-        ]
-        
-        return BaseResponse(
-            data={
-                "task_id": task_id,
-                "logs": logs[-lines:],
-                "total_lines": len(logs),
-                "truncated": len(logs) > lines
-            }
-        )
-        
-    except Exception as e:
-        logger.error(f"获取任务日志失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        metrics.finish()
-
-
-@router.get("/statistics/summary")
-async def get_task_statistics(
-    namespace: str = Depends(get_validated_namespace),
-    queue_name: Optional[str] = Query(None, description="队列名称"),
-    time_params: dict = Depends(validate_time_range),
-    pg_session: AsyncSession = Depends(get_pg_connection),
-    metrics: RequestMetrics = Depends(get_request_metrics)
-):
-    """获取任务统计摘要"""
-    metrics.start(namespace, "GET /tasks/statistics/summary")
-    
-    try:
-        # 这里需要实现统计查询逻辑
-        # 1. 按状态统计任务数量
-        # 2. 按时间统计任务趋势
-        # 3. 按队列统计任务分布
-        # 4. 计算成功率、平均执行时间等指标
-        
-        # 暂时返回模拟数据
-        statistics = {
-            "total_tasks": 12345,
-            "by_status": {
-                "pending": 123,
-                "running": 45,
-                "completed": 11000,
-                "failed": 1177
-            },
-            "by_queue": {
-                "shared_queue": 8000,
-                "priority_queue": 3000,
-                "background_queue": 1345
-            },
-            "metrics": {
-                "success_rate": 0.905,
-                "avg_execution_time": 12.34,
-                "tasks_per_hour": 234.5
-            },
-            "trends": {
-                "hourly_counts": [],
-                "error_rates": []
-            }
-        }
-        
-        return BaseResponse(data=statistics)
-        
-    except Exception as e:
-        logger.error(f"获取任务统计失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        metrics.finish()

jettask/backend/core/__init__.py

@@ -1,3 +0,0 @@
-"""
-Core infrastructure modules for JetTask WebUI Backend
-"""

jettask/backend/core/cache.py

@@ -1,221 +0,0 @@
-"""
-Caching utilities for JetTask WebUI Backend
-"""
-import json
-import hashlib
-from typing import Any, Optional, Dict, Callable, TypeVar, Union
-from functools import wraps
-import asyncio
-import time
-import logging
-
-import redis.asyncio as redis
-
-logger = logging.getLogger(__name__)
-
-T = TypeVar('T')
-
-
-class CacheManager:
-    """缓存管理器"""
-    
-    def __init__(self, redis_client: Optional[redis.Redis] = None):
-        self.redis_client = redis_client
-        self.local_cache: Dict[str, Dict[str, Any]] = {}
-        self.cache_stats = {
-            'hits': 0,
-            'misses': 0,
-            'sets': 0,
-            'deletes': 0
-        }
-    
-    def _generate_key(self, prefix: str, *args, **kwargs) -> str:
-        """生成缓存键"""
-        key_data = f"{prefix}:{args}:{sorted(kwargs.items())}"
-        return f"jettask:cache:{hashlib.md5(key_data.encode()).hexdigest()}"
-    
-    async def get(self, key: str) -> Optional[Any]:
-        """获取缓存值"""
-        try:
-            # 先检查本地缓存
-            if key in self.local_cache:
-                local_data = self.local_cache[key]
-                if local_data['expires'] > time.time():
-                    self.cache_stats['hits'] += 1
-                    return local_data['value']
-                else:
-                    del self.local_cache[key]
-            
-            # 检查Redis缓存
-            if self.redis_client:
-                value = await self.redis_client.get(key)
-                if value:
-                    self.cache_stats['hits'] += 1
-                    return json.loads(value)
-            
-            self.cache_stats['misses'] += 1
-            return None
-            
-        except Exception as e:
-            logger.warning(f"缓存获取失败: {e}")
-            self.cache_stats['misses'] += 1
-            return None
-    
-    async def set(
-        self, 
-        key: str, 
-        value: Any, 
-        ttl: int = 300,
-        local_only: bool = False
-    ) -> bool:
-        """设置缓存值"""
-        try:
-            # 设置本地缓存
-            if ttl <= 60 or local_only:  # 短期缓存或仅本地缓存
-                self.local_cache[key] = {
-                    'value': value,
-                    'expires': time.time() + ttl
-                }
-            
-            # 设置Redis缓存
-            if self.redis_client and not local_only:
-                await self.redis_client.setex(
-                    key, 
-                    ttl, 
-                    json.dumps(value, default=str)
-                )
-            
-            self.cache_stats['sets'] += 1
-            return True
-            
-        except Exception as e:
-            logger.warning(f"缓存设置失败: {e}")
-            return False
-    
-    async def delete(self, key: str) -> bool:
-        """删除缓存"""
-        try:
-            # 删除本地缓存
-            if key in self.local_cache:
-                del self.local_cache[key]
-            
-            # 删除Redis缓存
-            if self.redis_client:
-                await self.redis_client.delete(key)
-            
-            self.cache_stats['deletes'] += 1
-            return True
-            
-        except Exception as e:
-            logger.warning(f"缓存删除失败: {e}")
-            return False
-    
-    async def clear_pattern(self, pattern: str) -> int:
-        """根据模式删除缓存"""
-        try:
-            deleted = 0
-            
-            # 清理本地缓存
-            keys_to_delete = [k for k in self.local_cache.keys() if pattern in k]
-            for key in keys_to_delete:
-                del self.local_cache[key]
-                deleted += 1
-            
-            # 清理Redis缓存
-            if self.redis_client:
-                keys = await self.redis_client.keys(f"*{pattern}*")
-                if keys:
-                    await self.redis_client.delete(*keys)
-                    deleted += len(keys)
-            
-            self.cache_stats['deletes'] += deleted
-            return deleted
-            
-        except Exception as e:
-            logger.warning(f"批量删除缓存失败: {e}")
-            return 0
-    
-    def cleanup_expired(self):
-        """清理过期的本地缓存"""
-        current_time = time.time()
-        expired_keys = [
-            key for key, data in self.local_cache.items()
-            if data['expires'] <= current_time
-        ]
-        for key in expired_keys:
-            del self.local_cache[key]
-    
-    def get_stats(self) -> Dict[str, Any]:
-        """获取缓存统计信息"""
-        hit_rate = (
-            self.cache_stats['hits'] / 
-            (self.cache_stats['hits'] + self.cache_stats['misses'])
-            if (self.cache_stats['hits'] + self.cache_stats['misses']) > 0
-            else 0
-        )
-        
-        return {
-            **self.cache_stats,
-            'hit_rate': hit_rate,
-            'local_cache_size': len(self.local_cache)
-        }
-
-
-# 全局缓存管理器
-cache_manager = CacheManager()
-
-
-def cache_result(
-    ttl: int = 300,
-    key_prefix: str = "default",
-    local_only: bool = False
-):
-    """缓存装饰器"""
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
-        @wraps(func)
-        async def wrapper(*args, **kwargs) -> T:
-            # 生成缓存键
-            cache_key = cache_manager._generate_key(
-                f"{key_prefix}:{func.__name__}",
-                *args,
-                **kwargs
-            )
-            
-            # 尝试从缓存获取
-            cached_result = await cache_manager.get(cache_key)
-            if cached_result is not None:
-                return cached_result
-            
-            # 执行函数
-            result = await func(*args, **kwargs)
-            
-            # 缓存结果
-            await cache_manager.set(cache_key, result, ttl, local_only)
-            
-            return result
-        
-        return wrapper
-    return decorator
-
-
-def invalidate_cache(pattern: str):
-    """缓存失效装饰器"""
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
-        @wraps(func)
-        async def wrapper(*args, **kwargs) -> T:
-            result = await func(*args, **kwargs)
-            # 执行后清理相关缓存
-            await cache_manager.clear_pattern(pattern)
-            return result
-        
-        return wrapper
-    return decorator
-
-
-# 预定义的缓存配置
-CACHE_CONFIGS = {
-    'queue_stats': {'ttl': 300, 'key_prefix': 'queue_stats'},  # 5分钟
-    'task_details': {'ttl': 60, 'key_prefix': 'task_details'},  # 1分钟  
-    'namespace_config': {'ttl': 1800, 'key_prefix': 'namespace_config'},  # 30分钟
-    'monitoring_data': {'ttl': 30, 'key_prefix': 'monitoring_data', 'local_only': True},  # 30秒，仅本地
-}