/// <summary> /// Submits a task with the specified parameters. /// </summary> /// <param name="taskId">The unique ID of the task.</param> /// <param name="task">The task to submit.</param> /// <param name="summary">The summary to associated with the task, if any.</param> /// <param name="priority">The priority of the task.</param> internal void SubmitTask(Guid taskId, ITask task, ITaskSummary summary, TaskPriority priority) { if (task == null) { throw new ArgumentNullException("task"); } Trace.WriteLine("ENTER: Submitting '{0}' with priority '{1}' ...".FormatInvariant(task.GetType().Name, priority)); string pollingQueueKey = this.configuration.GetPollingQueueKey(task.GetType()); this.repository.Tasks.Add(taskId, task); if (summary != null) { this.repository.TaskSummary.Add(taskId, summary); } ITaskRuntimeInfo taskInfo = this.repository.TaskRuntimeInfo.Create(taskId, task.GetType(), this.dateTimeProvider.UtcNow, priority, pollingQueueKey); this.repository.TaskRuntimeInfo.Add(taskInfo); ITaskMessageBusSender taskMessageBus = this.messageBus.Tasks.GetSender(task.GetType()); taskMessageBus.NotifyTaskSubmitted(taskId, this.dateTimeProvider.UtcNow, !string.IsNullOrEmpty(pollingQueueKey)); Trace.WriteLine("EXIT: Task '{0}' submitted with ID '{1}' ...".FormatInvariant(task, taskId)); }
public void StartPollingQueueTask() { ITaskRuntimeInfo taskInfo1 = this.Repository.Add("Test"); Guid taskProcessorId = Guid.NewGuid(); DateTime timestampUtc = DateTime.UtcNow; this.Repository.Start(taskInfo1.TaskId, taskProcessorId, timestampUtc); ITaskRuntimeInfo taskInfo2 = this.Repository.GetById(taskInfo1.TaskId); Assert.AreEqual(TaskStatus.InProgress, taskInfo2.Status); Assert.AreEqual(taskProcessorId, taskInfo2.TaskProcessorId); Assert.AreEqual(timestampUtc, taskInfo2.StartedUtc); Assert.IsTrue(this.Repository.CheckIsPendingOrActive(taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPending(false).Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPending(true).Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPendingAndActive()[TaskStatus.Pending].Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsTrue(this.Repository.GetPendingAndActive()[TaskStatus.InProgress].Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsTrue(this.Repository.GetActive().Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetFailed().Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetArchive().Any(t => t.TaskId == taskInfo1.TaskId)); }
/// <inheritdoc /> public void CancelTask(Guid taskId) { Trace.WriteLine("ENTER: Cancelling task '{0}' ...".FormatInvariant(taskId)); Lazy <DateTime> timestampUtc = new Lazy <DateTime>(() => this.dateTimeProvider.UtcNow); ITaskRuntimeInfo taskInfo = this.repository.TaskRuntimeInfo.GetById(taskId); if (taskInfo == null) { throw new KeyNotFoundException("Task '{0}' was not found.".FormatInvariant(taskId)); } switch (taskInfo.Status) { case TaskStatus.Canceled: case TaskStatus.Failed: case TaskStatus.Success: throw new InvalidOperationException("Task '{0}' status is {1} and will not be canceled.".FormatInvariant(taskId, taskInfo.Status)); } ITaskMessageBusSender taskMessageBus = this.messageBus.Tasks.GetSender(taskInfo.TaskType); taskMessageBus.NotifyTaskCancelRequest(taskId, timestampUtc.Value); this.repository.TaskRuntimeInfo.RequestCancel(taskId, timestampUtc.Value); Trace.WriteLine("EXIT: Task '{0}' canceled.".FormatInvariant(taskId)); }
private static bool CanExecuteTask(ITaskRuntimeInfo pendingTaskInfo, ITaskProcessorRuntimeInfo processorInfo, IEnumerable <ITaskRuntimeInfo> activeTaskInfo) { Trace.WriteLine("ENTER: Checking if task processor '{0}' can execute task '{1}' ...".FormatInvariant(processorInfo.TaskProcessorId, pendingTaskInfo.TaskId)); if (processorInfo.Configuration.Tasks.MaxWorkers.HasValue && activeTaskInfo.AtLeast(processorInfo.Configuration.Tasks.MaxWorkers.Value, t => t.TaskProcessorId == processorInfo.TaskProcessorId)) { Trace.WriteLine("EXIT: Task processor '{0}' cannot execute task '{1}' because max workers threshold {2} is reached.".FormatInvariant(processorInfo.TaskProcessorId, pendingTaskInfo.TaskId, processorInfo.Configuration.Tasks.MaxWorkers.Value)); return(false); } ITaskJobConfiguration taskJobConfig = processorInfo.Configuration.Tasks[pendingTaskInfo.TaskType]; if ((taskJobConfig != null) && taskJobConfig.MaxWorkers.HasValue && activeTaskInfo.AtLeast(taskJobConfig.MaxWorkers.Value, tt => (tt.TaskType == taskJobConfig.TaskType) && (tt.TaskProcessorId == processorInfo.TaskProcessorId))) { Trace.WriteLine("Task processor '{0}' cannot execute task '{1}' because max workers threshold {2} for task type '{3}' is reached.".FormatInvariant(processorInfo.TaskProcessorId, pendingTaskInfo.TaskId, taskJobConfig.MaxWorkers.Value, pendingTaskInfo.TaskType.Name)); return(false); } Trace.WriteLine("EXIT: Task processor '{0}' can execute task '{1}'.".FormatInvariant(processorInfo.TaskProcessorId, pendingTaskInfo.TaskId)); return(true); }
public void ChooseProcessorForTask() { ITaskProcessorRuntimeInfo processorInfo1 = new FakeTaskProcessorRuntimeInfo() { TaskProcessorId = Guid.NewGuid() }; this.Repository.TaskProcessorRuntimeInfo.Add(processorInfo1); ITaskProcessorRuntimeInfo processorInfo2 = new FakeTaskProcessorRuntimeInfo() { TaskProcessorId = Guid.NewGuid() }; this.Repository.TaskProcessorRuntimeInfo.Add(processorInfo2); ITaskRuntimeInfo activeTaskInfo = this.Repository.TaskRuntimeInfo.Create(); this.Repository.TaskRuntimeInfo.Add(activeTaskInfo); this.Repository.TaskRuntimeInfo.Start(activeTaskInfo.TaskId, processorInfo1.TaskProcessorId, DateTime.UtcNow); var result = this.TaskDistributor.ChooseProcessorForTask(new FakeTaskRuntimeInfo()); Assert.AreEqual(processorInfo2, result.First()); Assert.AreEqual(processorInfo1, result.Last()); }
public void StartTaskWithTaskJobSettings() { this.Configuration.Get <FakeTask>().HasTaskJobSettings = true; ITaskJobSettings settings = new FakeTaskJobSettings(); this.Repository.TaskJobSettings.Set <FakeTask>(settings); ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create(); FakeTask task = new FakeTask(); this.Repository.Tasks.Add(taskInfo.TaskId, task); this.Repository.TaskRuntimeInfo.Add(taskInfo); using (FakeTaskWorker taskWorker = new FakeTaskWorker()) { this.TaskWorkerFactory.PredefineResult(taskWorker, f => f.CreateTaskWorker(task)); this.DateTimeProvider.UtcNow = DateTime.UtcNow; this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId); this.TaskWorkerFactory.AssertMethodCallOnceWithArguments(f => f.CreateTaskWorker(task)); taskWorker.AssertMethodCallOnce(w => w.StartTask(task, settings)); } }
public void CancelTask() { ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create(); this.Repository.TaskRuntimeInfo.Add(taskInfo); ITask task = new FakeTask(); this.Repository.Tasks.Add(taskInfo.TaskId, task); using (FakeTaskWorker taskWorker = new FakeTaskWorker()) { this.TaskWorkerFactory.PredefineResult(taskWorker, f => f.CreateTaskWorker(task)); taskWorker.PredefineMethodCall(w => w.StartTask(task, null), () => Thread.Sleep(TimeSpan.FromSeconds(1))); ThreadPool.QueueUserWorkItem(_ => this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId)); Thread.Sleep(TimeSpan.FromSeconds(0.5)); this.DateTimeProvider.UtcNow = DateTime.UtcNow; this.MessageBus.Tasks.NotifyTaskCancelRequest(taskInfo.TaskId, this.DateTimeProvider.UtcNow); Thread.Sleep(TimeSpan.FromSeconds(1.5)); taskWorker.AssertMethodCallOnce(w => w.CancelTask()); taskWorker.AssertMethodCallOnce(w => w.Dispose()); } this.MessageBus.Tasks.Receiver.AssertMethodCallOnce(mb => mb.UnsubscribeFromAllChannels()); }
public void Fail() { ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Add(); ITask task = new FakeTask(); this.Repository.Tasks.Add(taskInfo.TaskId, task); this.DateTimeProvider.UtcNow = DateTime.UtcNow; Exception error = new TypeNotFoundInRedisException("Dummy Error"); using (FakeTaskWorker worker = new FakeTaskWorker()) { worker.PredefineMethodCall(w => w.StartTask(task, null), () => { throw error; }); this.TaskWorkerFactory.PredefineResult(worker, f => f.CreateTaskWorker(task)); try { this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId); } catch (TypeNotFoundInRedisException) { } worker.AssertMethodCallOnce(w => w.Dispose()); } this.MessageBus.Tasks.Receiver.AssertMethodCallOnce(mb => mb.UnsubscribeFromAllChannels()); this.Repository.TaskRuntimeInfo.AssertMethodCallOnceWithArguments(r => r.Fail(taskInfo.TaskId, this.DateTimeProvider.UtcNow, error)); }
public void CancelTaskMultipleTimes() { ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Add(); ITask task = new FakeTask(); this.Repository.Tasks.Add(taskInfo.TaskId, task); using (FakeTaskWorker taskWorker = new FakeTaskWorker()) { taskWorker.PredefineMethodCall(w => w.StartTask(task, null), () => Thread.Sleep(TimeSpan.FromSeconds(1))); this.TaskWorkerFactory.PredefineResult(taskWorker, f => f.CreateTaskWorker(task)); for (int i = 0; i < 3; i++) { ThreadPool.QueueUserWorkItem(_ => { Thread.Sleep(TimeSpan.FromSeconds(0.3)); this.MessageBus.Tasks.NotifyTaskCancelRequest(taskInfo.TaskId, DateTime.UtcNow); }); } this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId); Thread.Sleep(TimeSpan.FromSeconds(0.5)); taskWorker.AssertMethodCallOnceWithArguments(w => w.CancelTask()); } this.MessageBus.Tasks.Receiver.AssertMethodCallOnce(mb => mb.UnsubscribeFromAllChannels()); }
private void RequestCancel(bool startTask) { ITaskRuntimeInfo taskInfo = this.Repository.Add(); if (startTask) { this.Repository.Start(taskInfo.TaskId, Guid.NewGuid(), DateTime.UtcNow.AddMinutes(-1)); } DateTime timestampUtc = DateTime.UtcNow; this.Repository.RequestCancel(taskInfo.TaskId, timestampUtc); ITaskRuntimeInfo taskInfo2 = this.Repository.GetById(taskInfo.TaskId); Assert.AreEqual(TaskStatus.Canceled, taskInfo2.Status); this.AssertEqual(timestampUtc, taskInfo2.CanceledUtc.Value); Assert.IsFalse(this.Repository.CheckIsPendingOrActive(taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetPending(false).Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetPending(true).Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetPendingAndActive()[TaskStatus.Pending].Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetPendingAndActive()[TaskStatus.InProgress].Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetActive().Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetFailed().Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsTrue(this.Repository.GetArchive().Any(t => t.TaskId == taskInfo.TaskId)); }
public void Complete() { ITaskRuntimeInfo taskInfo1 = this.Repository.Add(); Guid taskProcessorId = Guid.NewGuid(); DateTime timestampUtc = DateTime.UtcNow; this.Repository.Start(taskInfo1.TaskId, taskProcessorId, DateTime.UtcNow.AddMinutes(-1)); this.Repository.Complete(taskInfo1.TaskId, timestampUtc); ITaskRuntimeInfo taskInfo2 = this.Repository.GetById(taskInfo1.TaskId); Assert.AreEqual(100, taskInfo2.Percentage); Assert.AreEqual(TaskStatus.Success, taskInfo2.Status); this.AssertEqual(timestampUtc, taskInfo2.CompletedUtc.Value); Assert.IsFalse(this.Repository.CheckIsPendingOrActive(taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPending(false).Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPending(true).Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPendingAndActive()[TaskStatus.Pending].Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPendingAndActive()[TaskStatus.InProgress].Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetActive().Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetFailed().Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsTrue(this.Repository.GetArchive().Any(t => t.TaskId == taskInfo1.TaskId)); }
public void Fail() { ITaskRuntimeInfo taskInfo = this.Repository.Add(); Guid taskProcessorId = Guid.NewGuid(); DateTime timestampUtc = DateTime.UtcNow; Exception error = new TypeNotFoundInRedisException("Hello Error"); this.Repository.Start(taskInfo.TaskId, taskProcessorId, DateTime.UtcNow.AddMinutes(-1)); this.Repository.Fail(taskInfo.TaskId, timestampUtc, error); taskInfo = this.Repository.GetById(taskInfo.TaskId); Assert.AreEqual(TaskStatus.Failed, taskInfo.Status); this.AssertEqual(timestampUtc, taskInfo.CompletedUtc.Value); Assert.AreEqual(error.ToString(), taskInfo.Error); Assert.IsFalse(this.Repository.CheckIsPendingOrActive(taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetPending(false).Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetPending(true).Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetPendingAndActive()[TaskStatus.Pending].Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetPendingAndActive()[TaskStatus.InProgress].Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsFalse(this.Repository.GetActive().Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsTrue(this.Repository.GetFailed().Any(t => t.TaskId == taskInfo.TaskId)); Assert.IsTrue(this.Repository.GetArchive().Any(t => t.TaskId == taskInfo.TaskId)); }
public void ReportProgress() { ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create(); this.Repository.TaskRuntimeInfo.Add(taskInfo); FakeTask task = new FakeTask(); this.Repository.Tasks.Add(taskInfo.TaskId, task); double percent = DateTime.Now.Second; using (FakeTaskWorker worker = new FakeTaskWorker()) { this.TaskWorkerFactory.PredefineResult(worker, f => f.CreateTaskWorker(task)); this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId); worker.RaiseReportProgress(percent); } this.MessageBus.Tasks.Receiver.AssertMethodCallOnceWithArguments(mb => mb.NotifyTaskProgress(taskInfo.TaskId, percent)); this.Repository.TaskRuntimeInfo.AssertMethodCallOnceWithArguments(r => r.Progress(taskInfo.TaskId, percent)); }
internal static ITaskRuntimeInfo Add(this ITaskRuntimeInfoRepository repository, string pollingQueue) { ITaskRuntimeInfo result = repository.Create(Guid.NewGuid(), typeof(FakeTask), DateTime.UtcNow, TaskPriority.Normal, pollingQueue); repository.Add(result); return(result); }
internal static ITaskRuntimeInfo Add(this ITaskRuntimeInfoRepository repository) { ITaskRuntimeInfo result = repository.Create(); repository.Add(result); return(result); }
public void ChooseNextTaskForProcessorNoProcessor() { ITaskRuntimeInfo pendingTaskInfo = this.Repository.TaskRuntimeInfo.Create(); this.Repository.TaskRuntimeInfo.Add(pendingTaskInfo); Assert.IsFalse(this.TaskDistributor.ChooseNextTasksForProcessor(Guid.NewGuid()).Any()); }
private void OnShowTaskErrorClick(object sender, RoutedEventArgs e) { TaskViewModel taskViewModel = (TaskViewModel)((FrameworkElement)sender).DataContext; ITaskRuntimeInfo taskInfo = this.ViewModel.TaskProcessorFacade.GetTaskRuntimeInfo(taskViewModel.TaskId); MessageBox.Show(taskInfo.Error, "Task Error", MessageBoxButton.OK, MessageBoxImage.Error); }
internal static ITaskRuntimeInfo Add(this ITaskRuntimeInfoRepository repository, TaskPriority priority) { ITaskRuntimeInfo result = repository.Create(Guid.NewGuid(), typeof(FakeTask), DateTime.UtcNow, priority, null); repository.Add(result); return(result); }
private void ChooseNextTaskForProcessorOrder(TaskPriority higher, TaskPriority smaller) { ITaskRuntimeInfo taskInfo1 = this.Repository.TaskRuntimeInfo.Add(smaller); ITaskRuntimeInfo taskInfo2 = this.Repository.TaskRuntimeInfo.Add(higher); IEnumerable <ITaskRuntimeInfo> result = this.TaskDistributor.ChooseNextTasksForProcessor(Guid.NewGuid()); Assert.AreEqual(2, result.Count()); Assert.AreEqual(taskInfo2, result.First()); Assert.AreEqual(taskInfo1, result.Last()); }
private void OnTaskSubmitted(object sender, TaskEventArgs e) { ITaskRuntimeInfo taskInfo = this.taskProcessorFacade.GetTaskRuntimeInfo(e.TaskId); if (taskInfo != null) { App.Current.Dispatcher.InvokeAsync(() => { this.pendingTasks.Add(new TaskViewModel(taskInfo)); }); } }
/// <inheritdoc /> public IEnumerable <ITaskProcessorRuntimeInfo> ChooseProcessorForTask(ITaskRuntimeInfo pendingTaskInfo) { if (pendingTaskInfo == null) { throw new ArgumentNullException("pendingTaskInfo"); } ITaskRuntimeInfo[] activeTasksInfo = this.repository.TaskRuntimeInfo.GetActive().ToArray(); return(this.repository.TaskProcessorRuntimeInfo.GetAll() .Where(processorInfo => DefaultTaskDistributor.CanExecuteTask(pendingTaskInfo, processorInfo, activeTasksInfo)) .OrderBy(t => activeTasksInfo.Count(tt => tt.TaskProcessorId == t.TaskProcessorId))); }
public void Add(ITaskRuntimeInfo taskInfo) { if (taskInfo == null) { throw new ArgumentNullException(nameof(taskInfo)); } taskInfo.ValidateForAdd(); this.RecordMethodCall(taskInfo); this.taskInfos.Add(taskInfo.TaskId, (FakeTaskRuntimeInfo)taskInfo); }
internal TaskViewModel(ITaskRuntimeInfo taskInfo) { this.taskId = taskInfo.TaskId; this.taskType = taskInfo.TaskType; this.priority = taskInfo.Priority; this.submittedUtc = taskInfo.SubmittedUtc; this.status = taskInfo.Status.ToString(); this.startedUtc = taskInfo.StartedUtc; this.canceledUtc = taskInfo.CanceledUtc; this.completedUtc = taskInfo.CompletedUtc; this.taskProcessorId = taskInfo.TaskProcessorId; this.pollingQueue = taskInfo.PollingQueue; this.error = taskInfo.Error; }
public void Create() { Guid taskId = Guid.NewGuid(); DateTime timestampUtc = DateTime.UtcNow.AddMinutes(-1); ITaskRuntimeInfo taskInfo = this.Repository.Create(taskId, typeof(FakeTask), timestampUtc, TaskPriority.VeryHigh, "Polling Queue"); Assert.AreEqual(taskId, taskInfo.TaskId); Assert.AreEqual(typeof(FakeTask), taskInfo.TaskType); Assert.AreEqual(TaskPriority.VeryHigh, taskInfo.Priority); Assert.AreEqual(TaskStatus.Pending, taskInfo.Status); Assert.AreEqual(timestampUtc, taskInfo.SubmittedUtc); Assert.AreEqual("Polling Queue", taskInfo.PollingQueue); Assert.IsNull(taskInfo.Error); }
public void UpdateProgress() { ITaskRuntimeInfo taskInfo = this.Repository.Add(); this.Repository.Progress(taskInfo.TaskId, 100); taskInfo = this.Repository.GetById(taskInfo.TaskId); Assert.AreEqual(100, taskInfo.Percentage); this.Repository.Progress(taskInfo.TaskId, 0); taskInfo = this.Repository.GetById(taskInfo.TaskId); Assert.AreEqual(0, taskInfo.Percentage); }
private Dictionary <TaskStatus, IEnumerable <ITaskRuntimeInfo> > GetAllByType(params string[] listKeys) { List <string> entityIds = new List <string>(); using (IRedisPipeline pipeline = this.provider.CreatePipeline()) { foreach (string listKey in listKeys) { pipeline.GetList(listKey, values => entityIds.AddRange(values)); } pipeline.Flush(); } Dictionary <TaskStatus, IEnumerable <ITaskRuntimeInfo> > result = new Dictionary <TaskStatus, IEnumerable <ITaskRuntimeInfo> >(); using (IRedisPipeline pipeline = this.provider.CreatePipeline()) { foreach (string entityId in entityIds) { string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(entityId); pipeline.GetHash(entityKey, values => { if (values.Count > 0) { ITaskRuntimeInfo taskInfo = RedisTaskRuntimeInfoRepository.Convert(values); IEnumerable <ITaskRuntimeInfo> collection; if (!result.TryGetValue(taskInfo.Status, out collection)) { collection = new List <ITaskRuntimeInfo>(); result.Add(taskInfo.Status, collection); } ((ICollection <ITaskRuntimeInfo>)collection).Add(taskInfo); } }); } pipeline.Flush(); } return(result); }
/// <inheritdoc /> public void Add(ITaskRuntimeInfo taskInfo) { if (taskInfo == null) { throw new ArgumentNullException("taskInfo"); } Trace.WriteLine("ENTER: Adding runtime information for task '{0}' of type '{1}' with priority '{2}' in polling queue '{3}' ...".FormatInvariant(taskInfo.TaskId, taskInfo.TaskType, taskInfo.Priority, taskInfo.PollingQueue)); taskInfo.ValidateForAdd(); string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(taskInfo.TaskId); string addToListKey; Dictionary <string, string> values = new Dictionary <string, string>() { { "Id", RedisConverter.ToString(taskInfo.TaskId) }, { "TaskType", RedisConverter.ToString(taskInfo.TaskType, true) }, { "SubmittedUtc", RedisConverter.ToString(taskInfo.SubmittedUtc) }, { "Status", RedisConverter.ToString(taskInfo.Status) } }; if (string.IsNullOrEmpty(taskInfo.PollingQueue)) { values.Add("Priority", RedisConverter.ToString(taskInfo.Priority)); addToListKey = RedisTaskRuntimeInfoRepository.PendingTasksList; } else { values.Add("PollingQueue", taskInfo.PollingQueue); addToListKey = RedisTaskRuntimeInfoRepository.GetPollingQueueRedisKey(taskInfo.PollingQueue, TaskStatus.Pending); } using (IRedisTransaction transaction = this.Provider.CreateTransaction()) { transaction.SetHashValues(entityKey, values); transaction.AddToList(addToListKey, RedisConverter.ToString(taskInfo.TaskId)); transaction.Commit(); } Trace.WriteLine("EXIT: Runtime information for task '{0}' of type '{1}' with priority '{2}' in polling queue '{3}' added.".FormatInvariant(taskInfo.TaskId, taskInfo.TaskType, taskInfo.Priority, taskInfo.PollingQueue)); }
public void AddPollingQueueTask() { ITaskRuntimeInfo taskInfo1 = this.Repository.Add("Test"); ITaskRuntimeInfo taskInfo2 = this.Repository.GetById(taskInfo1.TaskId); UnitTestHelpers.AssertEqualByPublicScalarProperties(taskInfo1, taskInfo2); Assert.IsTrue(this.Repository.CheckIsPendingOrActive(taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPending(false).Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsTrue(this.Repository.GetPending(true).Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPendingAndActive()[TaskStatus.Pending].Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetPendingAndActive()[TaskStatus.InProgress].Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetActive().Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetFailed().Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsFalse(this.Repository.GetArchive().Any(t => t.TaskId == taskInfo1.TaskId)); Assert.IsTrue(this.Repository.ReservePollingQueueTasks("Test", 1).Any(t => t.TaskId == taskInfo1.TaskId)); }
public void StartTaskCanceled() { ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Add(); ITask task = new FakeTask(); this.Repository.Tasks.Add(taskInfo.TaskId, task); using (FakeTaskWorker worker = new FakeTaskWorker()) { this.TaskWorkerFactory.PredefineResult(worker, f => f.CreateTaskWorker(task)); this.Repository.TaskRuntimeInfo.RequestCancel(taskInfo.TaskId, DateTime.UtcNow); this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId); } }
private void StartTaskCompleted(Action <Guid> completeTask) { ITaskRuntimeInfo taskInfo = this.Repository.TaskRuntimeInfo.Create(); this.Repository.TaskRuntimeInfo.Add(taskInfo); ITask task = new FakeTask(); this.Repository.Tasks.Add(taskInfo.TaskId, task); using (FakeTaskWorker worker = new FakeTaskWorker()) { this.TaskWorkerFactory.PredefineResult(worker, f => f.CreateTaskWorker(task)); } completeTask(taskInfo.TaskId); this.TaskWorkerBootstrap.StartTask(taskInfo.TaskId); }