2562 lines
94 KiB
Python
2562 lines
94 KiB
Python
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
|
||
"""
|
||
块处理器模块
|
||
提供对不同类型块的执行处理
|
||
"""
|
||
|
||
import json
|
||
import logging
|
||
from abc import ABC, abstractmethod
|
||
from typing import Dict, List, Any, Optional, Type, Callable
|
||
from datetime import datetime
|
||
|
||
from services.execution.task_context import TaskContext
|
||
|
||
# 获取日志记录器
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# 块处理器注册表
|
||
_block_handlers = {}
|
||
|
||
class BlockHandler(ABC):
|
||
"""
|
||
块处理器抽象基类
|
||
所有具体的块处理器都应该继承这个类
|
||
"""
|
||
|
||
@abstractmethod
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
执行块
|
||
|
||
Args:
|
||
block: 块定义
|
||
input_params: 解析后的输入参数
|
||
context: 任务上下文
|
||
|
||
Returns:
|
||
Dict[str, Any]: 执行结果，必须包含success字段
|
||
"""
|
||
pass
|
||
|
||
async def _record_task_log(
|
||
self,
|
||
block: Dict[str, Any],
|
||
result: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> None:
|
||
"""
|
||
记录任务日志
|
||
|
||
Args:
|
||
block: 块定义
|
||
result: 执行结果
|
||
context: 任务上下文
|
||
"""
|
||
from sqlalchemy import insert
|
||
from data.models.tasklog import VWEDTaskLog
|
||
from data.session import get_async_session
|
||
import uuid
|
||
from datetime import datetime
|
||
|
||
try:
|
||
# 创建任务日志记录
|
||
task_log_id = str(uuid.uuid4())
|
||
async with get_async_session() as session:
|
||
stmt = insert(VWEDTaskLog).values(
|
||
id=task_log_id,
|
||
create_time=datetime.now(),
|
||
level=1 if result.get("success", False) else 3, # 1: 信息, 3: 错误
|
||
message=json.dumps(result, ensure_ascii=False),
|
||
task_block_id=block.get("id", "unknown"),
|
||
task_id=context.task_def_id,
|
||
task_record_id=context.task_record_id
|
||
)
|
||
await session.execute(stmt)
|
||
await session.commit()
|
||
except Exception as e:
|
||
logger.error(f"记录任务日志失败: {str(e)}")
|
||
|
||
# 注册装饰器
|
||
def register_handler(block_type: str):
|
||
"""
|
||
注册块处理器的装饰器
|
||
|
||
Args:
|
||
block_type: 块类型
|
||
"""
|
||
def decorator(cls):
|
||
_block_handlers[block_type] = cls()
|
||
return cls
|
||
return decorator
|
||
|
||
# 获取块处理器
|
||
def get_block_handler(block_type: str) -> Optional[BlockHandler]:
|
||
"""
|
||
获取块处理器
|
||
|
||
Args:
|
||
block_type: 块类型
|
||
|
||
Returns:
|
||
Optional[BlockHandler]: 对应的块处理器，如果不存在则返回None
|
||
"""
|
||
return _block_handlers.get(block_type)
|
||
|
||
# # =============================================子任务组件类========================================================
|
||
# # 子任务块处理器
|
||
# @register_handler("SubTaskBp")
|
||
# class SubTaskBlockHandler(BlockHandler):
|
||
# """子任务块处理器"""
|
||
#
|
||
# async def execute(
|
||
# self,
|
||
# block: Dict[str, Any],
|
||
# input_params: Dict[str, Any],
|
||
# context: TaskContext
|
||
# ) -> Dict[str, Any]:
|
||
# """执行子任务块"""
|
||
# from sqlalchemy import select, insert
|
||
# from data.models.taskdef import VWEDTaskDef
|
||
# from data.models.taskrecord import VWEDTaskRecord
|
||
# from data.session import get_async_session
|
||
# from services.execution.task_executor import TaskExecutor
|
||
# import uuid
|
||
# import asyncio
|
||
#
|
||
# try:
|
||
# # 获取子任务ID
|
||
# subtask_id = block.get("refTaskDefId")
|
||
#
|
||
# if not subtask_id:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": "缺少子任务ID"
|
||
# }
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# # 获取执行参数（确保默认值）
|
||
# is_async = input_params.get("ifAsync", False) # 是否异步执行，默认False
|
||
# specified_task_record_id = input_params.get("taskRecordId", None) # 指定的任务记录ID，默认None
|
||
#
|
||
# # 从input_params中提取出子任务需要的参数
|
||
# # 排除控制参数
|
||
# control_params = ["ifAsync", "taskRecordId"]
|
||
# subtask_params = {}
|
||
# for key, value in input_params.items():
|
||
# if key not in control_params:
|
||
# subtask_params[key] = value
|
||
#
|
||
# logger.info(f"开始执行子任务: {subtask_id}, 异步执行: {is_async}, 指定ID: {specified_task_record_id}")
|
||
#
|
||
# # 确定任务记录ID
|
||
# task_record_id = None
|
||
# if specified_task_record_id:
|
||
# # 检查指定的任务记录是否存在
|
||
# async with get_async_session() as session:
|
||
# result = await session.execute(
|
||
# select(VWEDTaskRecord).where(VWEDTaskRecord.id == specified_task_record_id)
|
||
# )
|
||
# existing_record = result.scalars().first()
|
||
#
|
||
# if existing_record:
|
||
# # 如果指定的任务记录ID已存在，则报错
|
||
# result = {
|
||
# "success": False,
|
||
# "message": f"指定的任务记录ID已存在: {specified_task_record_id}"
|
||
# }
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
# else:
|
||
# # 使用指定的ID创建新任务
|
||
# task_record_id = specified_task_record_id
|
||
# logger.info(f"使用指定ID创建新任务记录: {task_record_id}")
|
||
#
|
||
# if not task_record_id:
|
||
# # 如果未指定ID或指定的ID不存在，生成新ID
|
||
# task_record_id = str(uuid.uuid4())
|
||
# logger.info(f"使用生成的任务记录ID: {task_record_id}")
|
||
#
|
||
# # 获取根任务记录ID - 如果当前任务有父任务，则根任务是父任务的根任务，否则是当前任务
|
||
# root_task_record_id = context.get_variable("rootTaskRecordId", context.task_record_id)
|
||
#
|
||
# # 查询任务定义
|
||
# async with get_async_session() as session:
|
||
# result = await session.execute(
|
||
# select(VWEDTaskDef).where(VWEDTaskDef.id == subtask_id)
|
||
# )
|
||
# task_def = result.scalars().first()
|
||
#
|
||
# if not task_def:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": f"找不到子任务定义: {subtask_id}"
|
||
# }
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# # 获取任务定义详情
|
||
# task_def_detail = task_def.detail
|
||
#
|
||
# # 创建任务记录 - 设置所有关键参数
|
||
# record_values = {
|
||
# "id": task_record_id,
|
||
# "def_id": subtask_id,
|
||
# "def_label": task_def.label,
|
||
# "def_version": task_def.version,
|
||
# "created_on": datetime.now(),
|
||
# "status": 0, # 初始状态
|
||
# "input_params": json.dumps(subtask_params, ensure_ascii=False),
|
||
# "parent_task_record_id": context.task_record_id, # 设置父任务ID
|
||
# "root_task_record_id": root_task_record_id, # 设置根任务ID
|
||
# "periodic_task": task_def.periodic_task if hasattr(task_def, "periodic_task") else 0, # 继承周期任务属性
|
||
# "task_def_detail": task_def_detail # 设置任务定义详情
|
||
# }
|
||
#
|
||
# # 执行插入
|
||
# await session.execute(
|
||
# insert(VWEDTaskRecord).values(record_values)
|
||
# )
|
||
# await session.commit()
|
||
#
|
||
# # 创建任务执行器
|
||
# executor = TaskExecutor(task_record_id)
|
||
#
|
||
# # 根据是否异步执行采取不同的处理方式
|
||
# if is_async:
|
||
# # 异步执行：启动任务但不等待结果
|
||
# # 初始化执行器
|
||
# init_success = await executor.initialize()
|
||
# if not init_success:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": f"初始化子任务执行器失败: {executor.error_message}"
|
||
# }
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# # 创建异步任务但不等待
|
||
# asyncio.create_task(executor.execute())
|
||
#
|
||
# # 执行完成后记录日志
|
||
# result = {
|
||
# "success": True,
|
||
# "message": f"子任务已异步启动: {task_record_id}",
|
||
# "output": {
|
||
# "subtaskId": subtask_id,
|
||
# "taskRecordId": task_record_id,
|
||
# "async": True
|
||
# }
|
||
# }
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
# else:
|
||
# # 同步执行：等待任务执行完成后返回结果
|
||
# # 初始化执行器
|
||
# init_success = await executor.initialize()
|
||
# if not init_success:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": f"初始化子任务执行器失败: {executor.error_message}"
|
||
# }
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# # 执行子任务并等待结果
|
||
# execute_result = await executor.execute()
|
||
#
|
||
# # 处理子任务执行结果
|
||
# success = execute_result.get("success", False)
|
||
# message = execute_result.get("message", "子任务执行完成")
|
||
#
|
||
# # 记录子任务结果到上下文变量
|
||
# context.set_variable("subtaskResult", execute_result)
|
||
#
|
||
# # 获取子任务输出
|
||
# output = execute_result.get("result", {})
|
||
#
|
||
# # 将子任务输出合并到当前上下文变量
|
||
# if isinstance(output, dict):
|
||
# for key, value in output.items():
|
||
# variable_name = f"subtask_{key}"
|
||
# context.set_variable(variable_name, value)
|
||
#
|
||
# # 执行完成后记录日志
|
||
# result = {
|
||
# "success": success,
|
||
# "message": message,
|
||
# "output": {
|
||
# "subtaskId": subtask_id,
|
||
# "taskRecordId": task_record_id,
|
||
# "async": False,
|
||
# "output": output
|
||
# }
|
||
# }
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
# except Exception as e:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": f"子任务执行异常: {str(e)}"
|
||
# }
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
|
||
|
||
# 根块处理器
|
||
@register_handler("RootBp")
|
||
class RootBlockHandler(BlockHandler):
|
||
"""根块处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行根块"""
|
||
try:
|
||
from services.execution.block_executor import BlockExecutor
|
||
|
||
# 创建块执行器
|
||
executor = BlockExecutor(context)
|
||
|
||
# 执行根块的子块
|
||
result = await executor.execute_children(block)
|
||
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
|
||
return result
|
||
except Exception as e:
|
||
# 处理异常
|
||
result = {
|
||
"success": False,
|
||
"message": f"根块执行异常: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# ========================================================脚本组件类================================================
|
||
# 设置任务变量块处理器
|
||
# @register_handler("SetTaskVariablesBp")
|
||
# class SetTaskVariablesBlockHandler(BlockHandler):
|
||
# """设置任务变量块处理器"""
|
||
#
|
||
# async def execute(
|
||
# self,
|
||
# block: Dict[str, Any],
|
||
# input_params: Dict[str, Any],
|
||
# context: TaskContext
|
||
# ) -> Dict[str, Any]:
|
||
# """执行设置任务变量块"""
|
||
# try:
|
||
# # 获取函数名和参数
|
||
# function_name = input_params.get("functionName")
|
||
# function_args = input_params.get("functionArgs", {})
|
||
#
|
||
# if not function_name:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": "缺少函数名"
|
||
# }
|
||
# # 记录执行结果
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# # 调用脚本执行方法
|
||
# exec_result = await self._execute_script(function_name, function_args, context)
|
||
#
|
||
# # 如果执行成功，将变量保存到任务记录
|
||
# if exec_result.get("success", False):
|
||
# await self._save_variables_to_database(context)
|
||
#
|
||
# # 记录执行结果
|
||
# await self._record_task_log(block, exec_result, context)
|
||
# return exec_result
|
||
# except Exception as e:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": f"设置任务变量失败: {str(e)}"
|
||
# }
|
||
# # 记录异常
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# async def _execute_script(
|
||
# self,
|
||
# function_name: str,
|
||
# function_args: Any,
|
||
# context: TaskContext
|
||
# ) -> Dict[str, Any]:
|
||
# """
|
||
# 执行指定的脚本函数
|
||
#
|
||
# Args:
|
||
# function_name: 要执行的函数名
|
||
# function_args: 函数参数
|
||
# context: 任务上下文
|
||
#
|
||
# Returns:
|
||
# Dict[str, Any]: 执行结果
|
||
# """
|
||
# # 固定加载scripts/user_save/test1.py文件
|
||
# script_file = r"D:\jsw_code\project\VWED_task\scripts\user_save\test1.py"
|
||
# logger.info(f"正在加载脚本文件: {script_file}")
|
||
#
|
||
# try:
|
||
# # 动态加载脚本模块
|
||
# import importlib.util
|
||
# import sys
|
||
# import os
|
||
#
|
||
# # 检查文件是否存在
|
||
# if not os.path.exists(script_file):
|
||
# return {
|
||
# "success": False,
|
||
# "message": f"脚本文件不存在: {script_file}"
|
||
# }
|
||
#
|
||
# # 加载模块
|
||
# spec = importlib.util.spec_from_file_location("user_script", script_file)
|
||
# if not spec:
|
||
# return {
|
||
# "success": False,
|
||
# "message": f"无法加载脚本规范: {script_file}"
|
||
# }
|
||
# module = importlib.util.module_from_spec(spec)
|
||
# sys.modules["user_script"] = module
|
||
# spec.loader.exec_module(module)
|
||
#
|
||
# # 检查函数是否存在
|
||
# if not hasattr(module, function_name):
|
||
# return {
|
||
# "success": False,
|
||
# "message": f"函数 {function_name} 在脚本 {script_file} 中不存在"
|
||
# }
|
||
# # 获取函数对象
|
||
# func = getattr(module, function_name)
|
||
#
|
||
# # 准备函数参数（处理不同类型的参数传递方式）
|
||
# args = []
|
||
# kwargs = {}
|
||
#
|
||
# # 如果function_args是字典，将其作为关键字参数传递
|
||
# if isinstance(function_args, dict):
|
||
# kwargs = function_args
|
||
# # 如果function_args是列表，将其作为位置参数传递
|
||
# elif isinstance(function_args, list):
|
||
# args = function_args
|
||
# # 如果function_args是其他类型，将其作为单个位置参数传递
|
||
# elif function_args is not None:
|
||
# args = [function_args]
|
||
#
|
||
# # 调用函数
|
||
# logger.info(f"调用函数 {function_name} 参数: args={args}, kwargs={kwargs}")
|
||
# result_value = func(*args, **kwargs)
|
||
#
|
||
# # 检查是否是异步函数并等待结果
|
||
# import inspect
|
||
# if inspect.iscoroutine(result_value):
|
||
# import asyncio
|
||
# result_value = await result_value
|
||
#
|
||
# logger.info(f"函数 {function_name} 执行结果: {result_value}")
|
||
#
|
||
# # 设置返回值到上下文 - 与ScriptBp不同，这里会更新所有变量
|
||
# if isinstance(result_value, dict):
|
||
# # 如果返回值是字典，将字典中的每个键值对设置为任务变量
|
||
# for key, value in result_value.items():
|
||
# context.set_variable(key, value)
|
||
#
|
||
# result_message = f"脚本函数 {function_name} 执行成功，已更新 {len(result_value)} 个变量"
|
||
# else:
|
||
# # 如果返回值不是字典，将整个返回值设置为scriptResult变量
|
||
# context.set_variable("scriptResult", result_value)
|
||
# result_message = f"脚本函数 {function_name} 执行成功，结果已保存为scriptResult变量"
|
||
#
|
||
# # 构建成功结果
|
||
# return {
|
||
# "success": True,
|
||
# "message": result_message,
|
||
# "output": {
|
||
# "result": result_value,
|
||
# "functionName": function_name
|
||
# }
|
||
# }
|
||
#
|
||
# except Exception as e:
|
||
# logger.error(f"执行脚本函数时发生异常: {str(e)}", exc_info=True)
|
||
# return {
|
||
# "success": False,
|
||
# "message": f"执行脚本函数 {function_name} 失败: {str(e)}"
|
||
# }
|
||
#
|
||
# async def _save_variables_to_database(self, context: TaskContext) -> None:
|
||
# """
|
||
# 将任务变量保存到数据库的任务记录中
|
||
#
|
||
# Args:
|
||
# context: 任务上下文
|
||
# """
|
||
# try:
|
||
# from sqlalchemy import update
|
||
# from data.models.taskrecord import VWEDTaskRecord
|
||
# from data.session import get_async_session
|
||
# import json
|
||
#
|
||
# # 获取任务记录ID
|
||
# task_record_id = context.task_record_id
|
||
#
|
||
# if not task_record_id:
|
||
# logger.error("无法保存变量，任务记录ID为空")
|
||
# return
|
||
#
|
||
# # 将任务变量转换为JSON字符串
|
||
# variables_json = json.dumps(context.variables, ensure_ascii=False)
|
||
#
|
||
# # 更新数据库记录
|
||
# async with get_async_session() as session:
|
||
# stmt = update(VWEDTaskRecord).where(VWEDTaskRecord.id == task_record_id).values(
|
||
# variables=variables_json
|
||
# )
|
||
# await session.execute(stmt)
|
||
# await session.commit()
|
||
#
|
||
# logger.info(f"已将任务变量保存到数据库记录 {task_record_id}")
|
||
#
|
||
# except Exception as e:
|
||
# logger.error(f"保存任务变量到数据库失败: {str(e)}")
|
||
#
|
||
# # 脚本块处理器
|
||
# @register_handler("ScriptBp")
|
||
# class ScriptBlockHandler(BlockHandler):
|
||
# """脚本块处理器"""
|
||
#
|
||
# async def execute(
|
||
# self,
|
||
# block: Dict[str, Any],
|
||
# input_params: Dict[str, Any],
|
||
# context: TaskContext
|
||
# ) -> Dict[str, Any]:
|
||
# """执行脚本块"""
|
||
# try:
|
||
# # 获取函数名和参数
|
||
# function_name = input_params.get("functionName")
|
||
# function_args = input_params.get("functionArgs", {})
|
||
#
|
||
# if not function_name:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": "缺少函数名"
|
||
# }
|
||
# # 记录执行结果
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# # 调用脚本执行方法
|
||
# exec_result = await self._execute_script(function_name, function_args, context)
|
||
#
|
||
# # 记录执行结果
|
||
# await self._record_task_log(block, exec_result, context)
|
||
# return exec_result
|
||
# except Exception as e:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": f"脚本执行失败: {str(e)}"
|
||
# }
|
||
# # 记录异常
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# async def _execute_script(
|
||
# self,
|
||
# function_name: str,
|
||
# function_args: Any,
|
||
# context: TaskContext
|
||
# ) -> Dict[str, Any]:
|
||
# """
|
||
# 执行指定的脚本函数
|
||
#
|
||
# Args:
|
||
# function_name: 要执行的函数名
|
||
# function_args: 函数参数
|
||
# context: 任务上下文
|
||
#
|
||
# Returns:
|
||
# Dict[str, Any]: 执行结果
|
||
# """
|
||
# # 固定加载scripts/user_save/test1.py文件
|
||
# script_file = r"D:\jsw_code\project\VWED_task\scripts\user_save\test1.py"
|
||
# logger.info(f"正在加载脚本文件: {script_file}")
|
||
#
|
||
# try:
|
||
# # 动态加载脚本模块
|
||
# import importlib.util
|
||
# import sys
|
||
# import os
|
||
#
|
||
# # 检查文件是否存在
|
||
# if not os.path.exists(script_file):
|
||
# return {
|
||
# "success": False,
|
||
# "message": f"脚本文件不存在: {script_file}"
|
||
# }
|
||
#
|
||
# # 加载模块
|
||
# spec = importlib.util.spec_from_file_location("user_script", script_file)
|
||
# if not spec:
|
||
# return {
|
||
# "success": False,
|
||
# "message": f"无法加载脚本规范: {script_file}"
|
||
# }
|
||
# module = importlib.util.module_from_spec(spec)
|
||
# sys.modules["user_script"] = module
|
||
# spec.loader.exec_module(module)
|
||
# # 检查函数是否存在
|
||
# if not hasattr(module, function_name):
|
||
# return {
|
||
# "success": False,
|
||
# "message": f"函数 {function_name} 在脚本 {script_file} 中不存在"
|
||
# }
|
||
# # 获取函数对象
|
||
# func = getattr(module, function_name)
|
||
#
|
||
# # 准备函数参数（处理不同类型的参数传递方式）
|
||
# args = []
|
||
# kwargs = {}
|
||
#
|
||
# # 如果function_args是字典，将其作为关键字参数传递
|
||
# if isinstance(function_args, dict):
|
||
# kwargs = function_args
|
||
# # 如果function_args是列表，将其作为位置参数传递
|
||
# elif isinstance(function_args, list):
|
||
# args = function_args
|
||
# # 如果function_args是其他类型，将其作为单个位置参数传递
|
||
# elif function_args is not None:
|
||
# args = [function_args]
|
||
#
|
||
# # 调用函数
|
||
# logger.info(f"调用函数 {function_name} 参数: args={args}, kwargs={kwargs}")
|
||
# result_value = func(*args, **kwargs)
|
||
#
|
||
# # 检查是否是异步函数并等待结果
|
||
# import inspect
|
||
# if inspect.iscoroutine(result_value):
|
||
# import asyncio
|
||
# result_value = await result_value
|
||
#
|
||
# logger.info(f"函数 {function_name} 执行结果: {result_value}")
|
||
#
|
||
# # 设置返回值到上下文
|
||
# context.set_variable("scriptResult", result_value)
|
||
#
|
||
# # 构建成功结果
|
||
# return {
|
||
# "success": True,
|
||
# "message": f"脚本函数 {function_name} 执行成功",
|
||
# "output": {
|
||
# "result": result_value,
|
||
# "functionName": function_name
|
||
# }
|
||
# }
|
||
#
|
||
# except Exception as e:
|
||
# logger.error(f"执行脚本函数时发生异常: {str(e)}", exc_info=True)
|
||
# return {
|
||
# "success": False,
|
||
# "message": f"执行脚本函数 {function_name} 失败: {str(e)}"
|
||
# }
|
||
|
||
# 打印块处理器
|
||
@register_handler("PrintBp")
|
||
class PrintBlockHandler(BlockHandler):
|
||
"""打印块处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行打印块"""
|
||
try:
|
||
# 获取消息参数
|
||
message = input_params.get("message", "")
|
||
|
||
# 记录日志
|
||
logger.info(f"任务 {context.task_record_id} 打印: {message}")
|
||
|
||
# 返回结果
|
||
result = {
|
||
"success": True,
|
||
"message": "打印成功",
|
||
"output": {
|
||
"message": message
|
||
}
|
||
}
|
||
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"打印失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 条件判断块处理器
|
||
@register_handler("IfBp")
|
||
class IfBlockHandler(BlockHandler):
|
||
"""条件判断块处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行条件判断块"""
|
||
try:
|
||
# 获取条件参数
|
||
condition = input_params.get("condition")
|
||
|
||
# 判断条件
|
||
result = bool(condition)
|
||
|
||
# 创建块执行器
|
||
from services.execution.block_executor import BlockExecutor
|
||
executor = BlockExecutor(context)
|
||
|
||
# 检查块中所有可用的分支
|
||
children = block.get("children", {})
|
||
has_true_branch = "true" in children and children["true"]
|
||
has_false_branch = "false" in children and children["false"]
|
||
has_default_branch = "default" in children and children["default"]
|
||
|
||
logger.info(f"条件判断块执行 - ID: {block.get('id')}, 条件结果: {result}")
|
||
logger.info(f"可用分支情况 - true分支: {has_true_branch}, false分支: {has_false_branch}, default分支: {has_default_branch}")
|
||
# 根据条件执行不同分支
|
||
if result:
|
||
# 条件为真，优先执行true分支，如果没有则尝试执行default分支
|
||
if has_true_branch:
|
||
logger.info(f"条件为真，执行true分支")
|
||
branch_name = "true"
|
||
elif has_default_branch:
|
||
logger.info(f"条件为真但无true分支，执行default分支")
|
||
branch_name = "default"
|
||
else:
|
||
logger.info(f"条件为真但无可执行分支")
|
||
exec_result = {
|
||
"success": True,
|
||
"message": "条件为真，但没有找到true或default分支",
|
||
"output": {
|
||
"condition": result,
|
||
"branch": "none",
|
||
"executed": False
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, exec_result, context)
|
||
return exec_result
|
||
else:
|
||
# 条件为假，优先执行false分支
|
||
if has_false_branch:
|
||
logger.info(f"条件为假，执行false分支")
|
||
branch_name = "false"
|
||
else:
|
||
logger.info(f"条件为假且无false分支，不执行任何分支")
|
||
exec_result = {
|
||
"success": True,
|
||
"message": "条件为假，没有找到false分支",
|
||
"output": {
|
||
"condition": result,
|
||
"branch": "none",
|
||
"executed": False
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, exec_result, context)
|
||
return exec_result
|
||
# 执行选定的分支
|
||
if branch_name:
|
||
branch_result = await executor.execute_children(block, branch_name)
|
||
if not branch_result.get("success", False):
|
||
logger.error(f"分支 {branch_name} 执行失败: {branch_result.get('message')}")
|
||
# 记录执行结果
|
||
await self._record_task_log(block, branch_result, context)
|
||
return branch_result
|
||
|
||
logger.info(f"分支 {branch_name} 执行成功")
|
||
exec_result = {
|
||
"success": True,
|
||
"message": f"条件判断成功，执行{branch_name}分支完成",
|
||
"output": {
|
||
"condition": result,
|
||
"branch": branch_name,
|
||
"executed": True
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, exec_result, context)
|
||
return exec_result
|
||
|
||
# 正常情况不应该到达这里
|
||
exec_result = {
|
||
"success": True,
|
||
"message": "条件判断完成，未执行任何分支",
|
||
"output": {
|
||
"condition": result,
|
||
"branch": "none",
|
||
"executed": False
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, exec_result, context)
|
||
return exec_result
|
||
except Exception as e:
|
||
logger.error(f"条件判断执行异常: {str(e)}")
|
||
exec_result = {
|
||
"success": False,
|
||
"message": f"条件判断失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, exec_result, context)
|
||
return exec_result
|
||
|
||
# 循环块处理器
|
||
@register_handler("WhileBp")
|
||
class WhileBlockHandler(BlockHandler):
|
||
"""循环块处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行循环块"""
|
||
try:
|
||
# 获取循环条件和相关配置
|
||
loop_condition = input_params.get("loopCondition", False)
|
||
run_once = input_params.get("runOnce", False) # 是否至少执行一次
|
||
retry_period = input_params.get("retryPeriod", 0) # 循环间隔(毫秒)
|
||
print_continuously = input_params.get("printContinuously", False) # 是否持续打印日志
|
||
|
||
# 设置最大迭代次数，防止无限循环
|
||
max_iterations = 1000
|
||
iterations = 0
|
||
|
||
# 创建块执行器
|
||
from services.execution.block_executor import BlockExecutor
|
||
executor = BlockExecutor(context)
|
||
|
||
# 检查是否至少需要执行一次
|
||
if run_once:
|
||
# 执行一次循环体，无论条件是否满足
|
||
logger.info(f"执行while循环体(至少执行一次模式)")
|
||
branch_result = await executor.execute_children(block, "default")
|
||
if not branch_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, branch_result, context)
|
||
return branch_result
|
||
iterations += 1
|
||
|
||
# 根据条件循环执行
|
||
while loop_condition and iterations < max_iterations:
|
||
# 检查是否取消
|
||
if context.is_task_canceled():
|
||
result = {
|
||
"success": False,
|
||
"message": "任务已被取消"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 检查是否有中断或返回信号
|
||
if context.get_variable("__BREAK__", False):
|
||
logger.info(f"检测到中断信号，提前结束循环，已完成 {iterations} 次")
|
||
context.set_variable("__BREAK__", False) # 重置中断信号
|
||
break
|
||
|
||
if context.get_variable("__RETURN__", False):
|
||
logger.info(f"检测到返回信号，提前结束循环，已完成 {iterations} 次")
|
||
# 不重置返回信号，它需要向上传播
|
||
break
|
||
|
||
# 如果不是第一次执行且有重试间隔，则等待
|
||
if iterations > 0 and retry_period > 0:
|
||
import asyncio
|
||
await asyncio.sleep(retry_period / 1000)
|
||
|
||
# 执行循环体
|
||
if print_continuously or iterations == 0:
|
||
logger.info(f"执行while循环体，第 {iterations+1} 次迭代")
|
||
|
||
branch_result = await executor.execute_children(block, "default")
|
||
if not branch_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, branch_result, context)
|
||
return branch_result
|
||
|
||
iterations += 1
|
||
|
||
# 重新获取循环条件
|
||
loop_condition = input_params.get("loopCondition", False)
|
||
|
||
# 检查是否达到最大迭代次数
|
||
if iterations >= max_iterations:
|
||
logger.warning(f"循环达到最大迭代次数 {max_iterations}，可能存在无限循环")
|
||
result = {
|
||
"success": False,
|
||
"message": f"循环达到最大迭代次数 {max_iterations}，可能存在无限循环"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 循环结束后，执行exit分支
|
||
if "exit" in block.get("children", {}) and block["children"]["exit"]:
|
||
logger.info(f"循环结束，执行exit分支")
|
||
exit_result = await executor.execute_children(block, "exit")
|
||
if not exit_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, exit_result, context)
|
||
return exit_result
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": f"循环执行成功，共执行 {iterations} 次",
|
||
"output": {
|
||
"iterations": iterations
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"循环执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 等待块处理器
|
||
@register_handler("WaitBp")
|
||
class WaitBlockHandler(BlockHandler):
|
||
"""等待块处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行等待块"""
|
||
import asyncio
|
||
|
||
try:
|
||
# 获取等待时间参数（毫秒）
|
||
timeout = input_params.get("timeout", 1000)
|
||
|
||
# 转换为秒
|
||
timeout_sec = timeout / 1000
|
||
|
||
# 等待
|
||
await asyncio.sleep(timeout_sec)
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": f"等待 {timeout} 毫秒完成",
|
||
"output": {
|
||
"timeout": timeout
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"等待执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
|
||
|
||
# 添加HTTP请求相关处理器
|
||
|
||
# HTTP GET请求处理器
|
||
# @register_handler("GetBp")
|
||
# class HttpGetBlockHandler(BlockHandler):
|
||
# """HTTP GET请求处理器"""
|
||
#
|
||
# async def execute(
|
||
# self,
|
||
# block: Dict[str, Any],
|
||
# input_params: Dict[str, Any],
|
||
# context: TaskContext
|
||
# ) -> Dict[str, Any]:
|
||
# """执行HTTP GET请求"""
|
||
# import aiohttp
|
||
# import asyncio
|
||
# import json
|
||
#
|
||
# try:
|
||
# # 获取请求参数
|
||
# url = input_params.get("url")
|
||
#
|
||
# # 处理headers参数
|
||
# headers = {}
|
||
# header_param = input_params.get("header", {})
|
||
#
|
||
# # 如果header是字符串，尝试解析JSON
|
||
# if isinstance(header_param, str):
|
||
# try:
|
||
# header_data = json.loads(header_param)
|
||
# # 检查解析后的数据是否为列表格式 [{"key0":"value0", "value0":"value"}, ...]
|
||
# if isinstance(header_data, list):
|
||
# for item in header_data:
|
||
# # 寻找以key开头的键，如key0, key1等
|
||
# for key in [k for k in item if k.startswith('key')]:
|
||
# if key in item and item[key]:
|
||
# # 对应的value键应该是value0, value1等
|
||
# value_key = 'value' + key[3:]
|
||
# if value_key in item and item[value_key]:
|
||
# headers[item[key]] = item[value_key]
|
||
# # 如果是字典格式，直接使用
|
||
# elif isinstance(header_data, dict):
|
||
# headers = header_data
|
||
# except json.JSONDecodeError:
|
||
# logger.warning(f"无法解析headers JSON: {header_param}")
|
||
# elif isinstance(header_param, dict):
|
||
# headers = header_param
|
||
#
|
||
# retry = input_params.get("retry", False)
|
||
#
|
||
# # 确保retry_times为整数
|
||
# retry_times = input_params.get("retryTimes", 3)
|
||
# if isinstance(retry_times, str):
|
||
# try:
|
||
# retry_times = int(retry_times)
|
||
# except ValueError:
|
||
# retry_times = 3
|
||
#
|
||
# # 确保retry_interval为整数
|
||
# retry_interval = input_params.get("retryInterval", 1000)
|
||
# if isinstance(retry_interval, str):
|
||
# try:
|
||
# retry_interval = int(retry_interval)
|
||
# except ValueError:
|
||
# retry_interval = 1000
|
||
#
|
||
# if not url:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": "缺少请求URL"
|
||
# }
|
||
# # 记录执行结果
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# # 执行HTTP请求
|
||
# attempt = 0
|
||
# max_attempts = 1 if not retry else retry_times + 1
|
||
#
|
||
# while attempt < max_attempts:
|
||
# try:
|
||
# async with aiohttp.ClientSession() as session:
|
||
# async with session.get(url, headers=headers) as response:
|
||
# # 读取响应内容
|
||
# response_text = await response.text()
|
||
#
|
||
# # 尝试解析JSON
|
||
# try:
|
||
# response_json = await response.json()
|
||
# context.set_variable("response", response_json)
|
||
# except:
|
||
# # 不是有效的JSON，保存为文本
|
||
# context.set_variable("response", response_text)
|
||
#
|
||
# result = {
|
||
# "success": True,
|
||
# "message": f"HTTP GET请求成功，状态码: {response.status}",
|
||
# }
|
||
# # 记录执行结果
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
# except Exception as e:
|
||
# attempt += 1
|
||
# if attempt >= max_attempts:
|
||
# raise
|
||
#
|
||
# # 重试间隔
|
||
# await asyncio.sleep(retry_interval / 1000)
|
||
#
|
||
# except Exception as e:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": f"HTTP GET请求失败: {str(e)}"
|
||
# }
|
||
# # 记录异常
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# # HTTP POST请求处理器
|
||
# @register_handler("PostBp")
|
||
# class HttpPostBlockHandler(BlockHandler):
|
||
# """HTTP POST请求处理器"""
|
||
#
|
||
# async def execute(
|
||
# self,
|
||
# block: Dict[str, Any],
|
||
# input_params: Dict[str, Any],
|
||
# context: TaskContext
|
||
# ) -> Dict[str, Any]:
|
||
# """执行HTTP POST请求"""
|
||
# import aiohttp
|
||
# import asyncio
|
||
# import json
|
||
#
|
||
# try:
|
||
# # 获取请求参数
|
||
# url = input_params.get("url")
|
||
# params = input_params.get("param", "{}")
|
||
#
|
||
# # 处理headers参数
|
||
# headers = {}
|
||
# header_param = input_params.get("header", {})
|
||
#
|
||
# # 如果header是字符串，尝试解析JSON
|
||
# if isinstance(header_param, str):
|
||
# try:
|
||
# header_data = json.loads(header_param)
|
||
# # 检查解析后的数据是否为列表格式 [{"key0":"value0", "value0":"value"}, ...]
|
||
# if isinstance(header_data, list):
|
||
# for item in header_data:
|
||
# # 寻找以key开头的键，如key0, key1等
|
||
# for key in [k for k in item if k.startswith('key')]:
|
||
# if key in item and item[key]:
|
||
# # 对应的value键应该是value0, value1等
|
||
# value_key = 'value' + key[3:]
|
||
# if value_key in item and item[value_key]:
|
||
# headers[item[key]] = item[value_key]
|
||
# # 如果是字典格式，直接使用
|
||
# elif isinstance(header_data, dict):
|
||
# headers = header_data
|
||
# except json.JSONDecodeError:
|
||
# logger.warning(f"无法解析headers JSON: {header_param}")
|
||
# elif isinstance(header_param, dict):
|
||
# headers = header_param
|
||
#
|
||
# media_type = input_params.get("mediaType", "JSON")
|
||
# retry = input_params.get("retry", False)
|
||
#
|
||
# # 确保retry_times为整数
|
||
# retry_times = input_params.get("retryTimes", 3)
|
||
# if isinstance(retry_times, str):
|
||
# try:
|
||
# retry_times = int(retry_times)
|
||
# except ValueError:
|
||
# retry_times = 3
|
||
#
|
||
# # 确保retry_interval为整数
|
||
# retry_interval = input_params.get("retryInterval", 1000)
|
||
# if isinstance(retry_interval, str):
|
||
# try:
|
||
# retry_interval = int(retry_interval)
|
||
# except ValueError:
|
||
# retry_interval = 1000
|
||
#
|
||
# if not url:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": "缺少请求URL"
|
||
# }
|
||
# # 记录执行结果
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# # 准备请求数据
|
||
# try:
|
||
# if isinstance(params, str):
|
||
# data = json.loads(params)
|
||
# else:
|
||
# data = params
|
||
# except:
|
||
# data = params # 如果无法解析为JSON，使用原始字符串
|
||
#
|
||
# # 设置Content-Type
|
||
# content_type = "application/json"
|
||
# if media_type == "HTML":
|
||
# content_type = "text/html"
|
||
# elif media_type == "XML":
|
||
# content_type = "application/xml"
|
||
# elif media_type == "XWWWFORMURLENCODED":
|
||
# content_type = "application/x-www-form-urlencoded"
|
||
# elif media_type == "JAVASCRIPT":
|
||
# content_type = "application/javascript"
|
||
#
|
||
# if "Content-Type" not in headers:
|
||
# headers["Content-Type"] = content_type
|
||
#
|
||
# # 执行HTTP请求
|
||
# attempt = 0
|
||
# max_attempts = 1 if not retry else retry_times + 1
|
||
# while attempt < max_attempts:
|
||
# try:
|
||
# async with aiohttp.ClientSession() as session:
|
||
# async with session.post(url, json=data, headers=headers) as response:
|
||
# # 读取响应内容
|
||
# response_text = await response.text()
|
||
#
|
||
# # 尝试解析JSON
|
||
# try:
|
||
# response_json = await response.json()
|
||
# context.set_variable("response", response_json)
|
||
# except:
|
||
# # 不是有效的JSON，保存为文本
|
||
# context.set_variable("response", response_text)
|
||
#
|
||
# result = {
|
||
# "success": True,
|
||
# "message": f"HTTP POST请求成功，状态码: {response.status}, 响应内容详情: {response_text}",
|
||
# }
|
||
# # 记录执行结果
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
# except Exception as e:
|
||
# attempt += 1
|
||
# if attempt >= max_attempts:
|
||
# raise
|
||
#
|
||
# # 重试间隔
|
||
# await asyncio.sleep(retry_interval / 1000)
|
||
#
|
||
# except Exception as e:
|
||
# result = {
|
||
# "success": False,
|
||
# "message": f"HTTP POST请求失败: {str(e)}"
|
||
# }
|
||
# # 记录异常
|
||
# await self._record_task_log(block, result, context)
|
||
# return result
|
||
#
|
||
# 添加基础模块处理器
|
||
|
||
# 创建唯一ID处理器
|
||
@register_handler("CreateUuidBp")
|
||
class CreateUuidBlockHandler(BlockHandler):
|
||
"""创建唯一ID处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""创建唯一ID"""
|
||
import uuid
|
||
|
||
try:
|
||
# 生成UUID
|
||
generated_uuid = str(uuid.uuid4())
|
||
|
||
# 设置上下文变量
|
||
result = {
|
||
"success": True,
|
||
"message": "创建唯一ID成功",
|
||
"output": {
|
||
"uuid": generated_uuid,
|
||
|
||
}
|
||
}
|
||
context.set_block_output(block.get("name"), {"uuid": generated_uuid})
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"创建唯一ID失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 当前时间戳处理器
|
||
@register_handler("CurrentTimeStampBp")
|
||
class CurrentTimeStampBlockHandler(BlockHandler):
|
||
"""当前时间戳处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""获取当前时间戳"""
|
||
import time
|
||
|
||
try:
|
||
# 获取当前时间戳(毫秒)
|
||
current_timestamp = int(time.time() * 1000)
|
||
|
||
# 设置上下文变量
|
||
context.set_variable("currentTimeStamp", current_timestamp)
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "获取当前时间戳成功",
|
||
"output": {
|
||
"timestamp": current_timestamp
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"获取当前时间戳失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 当前时间处理器
|
||
@register_handler("TimestampBp")
|
||
class TimestampBlockHandler(BlockHandler):
|
||
"""当前时间处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""获取当前时间"""
|
||
from datetime import datetime
|
||
|
||
try:
|
||
# 获取当前时间
|
||
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||
|
||
# 设置上下文变量
|
||
context.set_variable("timestamp", current_time)
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "获取当前时间成功",
|
||
"output": {
|
||
"timestamp": current_time
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"获取当前时间失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 字符串转JSON对象处理器
|
||
@register_handler("StringToJsonObjectBp")
|
||
class StringToJsonObjectBlockHandler(BlockHandler):
|
||
"""字符串转JSON对象处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""将字符串转换为JSON对象"""
|
||
import json
|
||
|
||
try:
|
||
# 获取输入参数
|
||
convert_string = input_params.get("convertString", "")
|
||
|
||
if not convert_string:
|
||
result = {
|
||
"success": False,
|
||
"message": "转换字符串为空"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 转换为JSON对象
|
||
json_object = json.loads(convert_string)
|
||
|
||
# 设置输出参数
|
||
output = {
|
||
"convertObject": json_object
|
||
}
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "字符串转换为JSON对象成功",
|
||
"output": output
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except json.JSONDecodeError as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"字符串解析为JSON对象失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"字符串转换为JSON对象失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 字符串转JSON数组处理器
|
||
@register_handler("StringToJsonArrayBp")
|
||
class StringToJsonArrayBlockHandler(BlockHandler):
|
||
"""字符串转JSON数组处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""将字符串转换为JSON数组"""
|
||
import json
|
||
|
||
try:
|
||
# 获取输入参数
|
||
convert_string = input_params.get("convertString", "")
|
||
|
||
if not convert_string:
|
||
result = {
|
||
"success": False,
|
||
"message": "转换字符串为空"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 转换为JSON数组
|
||
json_array = json.loads(convert_string)
|
||
|
||
# 验证是否为数组
|
||
if not isinstance(json_array, list):
|
||
result = {
|
||
"success": False,
|
||
"message": "转换结果不是JSON数组"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 设置输出参数
|
||
output = {
|
||
"convertArray": json_array
|
||
}
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "字符串转换为JSON数组成功",
|
||
"output": output
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except json.JSONDecodeError as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"字符串解析为JSON数组失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"字符串转换为JSON数组失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 添加流程控制模块处理器
|
||
|
||
# If-Else处理器
|
||
@register_handler("IfElseBp")
|
||
class IfElseBlockHandler(BlockHandler):
|
||
"""If-Else处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行If-Else条件判断块"""
|
||
try:
|
||
# 获取条件参数
|
||
condition = input_params.get("conditionIf")
|
||
|
||
# 创建块执行器
|
||
from services.execution.block_executor import BlockExecutor
|
||
executor = BlockExecutor(context)
|
||
|
||
# 根据条件执行不同分支
|
||
if condition:
|
||
# 执行if分支
|
||
branch_result = await executor.execute_children(block, "if")
|
||
if not branch_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, branch_result, context)
|
||
return branch_result
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "条件为真，执行if分支成功",
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
else:
|
||
# 执行else分支
|
||
branch_result = await executor.execute_children(block, "else")
|
||
if not branch_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, branch_result, context)
|
||
return branch_result
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "条件为假，执行else分支成功",
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"If-Else条件判断执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# If-Else-If处理器
|
||
@register_handler("IfElseIfBp")
|
||
class IfElseIfBlockHandler(BlockHandler):
|
||
"""If-Else-If处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行If-Else-If条件判断块"""
|
||
try:
|
||
# 获取条件参数
|
||
condition_if = input_params.get("conditionIf")
|
||
condition_else_if = input_params.get("conditionElseIf")
|
||
|
||
# 创建块执行器
|
||
from services.execution.block_executor import BlockExecutor
|
||
executor = BlockExecutor(context)
|
||
|
||
# 根据条件执行不同分支
|
||
if condition_if:
|
||
# 执行if分支
|
||
branch_result = await executor.execute_children(block, "if")
|
||
if not branch_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, branch_result, context)
|
||
return branch_result
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "条件if为真，执行if分支成功",
|
||
"output": {
|
||
"condition": "if",
|
||
"branch": "if"
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
elif condition_else_if:
|
||
# 执行else_if分支
|
||
branch_result = await executor.execute_children(block, "else_if")
|
||
if not branch_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, branch_result, context)
|
||
return branch_result
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "条件else-if为真，执行else-if分支成功",
|
||
"output": {
|
||
"condition": "else_if",
|
||
"branch": "else_if"
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
else:
|
||
# 执行else分支
|
||
branch_result = await executor.execute_children(block, "else")
|
||
if not branch_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, branch_result, context)
|
||
return branch_result
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "所有条件为假，执行else分支成功",
|
||
"output": {
|
||
"condition": "else",
|
||
"branch": "else"
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"If-Else-If条件判断执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 遍历数组处理器
|
||
@register_handler("IterateListBp")
|
||
class IterateListBlockHandler(BlockHandler):
|
||
"""遍历数组处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行数组遍历块"""
|
||
try:
|
||
# 获取数组参数
|
||
array_data = input_params.get("list", [])
|
||
|
||
# 如果不是数组，尝试转换
|
||
if not isinstance(array_data, list):
|
||
import json
|
||
try:
|
||
if isinstance(array_data, str):
|
||
array_data = json.loads(array_data)
|
||
else:
|
||
result = {
|
||
"success": False,
|
||
"message": "提供的参数不是有效的数组"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except:
|
||
result = {
|
||
"success": False,
|
||
"message": "提供的参数无法解析为数组"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 创建块执行器
|
||
from services.execution.block_executor import BlockExecutor
|
||
executor = BlockExecutor(context)
|
||
|
||
# 遍历数组
|
||
results = []
|
||
for index, item in enumerate(array_data):
|
||
# 检查是否取消
|
||
if context.is_task_canceled():
|
||
result = {
|
||
"success": False,
|
||
"message": "任务已被取消"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 设置循环变量
|
||
context.set_variable("index", index)
|
||
context.set_variable("item", item)
|
||
|
||
# 执行循环体
|
||
loop_result = await executor.execute_children(block, "default")
|
||
|
||
# 收集结果
|
||
results.append({
|
||
"index": index,
|
||
"success": loop_result.get("success", False),
|
||
"result": loop_result
|
||
})
|
||
|
||
# 如果执行失败，提前退出
|
||
if not loop_result.get("success", False):
|
||
result = {
|
||
"success": False,
|
||
"message": f"数组遍历在索引 {index} 处执行失败",
|
||
"output": {
|
||
"iterationResults": results,
|
||
"failedAt": index
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": f"数组遍历成功，遍历了 {len(array_data)} 个元素",
|
||
"output": {
|
||
"iterationResults": results,
|
||
"count": len(array_data)
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"数组遍历执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 延迟处理器
|
||
@register_handler("DelayBp")
|
||
class DelayBlockHandler(BlockHandler):
|
||
"""延迟处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行延迟块"""
|
||
import asyncio
|
||
|
||
try:
|
||
# 获取延迟时间参数（毫秒）
|
||
delay_time = input_params.get("timeMillis", 1000)
|
||
|
||
# 转换为秒
|
||
delay_sec = delay_time / 1000
|
||
|
||
# 等待
|
||
await asyncio.sleep(delay_sec)
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": f"延迟 {delay_time} 毫秒完成",
|
||
"output": {
|
||
"delayTime": delay_time
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"延迟执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# Break处理器
|
||
@register_handler("BreakBp")
|
||
class BreakBlockHandler(BlockHandler):
|
||
"""Break处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行break块，用于跳出循环"""
|
||
try:
|
||
# 设置上下文中的break标志
|
||
context.set_variable("__BREAK__", True)
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "Break执行成功，将跳出当前循环",
|
||
"output": {
|
||
"breakSignal": True
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"Break执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 添加数据库操作相关处理器
|
||
|
||
# 执行SQL处理器
|
||
@register_handler("JdbcExecuteBp")
|
||
class JdbcExecuteBlockHandler(BlockHandler):
|
||
"""执行SQL处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行SQL语句"""
|
||
from sqlalchemy import text
|
||
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
|
||
from sqlalchemy.orm import sessionmaker
|
||
import os
|
||
|
||
try:
|
||
# 获取SQL语句
|
||
sql = input_params.get("sql")
|
||
|
||
if not sql:
|
||
result = {
|
||
"success": False,
|
||
"message": "缺少SQL语句"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 获取数据库连接信息
|
||
# 通常从配置中获取，这里简化使用环境变量或默认值
|
||
db_url = os.environ.get("DATABASE_URL", "sqlite+aiosqlite:///database.db")
|
||
|
||
# 创建异步引擎和会话
|
||
engine = create_async_engine(db_url)
|
||
async_session = sessionmaker(
|
||
engine, expire_on_commit=False, class_=AsyncSession
|
||
)
|
||
|
||
# 执行SQL
|
||
async with async_session() as session:
|
||
result = await session.execute(text(sql))
|
||
await session.commit()
|
||
|
||
# 获取受影响的行数
|
||
row_count = result.rowcount if hasattr(result, 'rowcount') else 0
|
||
|
||
exec_result = {
|
||
"success": True,
|
||
"message": f"SQL执行成功，影响了 {row_count} 行",
|
||
"output": {
|
||
"rowCount": row_count
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, exec_result, context)
|
||
return exec_result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"SQL执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 查询SQL处理器
|
||
@register_handler("JdbcQueryBp")
|
||
class JdbcQueryBlockHandler(BlockHandler):
|
||
"""查询SQL处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行SQL查询"""
|
||
from sqlalchemy import text
|
||
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
|
||
from sqlalchemy.orm import sessionmaker
|
||
import os
|
||
import json
|
||
|
||
try:
|
||
# 获取SQL语句
|
||
sql = input_params.get("sql")
|
||
|
||
if not sql:
|
||
return {
|
||
"success": False,
|
||
"message": "缺少SQL语句"
|
||
}
|
||
|
||
# 获取数据库连接信息
|
||
# 通常从配置中获取，这里简化使用环境变量或默认值
|
||
db_url = os.environ.get("DATABASE_URL", "sqlite+aiosqlite:///database.db")
|
||
|
||
# 创建异步引擎和会话
|
||
engine = create_async_engine(db_url)
|
||
async_session = sessionmaker(
|
||
engine, expire_on_commit=False, class_=AsyncSession
|
||
)
|
||
|
||
# 执行SQL查询
|
||
async with async_session() as session:
|
||
result = await session.execute(text(sql))
|
||
|
||
# 处理结果
|
||
if result.returns_rows:
|
||
# 获取列名
|
||
columns = result.keys()
|
||
|
||
# 转换为字典列表
|
||
rows = [dict(zip(columns, row)) for row in result.fetchall()]
|
||
|
||
# 转换为JSON字符串
|
||
result_json = json.dumps(rows)
|
||
|
||
# 设置上下文变量
|
||
context.set_variable("resultSet", result_json)
|
||
|
||
exec_result = {
|
||
"success": True,
|
||
"message": f"SQL查询成功，返回 {len(rows)} 条记录",
|
||
"output": {
|
||
"rowCount": len(rows),
|
||
"resultSet": rows,
|
||
"resultJson": result_json
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, exec_result, context)
|
||
return exec_result
|
||
else:
|
||
# 非查询语句，没有返回行
|
||
context.set_variable("resultSet", "[]")
|
||
|
||
exec_result = {
|
||
"success": True,
|
||
"message": "SQL执行成功，没有返回数据",
|
||
"output": {
|
||
"rowCount": 0,
|
||
"resultSet": [],
|
||
"resultJson": "[]"
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, exec_result, context)
|
||
return exec_result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"SQL查询失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 检查任务实例ID是否存在处理器
|
||
@register_handler("CheckTaskRecordIdIsExistBp")
|
||
class CheckTaskRecordIdIsExistBlockHandler(BlockHandler):
|
||
"""检查任务实例ID是否存在处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""检查任务记录ID是否存在"""
|
||
from sqlalchemy import text, select
|
||
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
|
||
from sqlalchemy.orm import sessionmaker
|
||
from data.models import VWEDTaskRecord
|
||
import os
|
||
|
||
try:
|
||
# 获取任务记录ID
|
||
task_record_id = input_params.get("taskRecordId")
|
||
|
||
if not task_record_id:
|
||
result = {
|
||
"success": False,
|
||
"message": "缺少任务记录ID"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 获取数据库连接信息
|
||
# 通常从配置中获取，这里简化使用环境变量或默认值
|
||
db_url = os.environ.get("DATABASE_URL", "sqlite+aiosqlite:///database.db")
|
||
|
||
# 创建异步引擎和会话
|
||
engine = create_async_engine(db_url)
|
||
async_session = sessionmaker(
|
||
engine, expire_on_commit=False, class_=AsyncSession
|
||
)
|
||
|
||
# 查询任务记录
|
||
async with async_session() as session:
|
||
query = select(VWEDTaskRecord).where(VWEDTaskRecord.id == task_record_id)
|
||
result = await session.execute(query)
|
||
record = result.scalar_one_or_none()
|
||
|
||
exists = record is not None
|
||
|
||
# 设置上下文变量
|
||
context.set_variable("taskRecordIdIsExist", exists)
|
||
|
||
exec_result = {
|
||
"success": True,
|
||
"message": f"任务记录ID {'存在' if exists else '不存在'}",
|
||
"output": {
|
||
"exists": exists,
|
||
"taskRecordId": task_record_id
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, exec_result, context)
|
||
return exec_result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"检查任务记录ID是否存在失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 增强现有脚本处理器和添加脚本变量处理器
|
||
|
||
# 返回块处理器
|
||
@register_handler("ReturnBp")
|
||
class ReturnBlockHandler(BlockHandler):
|
||
"""Return处理器，用于提前返回结果"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""执行return块，用于提前返回流程执行结果"""
|
||
try:
|
||
# 设置上下文中的return标志
|
||
context.set_variable("__RETURN__", True)
|
||
|
||
# 获取可能的返回数据
|
||
return_data = input_params.get("data", {})
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "Return执行成功，将提前结束流程",
|
||
"output": {
|
||
"returnSignal": True,
|
||
"returnData": return_data
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"Return执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 串行执行块处理器
|
||
@register_handler("SerialFlowBp")
|
||
class SerialFlowBlockHandler(BlockHandler):
|
||
"""串行执行块处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""串行执行子块"""
|
||
try:
|
||
# 创建块执行器
|
||
from services.execution.block_executor import BlockExecutor
|
||
executor = BlockExecutor(context)
|
||
|
||
# 执行default分支下的所有子块
|
||
result = await executor.execute_children(block, "default")
|
||
|
||
# 检查是否成功
|
||
if not result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
final_result = {
|
||
"success": True,
|
||
"message": "串行执行完成",
|
||
"output": result.get("output", {})
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, final_result, context)
|
||
return final_result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"串行执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 并行执行块处理器
|
||
@register_handler("ParallelFlowBp")
|
||
class ParallelFlowBlockHandler(BlockHandler):
|
||
"""并行执行块处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""并行执行子块"""
|
||
import asyncio
|
||
|
||
try:
|
||
# 创建块执行器
|
||
from services.execution.block_executor import BlockExecutor
|
||
|
||
# 获取子块
|
||
children = block.get("children", {}).get("default", [])
|
||
|
||
if not children:
|
||
result = {
|
||
"success": True,
|
||
"message": "没有子块需要执行",
|
||
"output": {}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 为每个子块创建一个执行任务
|
||
tasks = []
|
||
results = []
|
||
|
||
for child_block in children:
|
||
# 为每个子块创建一个新的执行上下文(共享同一个任务上下文)
|
||
executor = BlockExecutor(context)
|
||
|
||
# 将子块包装为一个异步任务
|
||
task = asyncio.create_task(executor.execute_block(child_block))
|
||
tasks.append(task)
|
||
|
||
# 等待所有任务完成
|
||
completed_tasks = await asyncio.gather(*tasks, return_exceptions=True)
|
||
|
||
# 处理任务结果
|
||
all_success = True
|
||
for i, result in enumerate(completed_tasks):
|
||
if isinstance(result, Exception):
|
||
results.append({
|
||
"success": False,
|
||
"message": f"子块执行异常: {str(result)}",
|
||
"index": i
|
||
})
|
||
all_success = False
|
||
else:
|
||
results.append(result)
|
||
if not result.get("success", False):
|
||
all_success = False
|
||
|
||
# 所有并行子块执行完成后，检查是否有后续处理
|
||
from services.execution.block_executor import BlockExecutor
|
||
executor = BlockExecutor(context)
|
||
|
||
# 根据执行结果处理后续分支
|
||
if all_success:
|
||
# 执行成功分支
|
||
if "success" in block.get("children", {}) and block["children"]["success"]:
|
||
logger.info(f"并行执行成功，执行success分支")
|
||
success_result = await executor.execute_children(block, "success")
|
||
if not success_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, success_result, context)
|
||
return success_result
|
||
else:
|
||
# 执行失败分支
|
||
if "fail" in block.get("children", {}) and block["children"]["fail"]:
|
||
logger.info(f"并行执行部分失败，执行fail分支")
|
||
fail_result = await executor.execute_children(block, "fail")
|
||
if not fail_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, fail_result, context)
|
||
return fail_result
|
||
|
||
# 执行完成分支（无论成功失败）
|
||
if "complete" in block.get("children", {}) and block["children"]["complete"]:
|
||
logger.info(f"并行执行完成，执行complete分支")
|
||
complete_result = await executor.execute_children(block, "complete")
|
||
if not complete_result.get("success", False):
|
||
# 记录执行结果
|
||
await self._record_task_log(block, complete_result, context)
|
||
return complete_result
|
||
|
||
final_result = {
|
||
"success": all_success,
|
||
"message": "并行执行完成" if all_success else "并行执行部分失败",
|
||
"output": {
|
||
"results": results,
|
||
"allSuccess": all_success
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, final_result, context)
|
||
return final_result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"并行执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 并发执行N次处理器
|
||
@register_handler("ParallelRepeatNBp")
|
||
class ParallelRepeatNBlockHandler(BlockHandler):
|
||
"""并发执行N次处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""并发执行子块N次"""
|
||
import asyncio
|
||
|
||
try:
|
||
# 获取执行次数
|
||
num = int(input_params.get("num", 1))
|
||
# 限制最大执行次数
|
||
num = min(num, 100)
|
||
|
||
if num <= 0:
|
||
result = {
|
||
"success": True,
|
||
"message": "执行次数必须大于0",
|
||
"output": {}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 创建块执行器
|
||
from services.execution.block_executor import BlockExecutor
|
||
|
||
# 为每次执行创建一个执行任务
|
||
tasks = []
|
||
results = []
|
||
|
||
for i in range(num):
|
||
# 为每次执行创建一个新的执行上下文(共享同一个任务上下文)
|
||
executor = BlockExecutor(context)
|
||
context.set_variable("index", i)
|
||
|
||
# 执行default分支下的子块
|
||
task = asyncio.create_task(executor.execute_children(block, "default"))
|
||
tasks.append(task)
|
||
|
||
# 等待所有任务完成
|
||
completed_tasks = await asyncio.gather(*tasks, return_exceptions=True)
|
||
|
||
# 处理任务结果
|
||
all_success = True
|
||
for i, result in enumerate(completed_tasks):
|
||
if isinstance(result, Exception):
|
||
results.append({
|
||
"success": False,
|
||
"message": f"第{i+1}次执行异常: {str(result)}",
|
||
"index": i
|
||
})
|
||
all_success = False
|
||
else:
|
||
results.append(result)
|
||
if not result.get("success", False):
|
||
all_success = False
|
||
|
||
final_result = {
|
||
"success": all_success,
|
||
"message": f"并发执行{num}次完成" if all_success else f"并发执行{num}次部分失败",
|
||
"output": {
|
||
"results": results,
|
||
"iterations": num
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, final_result, context)
|
||
return final_result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"并发执行N次失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 重复执行N次处理器
|
||
@register_handler("RepeatNumBp")
|
||
class RepeatNumBlockHandler(BlockHandler):
|
||
"""重复执行N次处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""重复执行子块N次"""
|
||
try:
|
||
# 获取执行次数
|
||
num = int(input_params.get("num", 1))
|
||
# 限制最大执行次数
|
||
num = min(num, 1000)
|
||
|
||
if num <= 0:
|
||
result = {
|
||
"success": True,
|
||
"message": "执行次数必须大于0",
|
||
"output": {}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 创建块执行器
|
||
from services.execution.block_executor import BlockExecutor
|
||
executor = BlockExecutor(context)
|
||
|
||
# 循环执行
|
||
results = []
|
||
for i in range(num):
|
||
# 检查是否取消
|
||
if context.is_task_canceled():
|
||
result = {
|
||
"success": False,
|
||
"message": "任务已被取消"
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 检查是否有中断或返回信号
|
||
if context.get_variable("__BREAK__", False):
|
||
logger.info(f"检测到中断信号，提前结束重复执行，已完成 {i}/{num} 次")
|
||
context.set_variable("__BREAK__", False) # 重置中断信号
|
||
break
|
||
|
||
if context.get_variable("__RETURN__", False):
|
||
logger.info(f"检测到返回信号，提前结束重复执行，已完成 {i}/{num} 次")
|
||
# 不需要重置返回信号，它需要向上传播
|
||
break
|
||
|
||
# 设置当前索引
|
||
context.set_variable("index", i)
|
||
|
||
# 执行子块
|
||
result = await executor.execute_children(block, "default")
|
||
results.append({
|
||
"index": i,
|
||
"success": result.get("success", False),
|
||
"result": result
|
||
})
|
||
|
||
# 如果执行失败，提前退出
|
||
if not result.get("success", False):
|
||
failed_result = {
|
||
"success": False,
|
||
"message": f"重复执行在第 {i+1} 次时失败",
|
||
"output": {
|
||
"results": results,
|
||
"iterations": i + 1,
|
||
"totalIterations": num,
|
||
"failedAt": i
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, failed_result, context)
|
||
return failed_result
|
||
|
||
# 执行完成分支
|
||
if "complete" in block.get("children", {}) and block["children"]["complete"] and results:
|
||
# 设置迭代信息
|
||
context.set_variable("count", len(results))
|
||
context.set_variable("lastIndex", len(results) - 1)
|
||
|
||
complete_result = await executor.execute_children(block, "complete")
|
||
if not complete_result.get("success", False):
|
||
failed_complete = {
|
||
"success": False,
|
||
"message": f"完成分支执行失败: {complete_result.get('message')}",
|
||
"output": {
|
||
"results": results,
|
||
"iterations": len(results),
|
||
"totalIterations": num
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, failed_complete, context)
|
||
return failed_complete
|
||
|
||
final_result = {
|
||
"success": True,
|
||
"message": f"重复执行成功，共执行 {len(results)} 次",
|
||
"output": {
|
||
"results": results,
|
||
"iterations": len(results),
|
||
"totalIterations": num
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, final_result, context)
|
||
return final_result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"重复执行N次失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 抛出异常处理器
|
||
@register_handler("ThrowExceptionBp")
|
||
class ThrowExceptionBlockHandler(BlockHandler):
|
||
"""抛出异常处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""抛出异常"""
|
||
try:
|
||
# 获取异常提示文本
|
||
message = input_params.get("message", "未知异常")
|
||
|
||
# 记录日志
|
||
logger.error(f"主动抛出异常: {message}")
|
||
|
||
# 这里实际上是返回失败结果，而不是真正抛出异常
|
||
# 这样可以更好地控制任务流程
|
||
result = {
|
||
"success": False,
|
||
"message": f"主动抛出异常: {message}",
|
||
"output": {
|
||
"exceptionMessage": message
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"抛出异常块执行失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|
||
# 停止其他并行分支处理器
|
||
@register_handler("StopOtherBranch")
|
||
class StopOtherBranchBlockHandler(BlockHandler):
|
||
"""停止其他并行分支处理器"""
|
||
|
||
async def execute(
|
||
self,
|
||
block: Dict[str, Any],
|
||
input_params: Dict[str, Any],
|
||
context: TaskContext
|
||
) -> Dict[str, Any]:
|
||
"""停止其他并行分支"""
|
||
try:
|
||
# 设置停止信号
|
||
context.set_variable("__STOP_OTHER_BRANCHES__", True)
|
||
|
||
result = {
|
||
"success": True,
|
||
"message": "停止其他并行分支信号已设置",
|
||
"output": {
|
||
"stopSignal": True
|
||
}
|
||
}
|
||
# 记录执行结果
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
except Exception as e:
|
||
result = {
|
||
"success": False,
|
||
"message": f"停止其他并行分支操作失败: {str(e)}"
|
||
}
|
||
# 记录异常
|
||
await self._record_task_log(block, result, context)
|
||
return result
|
||
|