internal void FireTaskFailed(ITask task, Exception e)
{
if (TaskFailed != null)
{
TaskFailed.Invoke(this, task, e);
}
}
/// <summary>
/// Add a <see cref="TaskFailed"/> callback
/// </summary>
/// <param name="callback"><see cref="TaskFailed"/> callback to add</param>
/// <returns>The <see cref="TaskContext"/></returns>
public TaskContext Failed(TaskFailed callback)
{
if (HasFailed)
{
callback(this);
}
_failed += callback;
return(this);
}
public async Task AddTask(TaskVm model)
{
var result = await Create(model.ToCreateTaskCommand());
if (result != null)
{
await RefreshTask();
return;
}
TaskFailed?.Invoke(this, "Unable to create task");
}
private async Task RefreshTask()
{
var updatedTasks = (await GetAllTasks()).Payload;
if (updatedTasks != null)
{
Tasks = updatedTasks.ToList();
TasksUpdated?.Invoke(this, null);
return;
}
TaskFailed?.Invoke(this, "Error while refreshing task list.");
}
public virtual void SetDatum(object odatum)
{
this.datum = (TaskFailed)odatum;
this.id = TaskID.ForName(datum.taskid.ToString());
this.taskType = TaskType.ValueOf(datum.taskType.ToString());
this.finishTime = datum.finishTime;
this.error = datum.error.ToString();
this.failedDueToAttempt = datum.failedDueToAttempt == null ? null : TaskAttemptID
.ForName(datum.failedDueToAttempt.ToString());
this.status = datum.status.ToString();
this.counters = EventReader.FromAvro(datum.counters);
}
public async Task AssignTask(Guid memberId)
{
SelectedTask.AssignedMemberId = memberId;
var result = await Update(SelectedTask.ToUpdateTaskCommand());
if (result != null)
{
await RefreshTask();
return;
}
TaskFailed?.Invoke(this, "Unable to create task");
}
public async Task CompleteTask(Guid id)
{
var completeTask = Tasks.FirstOrDefault(x => x.Id == id);
completeTask.IsComplete = true;
var result = await Update(completeTask.ToUpdateTaskCommand());
if (result != null)
{
await RefreshTask();
}
TaskFailed?.Invoke(this, "Unable to complete task");
TasksUpdated?.Invoke(this, null);
}
public virtual object GetDatum()
{
if (datum == null)
{
datum = new TaskFailed();
datum.taskid = new Utf8(id.ToString());
datum.error = new Utf8(error);
datum.finishTime = finishTime;
datum.taskType = new Utf8(taskType.ToString());
datum.failedDueToAttempt = failedDueToAttempt == null ? null : new Utf8(failedDueToAttempt
.ToString());
datum.status = new Utf8(status);
datum.counters = EventWriter.ToAvro(counters);
}
return(datum);
}
private void Handle(TaskFailed message)
{
RequireActivation(true);
if (message.ParentTaskInstanceId != this.InstanceId)
{
throw new Exception();
}
TransitionInfo ti = GetTransition(message.FromTaskInstanceId);
if (ti == null)
{
throw new Exception();
}
lock (this)
{
log.Info("Child task {0} has failed: {1}", ti.InstanceId, message.ErrorInfo);
if (ti.Status == TransitionStatus.Failed)
{
return;
}
if (!ti.IsTransitionActive)
{
log.Warn("Transition {0} ({1}) is not active: {2}", ti.InstanceId, ti.TaskId, ti.Status);
return;
}
if (message.IsExpected)
{
ti.Status = TransitionStatus.Failed;
if (!AllowChildTaskFailures)
{
DefaultHandleTaskFailure(message.ErrorInfo, true);
return;
}
}
else
{
ti.Status = TransitionStatus.FailedActive;
}
OnTransitionStatusChanged(ti.InstanceId);
return;
}
}
internal virtual void ProcessTask(ScheduledTask scheduledTask)
{
if (scheduledTask.IsQueued &&
!scheduledTask.AllowMultipleInstance)
{
GlobalConfiguration.Logger.Warn("scheduled task {0} is in queue and not allow multiple instance", scheduledTask.Name);
return;
}
if (!scheduledTask.AllowMultipleInstance)
{
if (TasksHost.IsRunning(scheduledTask.Name))
{
GlobalConfiguration.Logger.Warn("scheduled task {0} is already running and not allow multiple instance", scheduledTask.Name);
return;
}
}
var id = Guid.NewGuid();
scheduledTask.IsQueued = true;
TasksHost.Enqueue(
id
, scheduledTask.Name
, scheduledTask.TaskType
, scheduledTask.Parameters
, (dic) =>
{
GlobalConfiguration.Logger.Info("scheduled task {0} completed", scheduledTask.Name);
scheduledTask.IsQueued = false;
try
{
if (scheduledTask.Completed != null)
{
scheduledTask.Completed(dic);
}
}
catch (Exception ex)
{
GlobalConfiguration.Logger.Error(ex);
}
finally
{
scheduledTask.IsForced = false;
if (scheduledTask.NextRunningDateFactory != null)
{
try
{
scheduledTask.NextRunningDate = scheduledTask.NextRunningDateFactory.Invoke();
}
catch (Exception ex)
{
GlobalConfiguration.Logger.Error(ex);
}
}
}
}
, (ex) =>
{
scheduledTask.Exception = ex;
GlobalConfiguration.Logger.Error(ex);
if (TaskFailed != null)
{
try
{
TaskFailed.Invoke(scheduledTask.Name, ex);
}
catch { }
}
},
null,
() =>
{
GlobalConfiguration.Logger.Info("scheduled task {0} started", scheduledTask.Name);
scheduledTask.StartedCount += 1;
if (TaskStarted != null)
{
try
{
TaskStarted.Invoke(scheduledTask.Name);
}
catch { }
}
},
true,
scheduledTask.IsForced);
}
/// <summary>
/// Add a <see cref="TaskFailed"/> callback
/// </summary>
/// <param name="callback"><see cref="TaskFailed"/> callback to add</param>
/// <returns>The <see cref="TaskContext"/></returns>
public TaskContext Failed(TaskFailed callback)
{
if (HasFailed) callback(this);
_failed += callback;
return this;
}
/// <summary> /// Invokes the TaskFailed event /// </summary> protected void OnTaskFailed(Exception error) => TaskFailed?.Invoke(this, error);
private void OnTaskFailed()
{
TaskFailed?.Invoke(this, EventArgs.Empty);
}
