#!/usr/bin/env python # -*- coding: utf-8 -*- """ VWED.task 模块 - 任务系统集成 """ import json from typing import Dict, Any, Optional, List from utils.logger import get_logger from utils.json_parser import safe_parse_dict, safe_parse_list class VWEDTaskModule: """VWED.task 模块 - 任务系统集成""" def __init__(self, script_id: str): self.script_id = script_id self.logger = get_logger(f"script.{script_id}.task") async def _get_auth_token(self, auto_get_token: bool = True) -> Optional[str]: """获取认证token的通用方法 Args: auto_get_token: 是否自动获取登录token，默认true Returns: Optional[str]: 认证令牌，获取失败返回None """ if not auto_get_token: return None try: from services.sync_service import refresh_token_if_needed token = await refresh_token_if_needed() if token: self.logger.info(f"脚本 {self.script_id} 成功获取到登录token") return token else: self.logger.warning(f"脚本 {self.script_id} 获取登录token失败，继续使用空token") return None except Exception as e: self.logger.warning(f"脚本 {self.script_id} 获取token异常: {str(e)}，继续使用空token") return None async def create_task( self, label: str, task_type: int = 1, remark: Optional[str] = None, period: Optional[int] = None, delay: Optional[int] = 3000, release_sites: Optional[bool] = True, tenant_id: str = "default", map_id: Optional[str] = None, auto_get_token: bool = True ) -> Dict[str, Any]: """创建VWED任务 Args: label: 任务名称 task_type: 任务类型，1-普通任务，2-定时任务 remark: 任务备注 period: 周期时间（毫秒），定时任务必填 delay: 延迟时间（毫秒），默认3000 release_sites: 是否释放站点，默认true tenant_id: 租户ID，默认"default" map_id: 相关地图ID auto_get_token: 是否自动获取登录token，默认true Returns: Dict[str, Any]: 创建结果 """ try: from services.task_service import TaskService, TaskNameExistsError from data.session import get_db # 获取登录token token = await self._get_auth_token(auto_get_token) # 获取数据库会话 db = next(get_db()) try: # 调用TaskService.create_task方法 result = TaskService.create_task( db=db, label=label, task_type=task_type, remark=remark, period=period, delay=delay, release_sites=release_sites, token=token, # 使用获取到的token tenant_id=tenant_id, map_id=map_id ) self.logger.info(f"脚本 {self.script_id} 成功创建任务: {label} (ID: {result['id']})") return { "success": True, "message": "任务创建成功", "data": result } except TaskNameExistsError as e: self.logger.warning(f"脚本 {self.script_id} 创建任务失败: {str(e)}") return { "success": False, "message": f"任务名称已存在: {str(e)}", "error_type": "name_exists" } except Exception as e: self.logger.error(f"脚本 {self.script_id} 创建任务失败: {str(e)}") return { "success": False, "message": f"创建任务失败: {str(e)}", "error_type": "create_error" } finally: db.close() except Exception as e: self.logger.error(f"脚本 {self.script_id} 任务创建异常: {str(e)}") return { "success": False, "message": f"任务创建异常: {str(e)}", "error_type": "system_error" } async def execute_task( self, task_id: str, parameters: Optional[List[Dict[str, Any]]] = None, source_system: str = "script", source_device: Optional[str] = None, auto_get_token: bool = True ) -> Dict[str, Any]: """执行VWED任务 Args: task_id: 任务ID parameters: 任务输入参数列表 source_system: 来源系统，默认"script" source_device: 来源设备标识 auto_get_token: 是否自动获取登录token，默认true Returns: Dict[str, Any]: 执行结果 """ try: from services.task_edit_service import TaskEditService from routes.model.task_edit_model import TaskEditRunRequest, TaskInputParam from data.enum.task_record_enum import SourceType # 获取登录token token = await self._get_auth_token(auto_get_token) # 构建运行请求 input_params = [] if parameters: for param in parameters: if isinstance(param, dict) and "name" in param and "defaultValue" in param: input_params.append(TaskInputParam( name=param["name"], defaultValue=param["defaultValue"] )) run_request = TaskEditRunRequest( taskId=task_id, params=input_params, source_type=SourceType.SYSTEM_SCHEDULING, source_system=source_system, source_device=source_device or f"script_{self.script_id}" ) # 调用TaskEditService.run_task方法 result = await TaskEditService.run_task( run_request=run_request, client_ip="127.0.0.1", # 本地脚本调用 client_info=f'{{"script_id": "{self.script_id}", "source": "VWED.task.execute_task"}}', tf_api_token=token # 使用获取到的token ) if result and result.get("success"): self.logger.info(f"脚本 {self.script_id} 成功启动任务: {task_id}") return { "success": True, "message": "任务启动成功", "data": result } else: error_msg = result.get("message", "任务启动失败") if result else "任务启动失败" self.logger.error(f"脚本 {self.script_id} 启动任务失败: {error_msg}") return { "success": False, "message": error_msg, "error_type": "execute_error" } except Exception as e: self.logger.error(f"脚本 {self.script_id} 执行任务异常: {str(e)}") return { "success": False, "message": f"执行任务异常: {str(e)}", "error_type": "system_error" } async def execute_task_with_record_id( self, task_id: str, task_record_id: Optional[str] = None, parameters: Optional[List[Dict[str, Any]]] = None, source_system: str = "script", source_device: Optional[str] = None, auto_get_token: bool = True ) -> Dict[str, Any]: """执行VWED任务，支持指定task_record_id Args: task_id: 任务ID task_record_id: 指定的任务记录ID，为空时自动生成 parameters: 任务输入参数列表 source_system: 来源系统，默认"script" source_device: 来源设备标识 auto_get_token: 是否自动获取登录token，默认true Returns: Dict[str, Any]: 执行结果 """ try: from services.task_edit_service import TaskEditService from routes.model.task_edit_model import TaskEditRunRequest, TaskInputParamNew from data.enum.task_record_enum import SourceType # 获取登录token token = await self._get_auth_token(auto_get_token) # 构建运行请求 input_params = [] if parameters: for param in parameters: if isinstance(param, dict) and "name" in param and "defaultValue" in param: input_params.append(TaskInputParamNew( name=param["name"], type="STRING", # 默认字符串类型 label=param["name"], defaultValue=param["defaultValue"] )) run_request = TaskEditRunRequest( taskId=task_id, params=input_params, source_type=SourceType.SYSTEM_SCHEDULING, source_system=source_system, source_device=source_device or f"script_{self.script_id}", task_record_id=task_record_id # 传递指定的task_record_id ) # 调用TaskEditService.run_task方法 result = await TaskEditService.run_task( run_request=run_request, client_ip="127.0.0.1", # 本地脚本调用 client_info=f'{{"script_id": "{self.script_id}", "source": "VWED.task.execute_task_with_record_id"}}', tf_api_token=token # 使用获取到的token ) if result and result.get("success"): self.logger.info(f"脚本 {self.script_id} 成功启动任务: {task_id} (记录ID: {result.get('taskRecordId', task_record_id)})") return { "success": True, "message": "任务启动成功", "data": result } else: error_msg = result.get("message", "任务启动失败") if result else "任务启动失败" self.logger.error(f"脚本 {self.script_id} 启动任务失败: {error_msg}") return { "success": False, "message": error_msg, "error_type": "execute_error" } except Exception as e: self.logger.error(f"脚本 {self.script_id} 执行任务异常: {str(e)}") return { "success": False, "message": f"执行任务异常: {str(e)}", "error_type": "system_error" } async def get_task_status(self, task_record_id: str) -> Dict[str, Any]: """获取任务执行状态 Args: task_record_id: 任务记录ID（不是任务定义ID） Returns: Dict[str, Any]: 任务状态信息 """ try: from data.session import get_async_session from data.models.taskrecord import VWEDTaskRecord from sqlalchemy import select async with get_async_session() as session: result = await session.execute( select(VWEDTaskRecord).where(VWEDTaskRecord.id == task_record_id) ) task_record = result.scalar_one_or_none() if not task_record: return { "success": False, "message": "任务记录不存在", "error_type": "not_found" } # 构建状态信息 status_info = { "task_record_id": task_record.id, "task_def_id": task_record.task_def_id, "status": task_record.status, "progress": task_record.progress, "start_time": task_record.start_time.isoformat() if task_record.start_time else None, "end_time": task_record.end_time.isoformat() if task_record.end_time else None, "error_message": task_record.error_message, "variables": task_record.variables } self.logger.info(f"脚本 {self.script_id} 获取任务状态: {task_record_id}") return { "success": True, "message": "获取任务状态成功", "data": status_info } except Exception as e: self.logger.error(f"脚本 {self.script_id} 获取任务状态异常: {str(e)}") return { "success": False, "message": f"获取任务状态异常: {str(e)}", "error_type": "system_error" } async def check_task_param(self, param: str) -> bool: """校验任务参数 校验输入参数中的 task_id 和 task_label 字段对应的数据是否在数据库中存在。 Args: param: JSON字符串或Python字典字符串，包含task_id和task_label字段 Returns: bool: True表示数据存在，False表示数据不存在 """ try: # 使用通用解析方法 data = safe_parse_dict(param, self.script_id) if data is None: return False task_id = data.get("task_id", "") task_label = data.get("task_label", "") # 如果task_id和task_label都为空，返回False if not task_id and not task_label: self.logger.warning(f"脚本 {self.script_id} task_id和task_label都为空") return False from data.session import get_async_session from data.models.taskdef import VWEDTaskDef from sqlalchemy import select, or_ async with get_async_session() as session: # 构建查询条件：task_id或task_label匹配即可 conditions = [] if task_id: conditions.append(VWEDTaskDef.id == task_id) if task_label: conditions.append(VWEDTaskDef.label == task_label) # 查询数据库 query = select(VWEDTaskDef.id).where( or_(*conditions), VWEDTaskDef.is_deleted == False ) result = await session.execute(query) task_def = result.scalar_one_or_none() exists = task_def is not None self.logger.info(f"脚本 {self.script_id} 任务参数校验结果: task_id={task_id}, task_label={task_label}, exists={exists}") return exists except Exception as e: self.logger.error(f"脚本 {self.script_id} 校验任务参数异常: {str(e)}") return False async def create_wind_task(self, param: str) -> str: """异步创建并运行一个任务 本方法是非阻塞方法，将在脚本中创建一个线程，来执行天风任务的实例。 Args: param: JSON字符串，包含任务创建参数 Returns: str: JSON格式的创建结果 """ try: # 使用通用解析方法 data = safe_parse_dict(param, self.script_id) if data is None: return "" task_id = data.get("task_id") task_label = data.get("task_label") task_record_id = data.get("task_record_id") input_params = data.get("input_params", []) # 验证必选参数 if not task_id and not task_label: return json.dumps({"code": -1, "msg": "task_id和task_label至少需要提供一个"}, ensure_ascii=False) # 解析输入参数 parameters = [] if input_params: # 如果input_params是字符串，尝试解析为JSON if isinstance(input_params, str): try: input_params_data = json.loads(input_params) except: input_params_data = [] else: # 如果input_params已经是列表，直接使用 input_params_data = input_params # 处理参数列表，保留所有字段信息 if isinstance(input_params_data, list): # 如果是完整的参数配置列表：[{"name": "param1", "label": "参数1", "type": "STRING", "defaultValue": "", ...}, ...] for param in input_params_data: if isinstance(param, dict) and "name" in param: # 保留完整的参数配置信息 param_config = { "name": param["name"], "defaultValue": str(param.get("defaultValue", "")) } # 如果有其他字段也保留 if "label" in param: param_config["label"] = param["label"] if "type" in param: param_config["type"] = param["type"] if "required" in param: param_config["required"] = param["required"] if "remark" in param: param_config["remark"] = param["remark"] if "checked" in param: param_config["checked"] = param["checked"] parameters.append(param_config) elif isinstance(input_params_data, dict): # 如果是简单的键值对格式：{"param1": "value1", "param2": "value2"} for key, value in input_params_data.items(): parameters.append({ "name": key, "defaultValue": str(value) }) # 使用task_id或task_label查找任务并执行 target_task_id = task_id if task_id else None if not target_task_id and task_label: # 根据task_label查找task_id的逻辑 from data.session import get_async_session from data.models.taskdef import VWEDTaskDef from sqlalchemy import select async with get_async_session() as session: result = await session.execute(select(VWEDTaskDef.id).where( VWEDTaskDef.label == task_label, VWEDTaskDef.is_deleted == False )) task_def = result.scalar_one_or_none() if task_def: target_task_id = task_def if not target_task_id: return json.dumps({"code": -1, "msg": "未找到指定的任务"}, ensure_ascii=False) # 如果提供了task_record_id，检查是否已存在 if task_record_id and await self.is_task_record_id_exist(task_record_id): return json.dumps({"code": -1, "msg": f"任务记录ID {task_record_id} 已存在"}, ensure_ascii=False) # 执行任务 result = await self.execute_task_with_record_id( task_id=target_task_id, task_record_id=task_record_id, parameters=parameters, source_system="script", source_device=f"script_{self.script_id}" ) if result.get("success"): return json.dumps({"code": 200, "msg": "任务创建成功"}, ensure_ascii=False) else: return json.dumps({"code": -1, "msg": result.get("message", "任务创建失败")}, ensure_ascii=False) except Exception as e: self.logger.error(f"脚本 {self.script_id} 创建任务异常: {str(e)}") return json.dumps({"code": -1, "msg": f"创建任务异常: {str(e)}"}, ensure_ascii=False) async def get_task_record_by_id(self, task_record_id: str) -> str: """根据任务实例ID查询任务实例 Args: task_record_id: 任务实例的唯一ID Returns: str: JSON格式的任务实例信息，不存在则返回"null" """ try: from data.session import get_async_session from data.models.taskrecord import VWEDTaskRecord from sqlalchemy import select async with get_async_session() as session: result = await session.execute( select(VWEDTaskRecord).where(VWEDTaskRecord.id == task_record_id) ) task_record = result.scalar_one_or_none() if not task_record: return "null" # 构建返回数据，按照文档格式 task_info = { "id": task_record.id, "def_id": task_record.def_id, "def_label": task_record.def_label, "status": task_record.status, "created_on": task_record.created_at.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] if task_record.created_at else None, "ended_on": task_record.ended_on.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] if task_record.ended_on else None, "state_description": task_record.state_description or "", "agv_id": task_record.agv_id or "" } return json.dumps(task_info, ensure_ascii=False) except Exception as e: self.logger.error(f"脚本 {self.script_id} 查询任务实例异常: {str(e)}") raise e # def get_task_record_list_by_out_order_no(self, out_order_no: str) -> str: # """根据外部单号查询任务实例列表 # # Args: # out_order_no: 外部单号ID # # Returns: # str: JSON数组格式的任务实例列表 # """ # try: # # 暂时返回空数组，因为当前表结构中没有外部订单号字段 # # 需要在VWEDTaskRecord模型中添加out_order_no字段 # return "[]" # # except Exception as e: # self.logger.error(f"脚本 {self.script_id} 根据外部单号查询任务异常: {str(e)}") # raise e async def get_task_record_by_agv_id(self, agv_id: str) -> str: """根据机器人ID查询任务实例列表 Args: agv_id: 机器人ID Returns: str: JSON数组格式的任务实例列表 """ try: from data.session import get_async_session from data.models.taskrecord import VWEDTaskRecord from sqlalchemy import select async with get_async_session() as session: result = await session.execute( select(VWEDTaskRecord).where(VWEDTaskRecord.agv_id == agv_id) ) task_records = result.scalars().all() if not task_records: return "[]" # 构建返回数据列表 task_list = [] for task_record in task_records: task_info = { "id": task_record.id, "def_id": task_record.def_id, "def_label": task_record.def_label, "status": task_record.status, "created_on": task_record.created_at.strftime("%Y-%m-%d %H:%M:%S") if task_record.created_at else None, "ended_reason": task_record.ended_reason or "运行结束", "ended_on": task_record.ended_on.strftime("%Y-%m-%d %H:%M:%S") if task_record.ended_on else None, "state_description": task_record.state_description or "", } task_list.append(task_info) return json.dumps(task_list, ensure_ascii=False) except Exception as e: self.logger.error(f"脚本 {self.script_id} 根据机器人ID查询任务异常: {str(e)}") raise e async def mark_complete(self, task_id: str, auto_get_token: bool = True) -> Dict[str, Any]: """运行任务封口 Args: task_id: VWED任务系统任务ID auto_get_token: 是否自动获取登录token，默认true Returns: Dict[str, Any]: 封口结果 """ try: # 获取认证token token = await self._get_auth_token(auto_get_token) # 调用 closure_task 接口 from services.sync_service import closure_task result = await closure_task(task_id=task_id, token=token) if result and result.get("success"): self.logger.info(f"脚本 {self.script_id} 成功封口任务: {task_id}") return { "success": True, "message": "任务封口成功", "data": result } else: error_msg = result.get("message", "任务封口失败") if result else "任务封口失败" self.logger.error(f"脚本 {self.script_id} 封口任务失败: {task_id}, 错误: {error_msg}") return { "success": False, "message": error_msg, "error_type": "closure_error" } except Exception as e: self.logger.error(f"脚本 {self.script_id} 标记运单完成异常: {str(e)}") return { "success": False, "message": f"标记运单完成异常: {str(e)}", "error_type": "system_error" } async def is_task_record_id_exist(self, task_record_id: str) -> bool: """校验任务实例ID是否存在 Args: task_record_id: 任务实例id Returns: bool: True表示存在，False表示不存在 """ try: from data.session import get_async_session from data.models.taskrecord import VWEDTaskRecord from sqlalchemy import select async with get_async_session() as session: result = await session.execute( select(VWEDTaskRecord.id).where(VWEDTaskRecord.id == task_record_id) ) task_record = result.scalar_one_or_none() return task_record is not None except Exception as e: self.logger.error(f"脚本 {self.script_id} 校验任务实例ID异常: {str(e)}") raise e async def is_task_label_exist(self, task_name: str) -> bool: """校验任务名称是否存在 Args: task_name: 任务名称 Returns: bool: True表示存在，False表示不存在 """ try: from data.session import get_async_session from data.models.taskdef import VWEDTaskDef from sqlalchemy import select async with get_async_session() as session: result = await session.execute( select(VWEDTaskDef.id).where( VWEDTaskDef.label == task_name, VWEDTaskDef.is_deleted == False ) ) task_def = result.scalar_one_or_none() return task_def is not None except Exception as e: self.logger.error(f"脚本 {self.script_id} 校验任务名称异常: {str(e)}") raise e async def query_task_record(self, param: str) -> str: """根据查询条件获取任务实例 Args: param: JSON字符串，包含查询条件 Returns: str: JSON数组格式的任务实例列表 """ try: data = safe_parse_dict(param, self.script_id) if data is None: return "[]" from data.session import get_async_session from data.models.taskrecord import VWEDTaskRecord from sqlalchemy import select, and_ from datetime import datetime async with get_async_session() as session: # 构建查询条件 conditions = [] # 任务ID条件 if data.get("task_id"): conditions.append(VWEDTaskRecord.def_id == data["task_id"]) # 任务实例ID条件 if data.get("task_record_id"): conditions.append(VWEDTaskRecord.id == data["task_record_id"]) # 状态条件 if data.get("status"): conditions.append(VWEDTaskRecord.status == int(data["status"])) # 机器人ID条件 if data.get("agv_id"): conditions.append(VWEDTaskRecord.agv_id == data["agv_id"]) # 时间范围条件 if data.get("start_date"): start_time = datetime.strptime(data["start_date"], "%Y-%m-%d %H:%M:%S") conditions.append(VWEDTaskRecord.created_at >= start_time) if data.get("end_date"): end_time = datetime.strptime(data["end_date"], "%Y-%m-%d %H:%M:%S") conditions.append(VWEDTaskRecord.created_at <= end_time) # 执行查询 query = select(VWEDTaskRecord) if conditions: query = query.where(and_(*conditions)) result = await session.execute(query) task_records = result.scalars().all() if not task_records: return "[]" # 构建返回数据列表 task_list = [] for task_record in task_records: task_info = { "id": task_record.id, "def_id": task_record.def_id, "def_label": task_record.def_label, "status": task_record.status, "created_on": task_record.created_at.strftime("%Y-%m-%d %H:%M:%S") if task_record.created_at else None, "ended_reason": task_record.ended_reason or "运行结束", "ended_on": task_record.ended_on.strftime("%Y-%m-%d %H:%M:%S") if task_record.ended_on else None, "state_description": task_record.state_description or "", } task_list.append(task_info) return json.dumps(task_list, ensure_ascii=False) except Exception as e: self.logger.error(f"脚本 {self.script_id} 查询任务实例异常: {str(e)}") raise e # def receive_third_order(self, order_param: str) -> bool: # """接收并持久化第三方系统任务请求 # Args: # order_param: JSON字符串，第三方请求参数 # Returns: # bool: True表示成功，False表示失败 # """ # try: # # 这里需要实现第三方订单表的创建和插入逻辑 # # 暂时返回True，表示接收成功 # self.logger.info(f"脚本 {self.script_id} 接收第三方订单: {order_param}") # return True # except Exception as e: # self.logger.error(f"脚本 {self.script_id} 接收第三方订单异常: {str(e)}") # return False def save_task_log(self, log_param: str) -> None: """保存任务运行时日志 新增RDS任务实例的运行日志，该日志将显示在任务实例的监控界面中。 Args: log_param: JSON字符串，包含日志信息 """ try: data = safe_parse_dict(log_param, self.script_id) if data is None: return # 记录到系统日志 level = data.get("level", 1) message = data.get("message", "") task_id = data.get("task_id", "") task_record_id = data.get("task_record_id", "") block_id = data.get("block_id", "") log_msg = f"任务日志 [任务ID:{task_id}] [实例ID:{task_record_id}] [块ID:{block_id}] {message}" if level == 1: # 正常运行 self.logger.info(log_msg) elif level == 2: # 正常停止 self.logger.warning(log_msg) elif level == 3: # 异常中断 self.logger.error(log_msg) else: self.logger.info(log_msg) except Exception as e: self.logger.error(f"脚本 {self.script_id} 保存任务日志异常: {str(e)}") async def sync_create_wind_task(self, task_param: str) -> str: """创建并运行一个任务 本方法是阻塞方法，可以在脚本中创建一个天风任务的实例，并在任务执行结束后返回。 Args: task_param: JSON字符串，包含任务创建参数 Returns: str: "9013"表示任务正常结束，"9014"表示任务异常结束 """ try: # 使用create_wind_task的逻辑创建任务 result_json = await self.create_wind_task(task_param) result = json.loads(result_json) if result.get("code") != 200: return "9014" # 解析参数获取task_record_id用于监控 data = safe_parse_dict(task_param, self.script_id) if data is None: return "9014" task_record_id = data.get("task_record_id") if not task_record_id: self.logger.warning(f"脚本 {self.script_id} 无法获取task_record_id，无法监控任务状态") return "9014" # 等待任务完成 return await self._wait_for_task_completion(task_record_id) except Exception as e: self.logger.error(f"脚本 {self.script_id} 同步创建任务异常: {str(e)}") return "9014" async def _wait_for_task_completion(self, task_record_id: str, check_interval: int = 1, timeout: int = 3600) -> str: """等待任务完成 Args: task_record_id: 任务记录ID check_interval: 检查间隔（秒） timeout: 超时时间（秒） Returns: str: "9013"表示任务正常结束，"9014"表示任务异常结束 """ import asyncio from data.enum.task_record_enum import TaskStatus start_time = asyncio.get_event_loop().time() while True: try: # 检查是否超时 if asyncio.get_event_loop().time() - start_time > timeout: self.logger.warning(f"脚本 {self.script_id} 等待任务完成超时: {task_record_id}") return "9014" # 获取任务状态 status_result = await self.get_task_status(task_record_id) if not status_result.get("success"): self.logger.error(f"脚本 {self.script_id} 获取任务状态失败: {task_record_id}") return "9014" task_data = status_result.get("data", {}) status = task_data.get("status") # 检查任务状态 if status == TaskStatus.COMPLETED: self.logger.info(f"脚本 {self.script_id} 任务正常完成: {task_record_id}") return "9013" elif status in [TaskStatus.FAILED, TaskStatus.CANCELED]: self.logger.warning(f"脚本 {self.script_id} 任务异常结束: {task_record_id}, status: {status}") return "9014" elif status in [TaskStatus.RUNNING, TaskStatus.QUEUED, TaskStatus.PAUSED]: # 任务还在执行中，继续等待 self.logger.debug(f"脚本 {self.script_id} 任务执行中: {task_record_id}, status: {status}") await asyncio.sleep(check_interval) else: # 未知状态 self.logger.warning(f"脚本 {self.script_id} 任务状态未知: {task_record_id}, status: {status}") return "9014" except Exception as e: self.logger.error(f"脚本 {self.script_id} 监控任务状态异常: {task_record_id}, 错误: {str(e)}") return "9014" async def terminate_tasks(self, param: str) -> None: """终止任务 本方法是非阻塞方法，可用于终止多个正在运行的天风任务实例。 Args: param: JSON字符串，包含要终止的任务实例ID列表 """ try: data = safe_parse_list(param, self.script_id) if data is None: return # 获取认证token token = await self._get_auth_token(auto_get_token=True) for task_info in data: task_record_id = task_info.get("task_record_id") if task_record_id: try: # 1. 调用调度器取消本地任务 from services.enhanced_scheduler import scheduler scheduler_result = await scheduler.cancel_task(task_record_id) # 2. 调用天风系统接口设置任务为终止状态 from services.sync_service import set_task_terminated tf_result = await set_task_terminated(task_record_id, token) # 记录结果 if scheduler_result.get("success"): self.logger.info(f"脚本 {self.script_id} 成功在调度器中终止任务: {task_record_id}") else: self.logger.warning(f"脚本 {self.script_id} 调度器中终止任务失败: {task_record_id}") if tf_result and tf_result.get("success"): self.logger.info(f"脚本 {self.script_id} 成功在天风系统中设置任务终止状态: {task_record_id}") else: self.logger.warning(f"脚本 {self.script_id} 天风系统中设置任务终止状态失败: {task_record_id}") # 只要任一操作成功就认为整体成功 if scheduler_result.get("success") or (tf_result and tf_result.get("success")): self.logger.info(f"脚本 {self.script_id} 任务终止操作完成: {task_record_id}") else: self.logger.error(f"脚本 {self.script_id} 任务终止操作全部失败: {task_record_id}") except Exception as e: self.logger.error(f"脚本 {self.script_id} 终止任务异常: {task_record_id}, 错误: {str(e)}") except Exception as e: self.logger.error(f"脚本 {self.script_id} 终止任务异常: {str(e)}") raise e async def get_children_task_record_id(self, record_id: str) -> str: """查询子任务的任务id列表 本方法是非阻塞方法，可根据父任务的id查询所有子任务的id。 Args: record_id: 父任务的record_id Returns: str: 包含子任务id的JSON字符串 """ try: from data.session import get_async_session from data.models.taskrecord import VWEDTaskRecord from sqlalchemy import select async with get_async_session() as session: result = await session.execute( select(VWEDTaskRecord.id).where(VWEDTaskRecord.parent_task_record_id == record_id) ) child_ids = [row[0] for row in result.fetchall()] return json.dumps(child_ids, ensure_ascii=False) except Exception as e: self.logger.error(f"脚本 {self.script_id} 查询子任务ID列表异常: {str(e)}") raise e async def set_task_priority(self, task_record_id: str, priority: int) -> None: """设置任务优先级 本方法是非阻塞方法，可根据设置任务的优先级。 Args: task_record_id: 任务的实例id priority: 任务的优先级 Raises: Exception: 当任务记录ID不存在时抛出异常 """ try: from data.session import get_async_session from data.models.taskrecord import VWEDTaskRecord from sqlalchemy import select, update async with get_async_session() as session: # 首先查询任务记录是否存在 result = await session.execute( select(VWEDTaskRecord.id).where(VWEDTaskRecord.id == task_record_id) ) task_record = result.scalar_one_or_none() if not task_record: error_msg = f"任务记录ID不存在: {task_record_id}" self.logger.error(f"脚本 {self.script_id} {error_msg}") raise Exception(error_msg) # 更新任务优先级 await session.execute( update(VWEDTaskRecord) .where(VWEDTaskRecord.id == task_record_id) .values(priority=priority) ) await session.commit() self.logger.info(f"脚本 {self.script_id} 设置任务优先级成功: {task_record_id} -> {priority}") except Exception as e: self.logger.error(f"脚本 {self.script_id} 设置任务优先级异常: {str(e)}") raise e