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 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;
}
