// 一个完整执行经历的方法
private async Task RunLife(TTData data, TaskResp <TTRes> taskResp)
{
// 【1】 执行起始方法 附加校验
var checkRes = await RunCheck(data, taskResp);
if (!checkRes)
{
return;
}
// 直接执行
var condition = taskResp.task_cond;
var doResp = await TryDo(data, condition.loop_times, condition.tried_times);
doResp.SetToTaskResp(taskResp);
// 判断是否失败回退
if (doResp.run_status.IsFailed())
{
await Revert(data, condition.tried_times);
}
// 【3】 执行结束方法
await RunEnd(data, taskResp);
}
/// <summary>
/// 任务的具体执行
/// </summary>
/// <param name="data"></param>
/// <param name="taskResp"></param>
/// <returns> </returns>
private async Task Recurs(TTData data, TaskResp <TTRes> taskResp)
{
var runCondition = taskResp.task_cond;
do
{
taskResp.run_status = TaskRunStatus.WaitToRun;
await RunLife(data, taskResp);
runCondition.loop_times++;
}while (taskResp.run_status.IsFailed() && runCondition.loop_times <= TaskMeta.loop_times);
runCondition.run_timestamp = DateTime.Now.ToUtcSeconds();
// 判断是否间隔执行,生成重试信息
if (taskResp.run_status.IsFailed() &&
runCondition.tried_times < TaskMeta.retry_times)
{
runCondition.tried_times++;
runCondition.next_timestamp = runCondition.run_timestamp + TaskMeta.retry_seconds;
taskResp.run_status = TaskRunStatus.RunPaused;
await TrySaveTaskContext(data, taskResp);
}
// 最终失败，执行失败方法
if (taskResp.run_status.IsFailed())
{
await FinallyFailed(data, taskResp);
}
}
// 运行
private async Task TryRun(TTData data, TaskResp <TTRes> taskResp)
{
string errorMsg;
try
{
await Recurs(data, taskResp);
return;
}
catch (RespException e)
{
errorMsg = e.ToString();
if (taskResp.resp == null)
{
taskResp.resp = new TTRes().WithExeption(e);// e.ConvertToReultInherit<TTRes>(); //.ConvertToReult<TTRes>();
}
}
catch (Exception e)
{
errorMsg = e.ToString();
if (taskResp.resp == null)
{
taskResp.resp = new TTRes().WithResp(SysRespTypes.ApplicationError,
"Error occurred during task [Run]!");
}
}
taskResp.run_status = TaskRunStatus.RunFailed;
var resp = taskResp.resp;
LogUtil.Error($"sys_ret:{resp.sys_ret}, ret:{resp.ret},msg:{resp.msg}, Detail:{errorMsg}",
TaskMeta.task_id, EventTaskProvider.ModuleName);
await TrySaveTaskContext(data, taskResp);
}
public async Task <TaskResp <TTRes> > Run(TTData data, int triedTimes)
{
var taskResp = new TaskResp <TTRes>
{
task_cond = new RunCondition()
{
tried_times = triedTimes
}
};
await TryRun(data, taskResp);
return(taskResp);
}
// 根据任务结果格式化当前节点结果， 外部循环使用
internal static bool FormatNodeErrorResp<TTRes>(NodeResp<TTRes> nodeResp, TaskResp<Resp> taskResp,
TaskMeta tMeta)
where TTRes : Resp, new()
{
var status = NodeStatus.ProcessCompoleted;
if (!taskResp.run_status.IsCompleted())
{
var haveError = true;
switch (tMeta.node_action)
{
case NodeResultAction.PauseOnFailed:
status = NodeStatus.ProcessPaused;
break;
case NodeResultAction.FailedOnFailed:
status = taskResp.run_status == TaskRunStatus.RunFailed
? NodeStatus.ProcessFailed
: NodeStatus.ProcessPaused;
break;
case NodeResultAction.RevrtAllOnFailed:
status = taskResp.run_status == TaskRunStatus.RunFailed
? NodeStatus.ProcessFailedRevert
: NodeStatus.ProcessPaused;
break;
default:
haveError = false;
break;
}
if (haveError)
{
if (status < nodeResp.node_status)
{
nodeResp.node_status = status;
nodeResp.resp = ConvertToNodeResult<TTRes>(taskResp.resp);
}
return true;
}
}
if (nodeResp.node_status == NodeStatus.ProcessCompoleted && taskResp.resp is TTRes nres)
{
nodeResp.resp = nres;
}
return false;
}
private Task TrySaveTaskContext(TTData data, TaskResp <TTRes> taskResp)
{
try
{
if (TaskMeta.owner_type == OwnerType.Task)
{
return(taskResp.run_status == TaskRunStatus.RunPaused
?SaveTaskContext(data, taskResp.resp, taskResp.task_cond)
:SaveErrorTaskContext(data, taskResp.resp, taskResp.task_cond));
}
}
catch (Exception e)
{
// 防止Provider中SaveTaskContext内部使用Task实现时，级联异常死循环
LogUtil.Error($"Errors occurred during [Task context] saving. Detail:{e}", TaskMeta.task_id, EventTaskProvider.ModuleName);
}
return(Task.CompletedTask);
}
private async Task <bool> RunCheck(TTData data, TaskResp <TTRes> taskResp)
{
if (string.IsNullOrEmpty(TaskMeta?.task_id))
{
taskResp.run_status = TaskRunStatus.RunFailed;
taskResp.resp = new TTRes().WithResp(SysRespTypes.ApplicationError, "Task metainfo is null!");
return(false);
}
var condition = taskResp.task_cond;
var res = await RunStartCheck(data, condition.loop_times, condition.tried_times);
if (!res.IsSuccess())
{
taskResp.run_status = TaskRunStatus.RunFailed;
taskResp.resp = new TTRes().WithResp(res);// res.ConvertToResultInherit<TTRes>();
return(false);
}
return(true);
}
/// <summary>
/// 任务结束方法
/// </summary>
/// <param name="data"></param>
/// <param name="context">请求的上下文</param>
/// <returns></returns>
protected virtual Task RunEnd(TTData data, TaskResp <TTRes> context)
{
return(Task.CompletedTask);
}
/// <summary>
/// 最终失败执行方法
/// </summary>
/// <param name="data"></param>
/// <param name="taskResp"></param>
protected virtual Task FinallyFailed(TTData data, TaskResp <TTRes> taskResp)
{
return(Task.CompletedTask);
}
