private static bool RecoursiveCheckGraph(Task root, ImmutableList<Guid> previousTasks) { Contract.Requires(root != null); Contract.Requires(root.Inputs != null); Contract.Requires(previousTasks != null); if (previousTasks.Contains(root.Id)) { Logger.Write( LogCategories.Error(string.Format( "{0} is cycled.", root), LogCategories.TaskServices)); return false; } foreach (var task in root.Inputs) { if (previousTasks.Contains(task.Id)) { Logger.Write( LogCategories.Error(string.Format( "{0} is cycled.", task), LogCategories.TaskServices)); return false; } if (!RecoursiveCheckGraph(task, previousTasks.Add(root.Id))) return false; } return true; }
/// <summary> /// Removes task from task manager. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/>. /// </param> public void DeleteTask(Task task) { lock (task) { switch (task.State) { case TaskState.NotReady: FromNotReady(task); break; case TaskState.Completed: FromCompleted(task); break; case TaskState.Failed: FromFailed(task); break; case TaskState.Cancelled: FromCancelled(task); break; default: throw new InvalidOperationException( string.Format("Task {0} has unexpected state {1} on TaskQueue::DeleteTask()", task, task.State)); } task.State = TaskState.Deleted; } }
void ITaskQueue.TaskFailed(Task task, ErrorReport errorReport) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentNullException>(errorReport != null); Contract.Requires<ArgumentException>(task.State == TaskState.Processing); Contract.Ensures(task.State == TaskState.Failed); Contract.Ensures(task.Error == errorReport); throw new NotImplementedException(); }
/// <summary> /// Cancels execution of specified task. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/>. /// </param> public void CancelTask(Task task) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentException>( task.State == TaskState.NotReady || task.State == TaskState.Pending || task.State == TaskState.Processing); Contract.Ensures(task.State == TaskState.Cancelled); throw new NotImplementedException(); }
/// <summary> /// Removes task from task manager. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/>. /// </param> public void DeleteTask(Task task) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentException>( task.State == TaskState.Completed || task.State == TaskState.Failed || task.State == TaskState.Cancelled || task.State == TaskState.Unavailible); Contract.Ensures(task.State == TaskState.Deleted); throw new NotImplementedException(); }
/// <summary> /// Cancels execution of specified task. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/>. /// </param> public void CancelTask(Task task) { lock (task) { switch (task.State) { case TaskState.Processing: FromProcessing(task); break; case TaskState.Pending: FromPending(task); break; case TaskState.NotReady: FromNotReady(task); break; default: throw new InvalidOperationException( string.Format("Task {0} has unexpected state {1} on TaskQueue::CancelTask()", task, task.State)); } ToCancelled(task); } }
private void ToFailed(Task task) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentException>(task.State != TaskState.Failed); Contract.Ensures(task.State == TaskState.Failed); task.State = TaskState.Failed; lock (failedTasks) { failedTasks.Add(task); } }
private void FromUnavailible(Task task) { Contract.Requires<ArgumentNullException>(task != null); lock (unavailibleTasks) { unavailibleTasks.Remove(task); } }
/// <summary> /// Reinitializes specified task. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/>. /// </param> public void RestartTask(Task task) { lock (task) { FromCancelled(task); ToUnavailible(task); StartTask(task); ResetDependencyCounter(task); } }
/// <summary> /// Informs task queue that specified <paramref name="task"/> has been rejected by worker. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/> that has been executed. /// </param> public void TaskRejected(Task task) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentException>(task.State == TaskState.Processing); Contract.Ensures(task.State == TaskState.Pending); throw new NotImplementedException(); }
/// <summary> /// Registers a task in task manager and sets its UID. /// </summary> /// <param name="task"> /// An instance of <see cref="DataModel.Task"/>. /// </param> public void RegisterTask(Task task) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentException>(task.State == TaskState.Unattached); Contract.Ensures(task.State == TaskState.Unavailible); throw new NotImplementedException(); }
private void ToUnavailible(Task task) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentException>(task.State != TaskState.Unavailible); Contract.Ensures(task.State == TaskState.Unavailible); task.State = TaskState.Unavailible; lock (unavailibleTasks) { unavailibleTasks.Add(task); } }
private void FromCompleted(Task task) { Contract.Requires<ArgumentNullException>(task != null); lock (completedTasks) { completedTasks.Remove(task); } }
private static void ResetDependencyCounter(Task task) { task.DependenciesCount = (uint)task.Inputs.Count; }
/// <summary> /// Informs task queue that specified <paramref name="task"/> has been rejected by worker. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/> that has been executed. /// </param> public void TaskRejected(Task task) { lock (task) { FromProcessing(task); ToPending(task); } }
/// <summary> /// Informs task queue that specified <paramref name="task"/> has failed. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/> that failed. /// </param> /// <param name="errorReport"> /// Error report. /// </param> public void TaskFailed(Task task, ErrorReport errorReport) { lock (task) { FromProcessing(task, terminateProcessing: false); ToFailed(task); task.Error = errorReport; var job = task.Job; lock (job) { Logger.Write( LogCategories.Error( string.Format("Task {0} failed because of {1}. This caused job {2} to fail.", task, errorReport.Error, task.Job), LogCategories.TaskServices, LogCategories.TaskQueue)); job.State = JobState.Failed; foreach (var t in task.Job.Tasks) { lock (t) { switch (t.State) { case TaskState.NotReady: FromNotReady(t); break; case TaskState.Processing: FromProcessing(t); break; case TaskState.Failed: continue; case TaskState.Pending: FromPending(t); break; case TaskState.Completed: FromCompleted(t); break; default: throw new InvalidOperationException( string.Format("Task {0} has unexpected state {1} on TaskQueue::TaskFailed()", task, task.State)); } ToFailed(t); } } } } }
/// <summary> /// Informs task queue that specified <paramref name="task"/> has been executed successfully. /// Task queue performs recalculation of tasks' dependencies. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/> that has been executed. /// </param> public void TaskCompleted(Task task) { lock (task) { if (task.State == TaskState.Failed) { // Job failed, there is nothing else to do. The task is already in 'failed' list. return; } FromProcessing(task); ToCompleted(task); // Recalculate dependents' states foreach (var t in task.Outputs) { lock (t) { if (t.State == TaskState.NotReady) { t.DependenciesCount--; if (t.DependenciesCount == 0) { t.State = TaskState.Pending; FromNotReady(t); ToPending(t); } } } } task.Job.NotifyTaskCompleted(task); } }
/// <summary> /// Starts execution of specified task. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/>. /// </param> public void StartTask(Task task) { lock (task) { ResetDependencyCounter(task); FromUnavailible(task); if (task.DependenciesCount == 0) { ToPending(task); } else { ToNotReady(task); } } }
private void ToNotReady(Task task) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentException>(task.State != TaskState.NotReady); Contract.Ensures(task.State == TaskState.NotReady); task.State = TaskState.NotReady; lock (notReadyTasks) { notReadyTasks.Add(task); } }
private void ToPending(Task task) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentException>(task.State != TaskState.Pending); Contract.Ensures(task.State == TaskState.Pending); task.State = TaskState.Pending; pendingTasks.Enqueue(task); }
private void FromFailed(Task task) { Contract.Requires<ArgumentNullException>(task != null); lock (failedTasks) { failedTasks.Remove(task); } }
/// <summary> /// Initalizes new instance of <see cref="TaskEventArgs"/> class. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/> that provides data for current event. /// </param> public TaskEventArgs(Task task) { Task = task; }
/// <summary> /// Notifies job that <paramref name="task"/> has been failed. /// </summary> /// <param name="task"> /// Task that has been failed. /// </param> public void NotifyTaskFailed(Task task) { Contract.Requires(task != null); lock (this) { State = JobState.Failed; InvokeOnJobFailed(); } Logger.Write(LogCategories.Error(string.Format("Task {0} in job {1} failed.", task, this), LogCategories.TaskServices)); }
/// <summary> /// Starts execution of specified task. /// </summary> /// <param name="task"> /// An instance of <see cref="Task"/>. /// </param> public void StartTask(Task task) { Contract.Requires<ArgumentNullException>(task != null); Contract.Requires<ArgumentException>(task.State == TaskState.Unavailible); Contract.Ensures(task.State == TaskState.Pending || task.State == TaskState.NotReady); throw new NotImplementedException(); }
private void FromProcessing(Task task, bool terminateProcessing = true) { Contract.Requires<ArgumentNullException>(task != null); if (terminateProcessing) { var worker = task.Worker as IWorkerChannel; if (worker != null) { worker.Cancel(); } } lock (processingTasks) { processingTasks.Remove(task); } }
private void FromNotReady(Task task) { Contract.Requires<ArgumentNullException>(task != null); lock (notReadyTasks) { notReadyTasks.Remove(task); } }
/// <summary> /// Registers a task in task manager and sets its UID. /// </summary> /// <param name="task"> /// An instance of <see cref="DataModel.Task"/>. /// </param> public void RegisterTask(Task task) { lock (task) { ToUnavailible(task); } }
private void FromPending(Task task) { Contract.Requires<ArgumentNullException>(task != null); pendingTasks.Remove(task); }
/// <summary> /// Notifies job that <paramref name="task"/> has been successfully executed. /// </summary> /// <param name="task"> /// Task that has been executed. /// </param> public void NotifyTaskCompleted(Task task) { Contract.Requires(task != null); Logger.Write(LogCategories.Information(string.Format("Task {0} in job {1} completed.", task, this), LogCategories.TaskServices)); lock (this) { incompletedTasksCount--; if (incompletedTasksCount == 0) { State = JobState.Completed; Logger.Write(LogCategories.Information(string.Format("Job {0} completed.", this), LogCategories.TaskServices)); InvokeOnJobCompleted(); } } }