// 顺序任务 回退当前任务之前所有任务
internal static async Task Excuting_SerialRevert <TTData, TTRes>(this BaseNode <TTData, TTRes> node, TTData data, NodeResp <TTRes> nodeResp,
IList <IEventTask <TTData> > tasks, string blockTaskId, int triedTimes)
where TTData : class where TTRes : Resp, new()
{
if (nodeResp.RevrtTasks == null)
{
nodeResp.RevrtTasks = new List <TaskMeta>(tasks.Count);
}
foreach (var tItem in tasks)
{
if (tItem.TaskMeta.task_id == blockTaskId)
{
nodeResp.RevrtTasks.Add(tItem.TaskMeta);
break;
}
var rRes = await ExecutorUtil.TryRevertTask(tItem, data, triedTimes);// tItem.Revert(data);
if (rRes)
{
nodeResp.RevrtTasks.Add(tItem.TaskMeta);
}
}
}
// 并行任务回退处理（回退当前其他所有任务）
internal static async Task Excuting_ParallelRevert <TTData, TTRes>(this BaseNode <TTData, TTRes> node,
TTData data, NodeResp <TTRes> nodeResp, IList <IEventTask <TTData> > tasks, string blockTaskId, int triedTimes)
where TTData : class where TTRes : Resp, new()
{
var revResList = tasks.Select(tItem => tItem.TaskMeta.task_id == blockTaskId
? Task.FromResult(true)
: ExecutorUtil.TryRevertTask(tItem, data, triedTimes))
.ToArray();
try
{
await Task.WhenAll(revResList);
}
catch (Exception ex)
{
LogUtil.Error($"An error occurred while the parallel node reverted all tasks. Detail:{ex}",
node.NodeMeta.node_id, EventTaskProvider.ModuleName);
}
if (nodeResp.RevrtTasks == null)
{
nodeResp.RevrtTasks = new List <TaskMeta>(tasks.Count);
}
for (var i = 0; i < tasks.Count; i++)
{
var res = false;
var resT = revResList[i];
if (resT.Status == TaskStatus.RanToCompletion)
{
res = resT.Result;
}
if (res)
{
nodeResp.RevrtTasks.Add(tasks[i].TaskMeta);
}
}
}
/// 顺序执行
internal static async Task Excuting_Serial <TTData, TTRes>(this BaseNode <TTData, TTRes> node,
TTData data, NodeResp <TTRes> nodeResp, IList <IEventTask <TTData> > tasks, int triedTimes)
where TTData : class where TTRes : Resp, new()
{
nodeResp.TaskResults = new Dictionary <TaskMeta, TaskResp <Resp> >(tasks.Count);
nodeResp.node_status = NodeStatus.ProcessCompoleted; // 默认成功，给出最大值，循环内部处理
foreach (var tItem in tasks)
{
var taskResp = await ExecutorUtil.TryGetTaskItemResult(data, tItem, triedTimes);
var tMeta = tItem.TaskMeta;
nodeResp.TaskResults.Add(tMeta, taskResp);
var haveError = ExecutorUtil.FormatNodeErrorResp(nodeResp, taskResp, tMeta);
if (haveError)
{
nodeResp.block_taskid = tMeta.task_id;
break;
}
}
}
// 并行执行任务扩展
internal static async Task Excuting_Parallel <TTData, TTRes>(this BaseNode <TTData, TTRes> node, TTData data,
NodeResp <TTRes> nodeResp, IList <IEventTask <TTData> > tasks, int triedTimes)
where TTData : class
where TTRes : Resp, new()
{
var taskResults =
tasks.ToDictionary(t => t, t => ExecutorUtil.TryGetTaskItemResult(data, t, triedTimes));
try
{
await Task.WhenAll(taskResults.Select(tr => tr.Value));
}
catch (Exception ex)
{
LogUtil.Error(ex, node.NodeMeta.node_id, EventTaskProvider.ModuleName);
}
var taskResps = taskResults.ToDictionary(d => d.Key, d => d.Value.Status == TaskStatus.Faulted
? new TaskResp <Resp>().WithError(TaskRunStatus.RunFailed, new RunCondition())
: d.Value.Result);
nodeResp.TaskResults = taskResps.ToDictionary(tk => tk.Key.TaskMeta, tk => tk.Value);
nodeResp.node_status = NodeStatus.ProcessCompoleted; // 循环里会处理结果，这里给出最大值
foreach (var tItemRes in taskResps)
{
var isBlocked = ExecutorUtil.FormatNodeErrorResp(nodeResp, tItemRes.Value, tItemRes.Key.TaskMeta);
if (isBlocked)
{
nodeResp.block_taskid = tItemRes.Key.TaskMeta.task_id;
if (nodeResp.node_status == NodeStatus.ProcessFailedRevert)
{
break;
}
}
}
}
