public bool TryIncrement(TaskQueueReason reason)
{
if (reason == TaskQueueReason.TaskContinuation)
{
lock (lockObject)
{
if (CanQueueTask(reason))
{
continuationsCount++;
return(true);
}
return(maxRunningContinuationsCount == 0);
}
}
else if (reason == TaskQueueReason.PullFromQueue)
{
lock (lockObject)
{
if (CanQueueTask(reason))
{
tasksCount++;
return(true);
}
return(maxRunningTasksCount == 0);
}
}
throw new InvalidOperationException(string.Format("Неизвестный тип TaskQueueReason: {0}", reason));
}
public bool CanQueueTask(TaskQueueReason reason)
{
if (reason == TaskQueueReason.TaskContinuation)
{
if (maxRunningContinuationsCount == 0)
{
return(true);
}
return(continuationsCount < maxRunningContinuationsCount);
}
if (reason == TaskQueueReason.PullFromQueue)
{
if (maxRunningTasksCount == 0)
{
return(true);
}
if (maxRunningContinuationsCount == 0)
{
return((continuationsCount + tasksCount) < (maxRunningTasksCount));
}
else
{
return((tasksCount) < (maxRunningTasksCount));
}
}
throw new InvalidOperationException(string.Format("Неизвестный тип TaskQueueReason: {0}", reason));
}
public void TaskFinished([NotNull] string taskId, TaskQueueReason taskQueueReason, bool taskIsBeingTraced, LocalTaskProcessingResult result)
{
lock (lockObject)
hashtable.Remove(taskId);
localQueueTaskCounter.Decrement(taskQueueReason);
metricsContext.Meter("TaskIsFinished").Mark();
if (taskIsBeingTraced)
{
InfrastructureTaskTraceContext.Finish();
RemoteTaskHandlingTraceContext.Finish(result, rtqInternals.GlobalTime.UpdateNowTimestamp().Ticks);
}
}
public TaskWrapper([NotNull] string taskId,
TaskQueueReason taskQueueReason,
bool taskIsBeingTraced,
[NotNull] HandlerTask handlerTask,
[NotNull] LocalTaskQueue localTaskQueue,
[NotNull] ILog logger)
{
this.taskId = taskId;
this.taskQueueReason = taskQueueReason;
this.taskIsBeingTraced = taskIsBeingTraced;
this.handlerTask = handlerTask;
this.localTaskQueue = localTaskQueue;
this.logger = logger;
finished = false;
}
public void Decrement(TaskQueueReason reason)
{
if (reason == TaskQueueReason.TaskContinuation)
{
lock (lockObject)
{
continuationsCount--;
}
}
else if (reason == TaskQueueReason.PullFromQueue)
{
lock (lockObject)
{
tasksCount--;
}
}
else
{
throw new InvalidOperationException(string.Format("Неизвестный тип TaskQueueReason: {0}", reason));
}
}
public HandlerTask(
[NotNull] TaskIndexRecord taskIndexRecord,
TaskQueueReason reason,
[CanBeNull] TaskMetaInformation taskMeta,
IRtqTaskHandlerRegistry taskHandlerRegistry,
IRtqInternals rtqInternals)
{
this.taskIndexRecord = taskIndexRecord;
this.reason = reason;
this.taskMeta = taskMeta;
this.taskHandlerRegistry = taskHandlerRegistry;
serializer = rtqInternals.Serializer;
taskProducer = rtqInternals.TaskProducer;
handleTaskCollection = rtqInternals.HandleTaskCollection;
remoteLockCreator = rtqInternals.RemoteLockCreator;
taskExceptionInfoStorage = rtqInternals.TaskExceptionInfoStorage;
handleTasksMetaStorage = rtqInternals.HandleTasksMetaStorage;
taskMinimalStartTicksIndex = rtqInternals.TaskMinimalStartTicksIndex;
rtqProfiler = rtqInternals.Profiler;
globalTime = rtqInternals.GlobalTime;
taskTtl = rtqInternals.TaskTtl;
logger = rtqInternals.Logger.ForContext(nameof(HandlerTask));
taskShardMetricsContext = MetricsContext.For($"Shards.{taskIndexRecord.TaskIndexShardKey.TaskTopic}.{taskIndexRecord.TaskIndexShardKey.TaskState}.Tasks");
}
private LocalTaskQueueingResult DoTryQueueTask([NotNull] TaskIndexRecord taskIndexRecord, [CanBeNull] TaskMetaInformation taskMeta, TaskQueueReason taskQueueReason, bool taskIsBeingTraced)
{
var taskIsSentToThreadPool = false;
if (taskMeta != null && !taskHandlerRegistry.ContainsHandlerFor(taskMeta.Name))
{
return(LocalTaskQueueingResult.TaskIsSkippedResult);
}
if (taskMeta == null && taskIndexRecord.MinimalStartTicks > (Timestamp.Now - HandlerTask.MaxAllowedIndexInconsistencyDuration).Ticks)
{
logger.Debug("Мета для задачи TaskId = {RtqTaskId} еще не записана, ждем {MaxAllowedIndexInconsistencyDuration}",
new { HandlerTask.MaxAllowedIndexInconsistencyDuration, RtqTaskId = taskIndexRecord.TaskId });
return(LocalTaskQueueingResult.TaskIsSkippedResult);
}
if (!localQueueTaskCounter.TryIncrement(taskQueueReason))
{
return(LocalTaskQueueingResult.QueueIsFullResult);
}
try
{
var handlerTask = new HandlerTask(taskIndexRecord, taskQueueReason, taskMeta, taskHandlerRegistry, rtqInternals);
lock (lockObject)
{
if (stopped)
{
return(LocalTaskQueueingResult.QueueIsStoppedResult);
}
if (hashtable.ContainsKey(taskIndexRecord.TaskId))
{
return(LocalTaskQueueingResult.TaskIsSkippedResult);
}
var taskWrapper = new TaskWrapper(taskIndexRecord.TaskId, taskQueueReason, taskIsBeingTraced, handlerTask, this, logger);
var asyncTask = Task.Factory.StartNew(taskWrapper.Run);
taskIsSentToThreadPool = true;
metricsContext.Meter("TaskIsSentToThreadPool").Mark();
if (!taskWrapper.Finished)
{
hashtable.Add(taskIndexRecord.TaskId, asyncTask);
}
}
}
finally
{
if (!taskIsSentToThreadPool)
{
localQueueTaskCounter.Decrement(taskQueueReason);
}
}
return(LocalTaskQueueingResult.SuccessResult);
}
public LocalTaskQueueingResult TryQueueTask([NotNull] TaskIndexRecord taskIndexRecord, [CanBeNull] TaskMetaInformation taskMeta, TaskQueueReason taskQueueReason, bool taskIsBeingTraced)
{
using (var infrastructureTraceContext = new InfrastructureTaskTraceContext(taskIsBeingTraced))
{
var result = DoTryQueueTask(taskIndexRecord, taskMeta, taskQueueReason, taskIsBeingTraced);
infrastructureTraceContext.Finish(result.TaskIsSentToThreadPool);
return(result);
}
}
