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();
}
}
}