public void Execute(IEngineTask task)
{
if (CanExecute(task))
{
enginePipeline.Produce(task);
}
}
public async Task ProcessActionTask(IEngineTask task)
{
var lockTask = task as LockTask;
var processItem = await _processItemEventStore.GetProcessItemAsync(lockTask.ProcessItemId);
_taskValidatorFactory(EngineTaskValidatorKinds.CurrentUserCanLockProcessItem).Validate(task, processItem);
_taskValidatorFactory(EngineTaskValidatorKinds.RequestIsForTheMostRecentState).Validate(task, processItem);
processItem.ApplyMutation(new LockProcessItemMutation()
{
LockDuration = TimeSpan.FromMinutes(5),
PrincipalId = task.PrincipalId
});
_processItemEventStore.StoreUnsavedMutations((IProcessItemEventContainer)processItem,
(processItemMutationId, mutationDateTimeUtc) =>
{
processItem.SetProcessItemState(processItemMutationId, mutationDateTimeUtc);
});
_eventQueue.PublishEvent(new EventNotification()
{
ProcessItemId = lockTask.ProcessItemId,
NotificationKind = EventNotificationKinds.ProcessItemLock
});
}
private async Task InvokeAction(IEngineTask task)
{
try
{
var taskHandler = _taskHandlerFactory(task.GetType().Name);
await taskHandler.ProcessActionTask(task);
}
catch (Exception e)
{
// global exception handler for tasks
_loggingAdapter.WriteEntry(new LogEntry(LoggingEventType.Error, "We threw an exception! {exception}", new Dictionary <string, object>()
{
{ "exception", e },
}));
_eventQueue.PublishEvent(new EventNotification()
{
ProcessId = (task as IProcessEngineTask)?.ProcessId,
ProcessItemId = (task as IProcessItemEngineTask)?.ProcessItemId,
ActionId = (task as IActionTask)?.ActionId,
PrincipalId = task.PrincipalId,
NotificationKind = EventNotificationKinds.Exception,
Exception = e
});
}
}
public async Task ProcessActionTask(IEngineTask task)
{
var unlockTask = task as UnlockTask;
var processItem = await _processItemEventStore.GetProcessItemAsync(unlockTask.ProcessItemId);
_taskValidatorFactory(EngineTaskValidatorKinds.CurrentUserCanLockProcessItem).Validate(task, processItem);
_taskValidatorFactory(EngineTaskValidatorKinds.RequestIsForTheMostRecentState).Validate(task, processItem);
if (String.IsNullOrWhiteSpace(processItem.Lock?.LockedToPrincipalId) || processItem.Lock?.LockExpirationUtc < DateTime.UtcNow)
{
// the current user doesn't have a valid lock. There's no reason to apply any mutation.
return;
}
processItem.ApplyMutation(new UnlockProcessItemMutation()
{
});
_processItemEventStore.StoreUnsavedMutations((IProcessItemEventContainer)processItem,
(processItemMutationId, mutationDateTimeUtc) =>
{
processItem.SetProcessItemState(processItemMutationId, mutationDateTimeUtc);
});
_eventQueue.PublishEvent(new EventNotification()
{
ProcessItemId = unlockTask.ProcessItemId,
NotificationKind = EventNotificationKinds.ProcessItemUnlock
});
}
/// <summary>
/// Executes the task.
/// </summary>
/// <param name="task">The task.</param>
/// <exception cref="NotImplementedException"></exception>
public void ExecuteTask(IEngineTask task)
{
// Check if task can be executed
if (!task.CanBeExecuted())
{
task.AddMessage($"The task cannot be executed.", MessageSeverity.Error);
if (task.ParentJob.FailIfAnyTaskHasError)
{
throw new EngineException(logger, $"The task cannot be executed. This job was aborted.");
}
else
{
return;
}
}
// Execute task
if (TaskStarted != null)
{
TaskStarted.Invoke((Guid)task.EntityId, (Guid)task.InstanceID);
}
task.Start();
// Stop task
task.Stop();
if (task.HasErrors)
{
task.AddMessage($"The task (instance: {task.InstanceID}) was not executed cause one or more errors occurs.", MessageSeverity.Error);
if (task.ParentJob.FailIfAnyTaskHasError)
{
if (TaskFinished != null)
{
TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, false);
}
throw new EngineException(logger, $"The task (instance: {task.InstanceID}) was not executed cause one or more errors occurs. This job was aborted.");
}
}
else if (task.HasWarnings)
{
task.AddMessage($"The task (instance: {task.InstanceID}) was executed but one or more warning occurs.", MessageSeverity.Warning);
if (task.ParentJob.FailIfAnyTaskHasWarning)
{
if (TaskFinished != null)
{
TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, false);
}
throw new EngineException(logger, $"The task (instance: {task.InstanceID}) was executed but one or more warning occurs. This job was aborted.");
}
}
if (TaskFinished != null)
{
TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, true);
}
}
public void Enqueue(IEngineTask task)
{
_loggingAdapter.WriteEntry(new LogEntry(LoggingEventType.Information, "Enqueuing task: {task}",
new Dictionary <string, object>()
{
{ "task", JsonConvert.SerializeObject(task) }
}));
Queue.Enqueue(task);
}
/// <summary>
/// Process the specified task. It will be processed either now,
/// or queued to process on the thread pool.
/// </summary>
/// <param name="task">The task to process.</param>
/// <param name="group">The group this task belongs to.</param>
public void ProcessTask(IEngineTask task, TaskGroup group)
{
lock (this)
{
_activeTasks++;
}
if (group != null)
group.TaskStarting();
var item = new PoolItem(this, task, group);
ThreadPool.QueueUserWorkItem(item.ThreadPoolCallback);
}
public void Validate(IEngineTask task, IProcessItem processItem)
{
if (processItem.Lock == null || processItem.Lock.LockExpirationUtc < DateTime.UtcNow)
{
return;
}
if (!Equals(processItem.Lock.LockedToPrincipalId, task.PrincipalId))
{
throw new ProcessItemLockedException(processItem.ProcessItemId, task.PrincipalId, processItem.Lock.LockExpirationUtc);
}
}
public void Validate(IEngineTask task, IProcessItem processItem)
{
if (!(task is IActionTask actionTask))
{
// don't validate a non-action task
return;
}
if (!actionTask.ExpectedLastMutationId.Equals(processItem.ItemState?.ProcessItemMutationId))
{
throw new ProcessItemStateChangedException(processItem.ProcessItemId, actionTask.ExpectedLastMutationId, processItem.ItemState.ProcessItemMutationId);
}
}
/// <summary>
/// Process the specified task. It will be processed either now,
/// or queued to process on the thread pool.
/// </summary>
/// <param name="task">The task to process.</param>
/// <param name="group">The group this task belongs to.</param>
public void ProcessTask(IEngineTask task, TaskGroup group)
{
lock (this)
{
_activeTasks++;
}
if (group != null)
{
group.TaskStarting();
}
var item = new PoolItem(this, task, group);
ThreadPool.QueueUserWorkItem(item.ThreadPoolCallback);
}
public bool TryDequeueNext(out IEngineTask task)
{
var success = Queue.TryDequeue(out task);
if (success)
{
_loggingAdapter.WriteEntry(new LogEntry(LoggingEventType.Information, "Dequeuing task: {task}",
new Dictionary <string, object>()
{
{ "task", JsonConvert.SerializeObject(task) }
}));
}
//else
//{
// _loggingAdapter.WriteEntry(
// new LogEntry(LoggingEventType.Information, "Attempt to dequeue task found no tasks."));
//}
return(success);
}
private bool CanExecute(IEngineTask task)
{
bool doProduce = true;
lock (firstLoadSyncRoot)
{
doProduce = allFirstLoadsDone;
if (!doProduce && task.DirtyNode.Node is IActiveNode)
{
if (--countOfFirstLoadsOutstanding == 0)
{
doProduce = allFirstLoadsDone = true;
}
}
}
return(doProduce);
}
public void Execute(IEngineTask task)
{
if (CanExecute(task))
{
enginePipeline.Produce(task);
}
}
/// <summary>
/// Construct a pool item.
/// </summary>
/// <param name="owner">The owner of this task.</param>
/// <param name="task">The task to execute.</param>
/// <param name="group">The group that this task belongs to.</param>
public PoolItem(EngineConcurrency owner, IEngineTask task, TaskGroup group)
{
this.owner = owner;
this.task = task;
this.group = group;
}
private bool CanExecute(IEngineTask task)
{
bool doProduce = true;
lock (firstLoadSyncRoot)
{
doProduce = allFirstLoadsDone;
if (!doProduce && task.DirtyNode.Node is IActiveNode)
{
if (--countOfFirstLoadsOutstanding == 0)
{
doProduce = allFirstLoadsDone = true;
}
}
}
return doProduce;
}
public void ProcessTask(IEngineTask task, TaskGroup group)
{
lock (this)
{
this._x16f1ed41ac673568++;
if (group != null)
{
group.TaskStarting();
if (0 != 0)
{
return;
}
}
}
PoolItem item = new PoolItem(this, task, group);
ThreadPool.QueueUserWorkItem(new WaitCallback(item.ThreadPoolCallback));
}
/// <summary>
/// Process the specified task. It will be processed either now,
/// or queued to process on the thread pool. No group is assigned.
/// </summary>
/// <param name="task">The task to process.</param>
public void ProcessTask(IEngineTask task)
{
ProcessTask(task, null);
}
/// <summary>
/// Process the specified task. It will be processed either now,
/// or queued to process on the thread pool. No group is assigned.
/// </summary>
/// <param name="task">The task to process.</param>
public void ProcessTask(IEngineTask task)
{
ProcessTask(task, null);
}
public async Task ProcessActionTask(IEngineTask task)
{
var actionTask = task as ActionTask;
var process = await _processStore.GetProcessAsync(actionTask.ProcessId);
var processItem = await _processItemEventStore.GetProcessItemAsync(actionTask.ProcessItemId);
if (processItem == null)
{
var action = process.StartActions[actionTask.ActionId];
if (action == null)
{
throw new Exception("Start action not found, and process item is null.");
}
processItem = new ProcessItem();
processItem.ApplyMutation(new CreationActionProcessItemMutation()
{
ProcessItemId = actionTask.ProcessItemId,
ActionId = actionTask.ActionId,
TargetStepId = action.ArrivalStep,
PropertyChanges = actionTask.PropertyChanges
});
_processItemEventStore.StoreUnsavedMutations((IProcessItemEventContainer)processItem,
(processItemMutationId, mutationDateTimeUtc) =>
{
processItem.SetProcessItemState(processItemMutationId, mutationDateTimeUtc);
});
}
else
{
_taskValidatorFactory(EngineTaskValidatorKinds.CurrentUserCanLockProcessItem).Validate(task, processItem);
_taskValidatorFactory(EngineTaskValidatorKinds.RequestIsForTheMostRecentState).Validate(task, processItem);
if (process.Steps.TryGetValue(processItem.CurrentStepId, out var step))
{
if (step.Actions.TryGetValue(actionTask.ActionId, out var action))
{
processItem.ApplyMutation(new ActionProcessItemMutation()
{
ActionId = actionTask.ActionId,
TargetStepId = action.ArrivalStep,
PropertyChanges = actionTask.PropertyChanges
});
_processItemEventStore.StoreUnsavedMutations((IProcessItemEventContainer)processItem,
(processItemMutationId, mutationDateTimeUtc) =>
{
processItem.SetProcessItemState(processItemMutationId, mutationDateTimeUtc);
});
}
else
{
throw new ActionNotFoundException(actionTask.ProcessItemId, actionTask.ProcessId, actionTask.PrincipalId, processItem.CurrentStepId, actionTask.ActionId);
}
}
else
{
throw new Exception("Step not found.");
}
}
_eventQueue.PublishEvent(new EventNotification()
{
ProcessId = actionTask.ProcessId,
ProcessItemId = actionTask.ProcessItemId,
ActionId = actionTask.ActionId,
NotificationKind = EventNotificationKinds.Action
});
}
public void Execute(IEngineTask task)
{
core.Pipeline.Produce(task);
}
/// <summary>
/// Construct a pool item.
/// </summary>
/// <param name="owner">The owner of this task.</param>
/// <param name="task">The task to execute.</param>
/// <param name="group">The group that this task belongs to.</param>
public PoolItem(EngineConcurrency owner, IEngineTask task, TaskGroup group)
{
this.owner = owner;
this.task = task;
this.group = group;
}
/// <summary>
/// Construct a pool item.
/// </summary>
/// <param name="owner">The owner of this task.</param>
/// <param name="task">The task to execute.</param>
/// <param name="group">The group that this task belongs to.</param>
public PoolItem(EngineConcurrency owner, IEngineTask task, TaskGroup group)
{
_owner = owner;
_task = task;
_group = group;
}
public void Execute(IEngineTask task)
{
core.Pipeline.Produce(task);
}
public PoolItem(EngineConcurrency owner, IEngineTask task, TaskGroup group)
{
this._x071bde1041617fce = owner;
this._x801bd3a7d5412d70 = task;
this._xe2c9497bf778cd2b = group;
}
/// <summary>
/// Construct a pool item.
/// </summary>
/// <param name="owner">The owner of this task.</param>
/// <param name="task">The task to execute.</param>
/// <param name="group">The group that this task belongs to.</param>
public PoolItem(EngineConcurrency owner, IEngineTask task, TaskGroup group)
{
_owner = owner;
_task = task;
_group = group;
}
