public TaskMessage(IReadWritableTaskState taskState, ITransaction transaction, SafeDisposableActions onCompleteActions, ILogger logger)
{
TaskStateWritable = taskState;
Transaction = transaction;
OnCompleteActions = onCompleteActions;
Logger = logger;
}
public TaskContext(bool isStateful, SafeDisposableActions onCompleteActions, IReadWritableTaskState state, IStateManager stateManager)
{
_isStateful = isStateful;
OnCompleteActions = onCompleteActions;
TaskStateWritable = state;
_stateManager = stateManager;
}
public static bool ReleaseTaskWithDeferFlag(this TaskContext context, IStateManager steManager)
{
context.Logger.Trace($"Defer task from {context.State.DeferredCount}");
//IStateManager steManager = Bus.StateManager;
IReadWritableTaskState task = context.TaskStateWritable;
var nextDeferVal = task.DeferredCount + 1;
if (nextDeferVal > 3)
{
var pendingTasks =
steManager.CountPendingTasksForProcess(context.ProcessExecutionContext.ProcessState.Id);
var deferLimitExceeded = pendingTasks <= nextDeferVal; //(pendingTasks - 1) <= nextDeferVal;
if (deferLimitExceeded) //skip itself
{
context.Logger.Warn(
$"Can't further defer task because only {pendingTasks} tasks remaining and current task is deferred {task.DeferredCount} times. Check circular dependency");
return(false);
}
}
task.DeferredCount = nextDeferVal;
task.UpdatedOn = DateTime.UtcNow;
//task.Status = ResultStatus.Empty;
task.IsFinished = false;
task.IsStopped = false;
task.NodeKey = null;
steManager.UpdateTask(task, context.Transaction, true);
context.Logger.Info($"Task deferred {nextDeferVal} time");
//context.Transaction.Commit();
return(true);
}
public static void MarkTaskStarted(this TaskContext context, IStateManager steManager)
{
//IStateManager steManager = Bus.StateManager;
IReadWritableTaskState task = context.TaskStateWritable;
task.StartedOn = DateTime.UtcNow;
task.UpdatedOn = DateTime.UtcNow;
steManager.UpdateTask(task, context.Transaction);
}
internal static void PreserveNextState(this TaskContext context, string state, IStateManager steManager, string taskState = null)
{
//IStateManager steManager = Bus.StateManager;
List <KeyValuePair <string, string> > statList = new List <KeyValuePair <string, string> >();
statList.Add(new KeyValuePair <string, string>(KeyConstants.TaskNextState, state));
statList.Add(new KeyValuePair <string, string>(KeyConstants.TaskPreviousState, context.NextState));
steManager.SaveTaskStates(context.State.Id, context.State.ProcessId, statList);
IReadWritableTaskState task = context.TaskStateWritable;
var next = context.State.CurrentState ?? context.NextState;
context.NextState = state; //string.Empty;
context.PrevState = next;
task.CurrentState = taskState ?? state;
steManager.UpdateTask(task, context.Transaction);
}
public static bool MarkTaskStatus(this TaskContext context, CompletionStatus completionStatus, ResultStatus result, string reason, IStateManager steManager)
{
try
{
context.Logger.Info(reason);
//IStateManager steManager = Bus.StateManager;
//todo:
IReadWritableTaskState task = context.TaskStateWritable;
var isDone = completionStatus.IsDone();
if (isDone)
{
task.IsFinished = true;
task.CompletedOn = DateTime.UtcNow;
}
if (result.Id == ResultStatus.Error.Id)
{
task.FailedCount = task.FailedCount + 1;
}
task.UpdatedOn = DateTime.UtcNow;
task.Status = result;
steManager.UpdateTask(task, context.Transaction, isDone);
if (isDone)
{
context.Logger.Info("Done");
//context.Transaction.Commit();
}
return(true);
}
catch (FrameworkException e)
{
context.Logger.Error("FrameworkException while updating task status from node {node}, Complete: {complete}, Result: {result}, Reason: {reason} with error {error}", NodeSettings.Instance.Name, completionStatus.Name, result.Name, reason, e);
return(false);
}
catch (Exception e)
{
context.Logger.Error("Failed to update task status from node {node}, Complete: {complete}, Result: {result}, Reason: {reason} with error {error}", NodeSettings.Instance.Name, completionStatus.Name, result.Name, reason, e);
return(false);
}
}
public void Handle <T>(IEnumerable <T> volume, IProcessExecutionContextWithVolume processContext, CancellationToken token)
{
if (volume == null)
{
processContext.Logger.Info("No volume returned");
return;
}
bool hasVolume = false;
var serializer = _serializersFactory.GetSerializer <T>();
int currentCount = 0;
int batchSize = 100;
try
{
Bus.HandleDbCommand(new DbAction(DbActions.Transaction, () => //create transaction in Db Bus pipeline
{
var volumeDeletedCount = ExecuteNonQuery(Constant.SQLDeleteProcessVolume, processContext.ProcessState.Id);
if (volumeDeletedCount > 0)
{
processContext.Logger.Warn($"Existing volume {volumeDeletedCount} deleting");
}
}));
//using (var unitOfWork = ) //IsolationLevel.Snapshot //todo check isolation level with db team, is it enabled by default
{
foreach (var v in volume)
{
var payLoad = serializer.SerializeToString(v);
IReadWritableTaskState state = CreateNew();
state.Payload = payLoad;
state.ProcessId = processContext.ProcessState.Id;
state.CurrentState = ResultStatus.Empty.Name;
currentCount++;
if (currentCount >= batchSize)
{
token.ThrowIfCancellationRequested();
hasVolume = true;
//Persist();
currentCount = 0;
//Clear();//remove persisted items
}
}
//if (Entity.Count>0)
{
token.ThrowIfCancellationRequested();
hasVolume = true;
// Persist();
}
//Commit();
}
}
finally
{
//dispose / rollback
}
if (hasVolume)
{
processContext.SetVolumeGenerated();
}
}
