public async Task LogTaskRun(bool success, int updateCount, string environment, string taskName) { await using var db = CommonRepository.GetDatabase(serviceScopeFactory: _serviceScopeFactory); var taskExecution = new TaskExecution { InsertDate = DateTime.UtcNow, IsSuccess = success, UpdateCount = updateCount, Environment = environment, TaskName = taskName }; var taskExecutionCount = await db.TaskExecutions.Where(predicate : t => t.TaskName == taskName && t.Environment == environment).CountAsync(); if (taskExecutionCount >= 100) { var toBeDeleted = taskExecutionCount - 99; var taskExecutionsToDelete = await db.TaskExecutions.OrderBy(keySelector : t => t.Id) .Where(predicate: t => t.TaskName == taskName) .Take(count: toBeDeleted).ToListAsync() .ConfigureAwait(continueOnCapturedContext: false); db.RemoveRange(entities: taskExecutionsToDelete); } await db.AddAsync(entity : taskExecution).ConfigureAwait(continueOnCapturedContext: false); await db.SaveChangesAsync().ConfigureAwait(continueOnCapturedContext: false); }
public async Task CreateAsync(TaskExecution taskExecution) { using (var connection = await OpenConnection()) { await connection.ExecuteAsync( "INSERT INTO TaskExecution (TaskExecutionId, TaskReferenceId, TaskSessionId, TargetId, CreatedOn) VALUES (@TaskExecutionId, @TaskReferenceId, @TaskSessionId, @TargetId, @CreatedOn)", taskExecution); } }
public async Task TestPropertyChangesWhenTaskFaulted() { bool complete = false; using (var evnt = new ManualResetEventSlim()) { var task = Task.Run(new Func <int>(() => { evnt.Set(); int counter = int.MinValue; while (!Volatile.Read(ref complete)) { unchecked { counter++; } } throw new Exception("test"); })); try { evnt.Wait(); var e = new TaskExecution <int>(task); var changes = new List <string>(); e.PropertyChanged += (sender, args) => { changes.Add(args.PropertyName); }; Volatile.Write(ref complete, true); await e.CompletionTask; CollectionAssert.AreEquivalent( new string[] { nameof(TaskExecution <int> .Status), nameof(TaskExecution <int> .Result), nameof(TaskExecution <int> .IsCompleted), nameof(TaskExecution <int> .IsCompletedSuccessfully), nameof(TaskExecution <int> .IsNotCompleted), nameof(TaskExecution <int> .IsCanceled), nameof(TaskExecution <int> .IsFaulted), nameof(TaskExecution <int> .Exception), nameof(TaskExecution <int> .InnerException), nameof(TaskExecution <int> .InnerExceptions), }, changes); } finally { complete = true; } } }
static void Main(string[] args) { List <XmlTestData> tests = new List <XmlTestData>() { new XmlTestData() { ClassName = "CalcServer.Toolboxes.MathToolbox", ClassVersion = "1.0.0.0", FunctionName = "MinMax", DataToProcess = GenerateRandomNumbersList(5, 100) }, new XmlTestData() { ClassName = "CalcServer.Toolboxes.MathToolbox", ClassVersion = "1.0.0.0", FunctionName = "MinMaxIdx", DataToProcess = GenerateRandomNumbersList(5, 100) }, new XmlTestData() { ClassName = "CalcServer.Toolboxes.StatisticsToolbox", ClassVersion = "1.0.0.0", FunctionName = "MeanStdDev", DataToProcess = GenerateRandomNumbersList(5, 100) }, new XmlTestData() { ClassName = "CalcServer.Toolboxes.StatisticsToolbox", ClassVersion = "1.0.0.0", FunctionName = "WordsCount", DataToProcess = "a test string" } }; for (int i = 0; i < tests.Count; i++) { string taskDataStr = tests[i].ToString(); Console.WriteLine(taskDataStr); new Thread(() => { string taskDataName = string.Format("TaskData-{0}", i); Console.WriteLine(Environment.NewLine + taskDataName); TaskExecution te = new TaskExecution("http://localhost:9001/ProcessingService/", TimeSpan.FromSeconds(1)); te.OnTaskExecutionCompleted += new TaskExecutionCompletedHandler(te_OnTaskExecutionCompleted); te.OnTaskExecutionProgress += new TaskExecutionProgressHandler(te_OnTaskExecutionProgress); te.SetTaskData(taskDataName, taskDataStr); te.Start(); } ) { IsBackground = true }.Start(); mre.WaitOne(); Thread.Sleep(2000); Console.WriteLine(Environment.NewLine + "==========" + Environment.NewLine); mre.Reset(); } Console.WriteLine("Premere <Invio> per terminare l'applicazione..."); Console.ReadLine(); }
public void TestWatchedTaskMayAlreadyBeCompleted() { Task t = Task.CompletedTask; var execution = new TaskExecution(t); Assert.AreSame(t, execution.Task); Assert.IsTrue(execution.IsCompleted); Assert.IsTrue(execution.CompletionTask.IsCompleted); }
public void TestWatchedTaskMayAlreadyBeCompleted() { var task = Task.FromResult(5); var e = new TaskExecution <int>(task); Assert.AreSame(task, e.Task); Assert.IsTrue(e.IsCompleted); Assert.IsTrue(e.CompletionTask.IsCompleted); Assert.AreEqual(5, e.Result); }
public void ExecutionGetsSpecifiedCommand() { IArgumentProvider arguments = Substitute.For <IArgumentProvider>(); ITaskRegistry taskRegistry = Substitute.For <ITaskRegistry>(); ITask task = Substitute.For <ITask>(); arguments.Command.Returns("ExecutionGetsSpecifiedCommand"); taskRegistry["ExecutionGetsSpecifiedCommand"].Returns(task); TaskExecution execution = Substitute.ForPartsOf <TaskExecution>(arguments, taskRegistry, null); execution.ExecuteTask(); task.Received(1).Execute(Arg.Any <ITaskInteraction>()); }
public void TaskIsDisposed() { TestArgumentProvider arguments = new TestArgumentProvider(); arguments.Command = "TaskIsDisposed"; SimpleTaskRegistry taskRegistry = new SimpleTaskRegistry(); TestTask task = new TestTask(); taskRegistry.RegisterTask(() => task, "TaskIsDisposed"); TaskExecution execution = Substitute.ForPartsOf <TaskExecution>(arguments, taskRegistry, null); execution.ExecuteTask(); task.DisposeCount.Should().Be(1); }
public async Task TestTaskCompletedSuccessfullyState() { bool complete = false; using (var evnt = new ManualResetEventSlim()) { var task = Task.Run(() => { evnt.Set(); int counter = int.MinValue; while (!Volatile.Read(ref complete)) { unchecked { counter++; } } return(5); }); try { evnt.Wait(); var e = new TaskExecution <int>(task, defaultResult: -1); Volatile.Write(ref complete, true); await e.CompletionTask; Assert.AreSame(task, e.Task); Assert.AreNotSame(task, e.CompletionTask); Assert.AreEqual(TaskStatus.RanToCompletion, e.Status); Assert.AreEqual(5, e.Result); Assert.IsTrue(e.IsCompleted); Assert.IsTrue(e.IsCompletedSuccessfully); Assert.IsFalse(e.IsNotCompleted); Assert.IsFalse(e.IsCanceled); Assert.IsFalse(e.IsFaulted); Assert.IsNull(e.Exception); Assert.IsNull(e.InnerException); Assert.IsNull(e.InnerExceptions); } finally { complete = true; } } }
public async Task StartExecution(MazeTask mazeTask, TaskSession taskSession, TaskExecution taskExecution) { using (await _readerWriterLock.WriterLockAsync()) { var file = _fileSystem.FileInfo.FromFileName(GetTaskDbFilename(mazeTask)); file.Directory.Create(); var transmitterQueue = new TaskQueue(); try { using (var dbStream = file.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite)) using (var db = new LiteDatabase(dbStream)) { var sessions = db.GetCollection <TaskSession>(nameof(TaskSession)); sessions.EnsureIndex(x => x.TaskSessionId, unique: true); var taskSessionEntity = sessions.FindById(taskSession.TaskSessionId); if (taskSessionEntity == null) { taskSessionEntity = new TaskSession { TaskSessionId = taskSession.TaskSessionId, TaskReferenceId = mazeTask.Id, Description = taskSession.Description, CreatedOn = DateTimeOffset.UtcNow }; sessions.Insert(taskSessionEntity); transmitterQueue.Enqueue(() => _requestTransmitter.Transmit(TaskSessionsResource.CreateSessionRequest(taskSessionEntity))).Forget(); } taskExecution.TaskSessionId = taskSessionEntity.TaskSessionId; var executions = db.GetCollection <TaskExecution>(nameof(TaskExecution)); taskExecution.TaskExecutionId = executions.Insert(taskExecution); transmitterQueue.Enqueue(() => _requestTransmitter.Transmit(TaskExecutionsResource.CreateExecutionRequest(taskExecution))).Forget(); } } finally { await transmitterQueue.DisposeAsync(); } } }
public void TestTaskFaultedState() { var exception = new Exception("test"); var task = Task.FromException(exception); var e = new TaskExecution(task); Assert.AreSame(task, e.Task); Assert.AreNotSame(task, e.CompletionTask); Assert.AreEqual(TaskStatus.Faulted, e.Status); Assert.IsTrue(e.IsCompleted); Assert.IsFalse(e.IsCompletedSuccessfully); Assert.IsFalse(e.IsNotCompleted); Assert.IsFalse(e.IsCanceled); Assert.IsTrue(e.IsFaulted); Assert.IsNotNull(e.Exception); Assert.AreSame(exception, e.InnerException); CollectionAssert.AreEqual(new[] { exception }, e.InnerExceptions.ToArray()); }
public Task StartExecution(MazeTask mazeTask, TaskSession taskSession, TaskExecution taskExecution) { taskExecution.TaskExecutionId = Guid.NewGuid(); taskExecution.TaskSessionId = taskSession.TaskSessionId; lock (_executionsLock) lock (_sessionsLock) { if (!Sessions.Any(x => x.TaskSessionId == taskSession.TaskSessionId && x.TaskReferenceId == mazeTask.Id)) { Sessions.Add(taskSession); } Executions.Add(taskExecution); } return(Task.CompletedTask); }
public void HelpOutputsUsage() { IArgumentProvider arguments = Substitute.For <IArgumentProvider>(); ITaskRegistry taskRegistry = Substitute.For <ITaskRegistry>(); ITaskDocumentation docs = Substitute.For <ITaskDocumentation>(); ITask task = Substitute.For <ITask>(); task.GetService <ITaskDocumentation>().Returns(docs); arguments.Command.Returns("HelpOutputsUsage"); arguments.HelpRequested.Returns(true); taskRegistry["HelpOutputsUsage"].Returns(task); TaskExecution execution = Substitute.ForPartsOf <TaskExecution>(arguments, taskRegistry, null); execution.ExecuteTask(); docs.Received(1).GetUsage(Arg.Any <ITaskInteraction>()); }
public void TestTaskCanceledState() { var token = new CancellationToken(true); var task = Task.FromCanceled(token); var e = new TaskExecution(task); Assert.AreSame(task, e.Task); Assert.AreNotSame(task, e.CompletionTask); Assert.AreEqual(TaskStatus.Canceled, e.Status); Assert.IsTrue(e.IsCompleted); Assert.IsFalse(e.IsCompletedSuccessfully); Assert.IsFalse(e.IsNotCompleted); Assert.IsTrue(e.IsCanceled); Assert.IsFalse(e.IsFaulted); Assert.IsNull(e.Exception); Assert.IsNull(e.InnerException); Assert.IsNull(e.InnerExceptions); }
public void TestTaskRunningState() { bool complete = false; using (var evnt = new ManualResetEventSlim()) { var task = Task.Run(() => { evnt.Set(); int counter = int.MinValue; while (!Volatile.Read(ref complete)) { unchecked { counter++; } } }); try { evnt.Wait(); var e = new TaskExecution(task); Assert.AreSame(task, e.Task); Assert.AreNotSame(task, e.CompletionTask); Assert.AreEqual(TaskStatus.Running, e.Status); Assert.IsFalse(e.IsCompleted); Assert.IsFalse(e.IsCompletedSuccessfully); Assert.IsTrue(e.IsNotCompleted); Assert.IsFalse(e.IsCanceled); Assert.IsFalse(e.IsFaulted); Assert.IsNull(e.Exception); Assert.IsNull(e.InnerException); Assert.IsNull(e.InnerExceptions); } finally { Volatile.Write(ref complete, true); } } }
public TaskRelationship(TaskExecution parent, TaskExecution child) { Parent = parent; Child = child; }
public void BeginInvoke(TaskExecution execution) { _timer.Dispatcher.BeginInvoke(execution); }
/// <summary> /// Run a task periodically /// </summary> /// <param name="execution">Task which you want to run</param> /// <param name="intervalSeconds">interval time, unit is second</param> public void Schedule(TaskExecution execution, TimeSpan interval) { Task task = new Task(interval, execution); _executor.Register(task); }
public void Schedule(TaskExecution execution) { Task task = new Task(new TimeSpan(0, 0, 0,1), execution); _executor.Register(task); }
public static HttpRequestMessage CreateExecutionRequest(TaskExecution taskExecution) => CreateRequest(HttpVerb.Post, null, taskExecution).Build();
public Task(TimeSpan interval, TaskExecution execution) { _interval = interval; _execution = execution; }