jettask 0.2.14__py3-none-any.whl → 0.2.16__py3-none-any.whl

jettask/services/redis_monitor_service.py

@@ -0,0 +1,151 @@
+"""
+Redis监控服务层
+处理Redis监控相关的业务逻辑
+"""
+from typing import Optional, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class RedisMonitorService:
+    """Redis监控服务类"""
+    
+    def __init__(self, namespace_data_access):
+        """
+        初始化Redis监控服务
+        
+        Args:
+            namespace_data_access: 命名空间数据访问实例
+        """
+        self.namespace_data_access = namespace_data_access
+    
+    async def get_redis_monitor_data(
+        self,
+        namespace: str
+    ) -> Dict[str, Any]:
+        """
+        获取Redis监控数据
+        
+        Args:
+            namespace: 命名空间
+            
+        Returns:
+            Redis监控数据
+        """
+        # TODO: 实现获取Redis监控数据逻辑
+        return {
+            "namespace": namespace,
+            "status": "healthy",
+            "metrics": {}
+        }
+    
+    async def get_redis_config(
+        self,
+        namespace: str
+    ) -> Dict[str, Any]:
+        """
+        获取Redis配置信息
+        
+        Args:
+            namespace: 命名空间
+            
+        Returns:
+            Redis配置信息
+        """
+        # TODO: 实现获取Redis配置逻辑
+        return {
+            "namespace": namespace,
+            "config": {}
+        }
+    
+    async def execute_redis_command(
+        self,
+        namespace: str,
+        command: str,
+        args: Optional[list] = None
+    ) -> Any:
+        """
+        执行Redis命令
+        
+        Args:
+            namespace: 命名空间
+            command: Redis命令
+            args: 命令参数
+            
+        Returns:
+            命令执行结果
+        """
+        # TODO: 实现执行Redis命令逻辑
+        return {
+            "success": True,
+            "result": None
+        }
+    
+    async def get_slow_log(
+        self,
+        namespace: str,
+        limit: int = 10
+    ) -> Dict[str, Any]:
+        """
+        获取Redis慢查询日志
+        
+        Args:
+            namespace: 命名空间
+            limit: 返回记录数
+            
+        Returns:
+            慢查询日志数据
+        """
+        logger.info(f"获取Redis慢查询日志 - namespace: {namespace}, limit: {limit}")
+        # TODO: 实现获取Redis慢查询日志逻辑
+        return {
+            "namespace": namespace,
+            "slow_queries": [],
+            "total": 0
+        }
+    
+    async def get_command_stats(
+        self,
+        namespace: str
+    ) -> Dict[str, Any]:
+        """
+        获取Redis命令统计
+        
+        Args:
+            namespace: 命名空间
+            
+        Returns:
+            命令统计数据
+        """
+        logger.info(f"获取Redis命令统计 - namespace: {namespace}")
+        # TODO: 实现获取Redis命令统计逻辑
+        return {
+            "namespace": namespace,
+            "command_stats": {},
+            "total_calls": 0
+        }
+    
+    async def get_stream_stats(
+        self,
+        namespace: str,
+        stream_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        获取Redis Stream统计
+        
+        Args:
+            namespace: 命名空间
+            stream_name: Stream名称(可选)
+            
+        Returns:
+            Stream统计数据
+        """
+        logger.info(f"获取Redis Stream统计 - namespace: {namespace}, stream: {stream_name}")
+        # TODO: 实现获取Redis Stream统计逻辑
+        return {
+            "namespace": namespace,
+            "stream_name": stream_name,
+            "streams": [],
+            "total_messages": 0
+        }

jettask/services/scheduled_task_service.py

@@ -0,0 +1,207 @@
+"""
+定时任务服务层
+处理定时任务相关的业务逻辑
+"""
+from typing import Optional, List, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ScheduledTaskService:
+    """定时任务服务类"""
+    
+    def __init__(self, data_access):
+        """
+        初始化定时任务服务
+        
+        Args:
+            data_access: 数据访问层实例
+        """
+        self.data_access = data_access
+    
+    @staticmethod
+    def validate_schedule_config(schedule_type: str, schedule_config: dict):
+        """
+        验证调度配置
+        
+        Args:
+            schedule_type: 调度类型
+            schedule_config: 调度配置
+            
+        Raises:
+            ValueError: 配置无效时
+        """
+        if schedule_type == 'interval':
+            if 'seconds' in schedule_config:
+                seconds = schedule_config.get('seconds')
+                if seconds is None or seconds <= 0:
+                    raise ValueError(f"间隔时间必须大于0秒，当前值: {seconds}")
+                if seconds < 1:
+                    raise ValueError(
+                        f"间隔时间不能小于1秒，当前值: {seconds}秒。"
+                        f"小于1秒的高频任务可能影响系统性能"
+                    )
+            elif 'minutes' in schedule_config:
+                minutes = schedule_config.get('minutes')
+                if minutes is None or minutes <= 0:
+                    raise ValueError(f"间隔时间必须大于0分钟，当前值: {minutes}")
+            else:
+                raise ValueError("interval类型的任务必须指定seconds或minutes")
+        elif schedule_type == 'cron':
+            if 'cron_expression' not in schedule_config:
+                raise ValueError("cron类型的任务必须指定cron_expression")
+    
+    async def get_scheduled_tasks(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        search: Optional[str] = None,
+        is_active: Optional[bool] = None,
+        filters: Optional[List[Dict]] = None,
+        time_range: Optional[str] = None,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        获取定时任务列表
+        
+        Args:
+            page: 页码
+            page_size: 每页大小
+            search: 搜索关键字
+            is_active: 是否激活
+            filters: 筛选条件
+            time_range: 时间范围
+            start_time: 开始时间
+            end_time: 结束时间
+            
+        Returns:
+            任务列表和总数
+        """
+        async with self.data_access.get_session() as session:
+            tasks, total = await self.data_access.fetch_scheduled_tasks(
+                session=session,
+                page=page,
+                page_size=page_size,
+                search=search,
+                is_active=is_active,
+                filters=filters,
+                time_range=time_range,
+                start_time=start_time,
+                end_time=end_time
+            )
+        
+        return {
+            "success": True,
+            "data": tasks,
+            "total": total,
+            "page": page,
+            "page_size": page_size
+        }
+    
+    async def create_scheduled_task(
+        self,
+        task_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        创建定时任务
+        
+        Args:
+            task_data: 任务数据
+            
+        Returns:
+            创建的任务信息
+        """
+        # 验证调度配置
+        self.validate_schedule_config(
+            task_data['schedule_type'],
+            task_data['schedule_config']
+        )
+        
+        async with self.data_access.get_session() as session:
+            task = await self.data_access.create_scheduled_task(session, task_data)
+        
+        return {
+            "success": True,
+            "data": task,
+            "message": "定时任务创建成功"
+        }
+    
+    async def update_scheduled_task(
+        self,
+        task_id: str,
+        task_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        更新定时任务
+        
+        Args:
+            task_id: 任务ID
+            task_data: 任务数据
+            
+        Returns:
+            更新后的任务信息
+        """
+        # 验证调度配置
+        self.validate_schedule_config(
+            task_data['schedule_type'],
+            task_data['schedule_config']
+        )
+        
+        async with self.data_access.get_session() as session:
+            task = await self.data_access.update_scheduled_task(
+                session, task_id, task_data
+            )
+        
+        return {
+            "success": True,
+            "data": task,
+            "message": "定时任务更新成功"
+        }
+    
+    async def delete_scheduled_task(self, task_id: str) -> Dict[str, Any]:
+        """
+        删除定时任务
+        
+        Args:
+            task_id: 任务ID
+            
+        Returns:
+            操作结果
+        """
+        async with self.data_access.get_session() as session:
+            success = await self.data_access.delete_scheduled_task(session, task_id)
+        
+        if success:
+            return {
+                "success": True,
+                "message": f"定时任务 {task_id} 已删除"
+            }
+        else:
+            raise ValueError("定时任务不存在")
+    
+    async def toggle_scheduled_task(self, task_id: str) -> Dict[str, Any]:
+        """
+        启用/禁用定时任务
+        
+        Args:
+            task_id: 任务ID
+            
+        Returns:
+            更新后的状态
+        """
+        async with self.data_access.get_session() as session:
+            task = await self.data_access.toggle_scheduled_task(session, task_id)
+        
+        if task:
+            return {
+                "success": True,
+                "data": {
+                    "id": task["id"],
+                    "is_active": task["enabled"]
+                },
+                "message": "定时任务状态已更新"
+            }
+        else:
+            raise ValueError("定时任务不存在")