/// <inheritdoc />
public void Add(Guid taskId, ITaskSummary summary)
{
Trace.WriteLine("ENTER: Adding summary '{0}' for task '{1}' ...".FormatInvariant(summary, taskId));
if (summary == null)
{
throw new ArgumentNullException(nameof(summary));
}
string taskIdAsString = RedisConverter.ToString(taskId);
byte[] content = this.serializer.Serialize(summary);
if (this.serializer.CanDetermineEntityTypeFromContent)
{
this.provider.SetHashValue(RedisTaskSummaryRepository.RedisTaskSummaryHashKey, taskIdAsString, content);
}
else
{
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.SetHashValue(RedisTaskSummaryRepository.RedisTaskSummaryHashKey, taskIdAsString, content);
transaction.SetHashValue(RedisTaskSummaryRepository.RedisTaskSummaryHashKey, taskIdAsString + "$Type", RedisConverter.ToString(summary.GetType(), false));
transaction.Commit();
}
}
Trace.WriteLine("EXIT: Summary '{0}' added for task '{1}'.".FormatInvariant(summary, taskId));
}
/// <inheritdoc />
public void Add(Guid taskId, ITask task)
{
Trace.WriteLine("ENTER: Adding task '{0}' with ID '{1}' ...".FormatInvariant(task, taskId));
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
string taskIdAsString = RedisConverter.ToString(taskId);
if (this.serializer.CanDetermineEntityTypeFromContent)
{
this.provider.SetHashValue(RedisTaskRepository.TasksHashKey, taskIdAsString, this.serializer.Serialize(task));
}
else
{
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.SetHashValue(RedisTaskRepository.TasksHashKey, taskIdAsString, this.serializer.Serialize(task));
transaction.SetHashValue(RedisTaskRepository.TasksHashKey, taskIdAsString + "$Type", RedisConverter.ToString(task.GetType(), true));
transaction.Commit();
}
}
Trace.WriteLine("EXIT: Task '{0}' with ID '{1}' added.".FormatInvariant(task, taskId));
}
private void AddOrUpdate(IScheduledTask scheduledTask)
{
string taskIdAsString = RedisConverter.ToString(scheduledTask.Id);
if (this.serializer.CanDetermineEntityTypeFromContent)
{
this.provider.SetHashValues(
RedisScheduledTaskRepository.ScheduledTasksHashKey,
new Dictionary <string, byte[]>()
{
{ taskIdAsString + "$Content", this.serializer.Serialize(scheduledTask) },
{ taskIdAsString + "$RecurrenceDefinition", this.serializer.Serialize(scheduledTask.Schedule) }
});
}
else
{
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.SetHashValue(RedisScheduledTaskRepository.ScheduledTasksHashKey, taskIdAsString + "$Content", this.serializer.Serialize(scheduledTask));
transaction.SetHashValue(RedisScheduledTaskRepository.ScheduledTasksHashKey, taskIdAsString + "$Type", RedisConverter.ToString(scheduledTask.GetType(), false));
transaction.SetHashValue(RedisScheduledTaskRepository.ScheduledTasksHashKey, taskIdAsString + "$RecurrenceDefinition", this.serializer.Serialize(scheduledTask.Schedule));
transaction.SetHashValue(RedisScheduledTaskRepository.ScheduledTasksHashKey, taskIdAsString + "$RecurrenceDefinition$Type", RedisConverter.ToString(scheduledTask.Schedule.GetType(), false));
transaction.Commit();
}
}
}
/// <inheritdoc />
public void Complete(Guid taskId, DateTime timestampUtc)
{
Trace.WriteLine("ENTER: Record task '{0}' completed ...".FormatInvariant(taskId));
string taskIdAsString = RedisConverter.ToString(taskId);
string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(taskIdAsString);
RedisTaskRuntimeInfo taskInfo = this.GetById(taskId, false);
taskInfo.Percentage = 100;
taskInfo.Status = TaskStatus.Success;
taskInfo.CompletedUtc = timestampUtc;
byte[] content = this.serializer.Serialize(taskInfo);
using (IRedisTransaction transaction = this.Provider.CreateTransaction())
{
transaction.RemoveKey(entityKey);
transaction.RemoveFromList(RedisTaskRuntimeInfoRepository.ActiveTasksList, taskIdAsString);
transaction.SetHashValue(RedisTaskRuntimeInfoRepository.ArchiveTasksHash, taskIdAsString, content);
transaction.Commit();
}
Trace.WriteLine("EXIT: Task '{0}' completed recorded.".FormatInvariant(taskId));
}
/// <inheritdoc />
public void Fail(Guid taskId, DateTime timestampUtc, Exception error)
{
if (error == null)
{
throw new ArgumentNullException(nameof(error));
}
Trace.WriteLine("ENTER: Record task '{0}' failed with error '{1}' ...".FormatInvariant(taskId, error.Message));
string taskIdAsString = RedisConverter.ToString(taskId);
string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(taskIdAsString);
RedisTaskRuntimeInfo taskInfo = this.GetById(taskId, false);
taskInfo.Status = TaskStatus.Failed;
taskInfo.CompletedUtc = timestampUtc;
taskInfo.Error = error.ToString();
byte[] content = this.serializer.Serialize(taskInfo);
using (IRedisTransaction transaction = this.Provider.CreateTransaction())
{
transaction.RemoveKey(entityKey);
transaction.RemoveFromList(RedisTaskRuntimeInfoRepository.ActiveTasksList, taskIdAsString);
transaction.AddToList(RedisTaskRuntimeInfoRepository.FailedTasksList, taskIdAsString);
transaction.SetHashValue(RedisTaskRuntimeInfoRepository.ArchiveTasksHash, taskIdAsString, content);
transaction.Commit();
}
Trace.WriteLine("EXIT: Task '{0}' failed with error '{1}' recorded.".FormatInvariant(taskId, error.Message));
}
/// <inheritdoc />
public void Push(IUniqueMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (string.IsNullOrEmpty(message.MessageUniqueId))
{
throw new ArgumentException("MessageUniqueId is null or empty.".FormatInvariant(message), "message");
}
if (this.isDisposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
Trace.WriteLine("ENTER: Adding message {0}:{1} to list '{2}' ...".FormatInvariant(message.GetType().Name, message.MessageUniqueId, RedisTaskProcessorMessageQueue.MessageQueueListKey));
byte[] content = this.serializer.Serialize(message);
if (this.serializer.CanDetermineEntityTypeFromContent)
{
this.provider.AddToList(RedisTaskProcessorMessageQueue.MessageQueueListKey, content);
}
else
{
string messageUniqueId = string.Join("$", message.GetType().Name, message.MessageUniqueId);
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.AddToList(RedisTaskProcessorMessageQueue.MessageQueueListKey, messageUniqueId);
transaction.SetHashValue(RedisTaskProcessorMessageQueue.MessageQueueContentKey, messageUniqueId, content);
transaction.SetHashValue(RedisTaskProcessorMessageQueue.MessageQueueContentKey, messageUniqueId + "$Type", RedisConverter.ToString(message.GetType(), false));
transaction.Commit();
}
}
this.provider.PublishMessage(RedisTaskProcessorMessageQueue.MasterCommandsChannel, string.Empty);
Trace.WriteLine("EXIT: Message {0}:{1} added to list '{2}'.".FormatInvariant(message.GetType().Name, message.MessageUniqueId, RedisTaskProcessorMessageQueue.MessageQueueListKey));
}
