public async Task BizActionAsync(MazeTask inputData)
{
if (ValidateModelFailed(inputData))
{
return;
}
var taskReference = await _dbAccess.FindAsync(inputData.Id);
if (taskReference == null)
{
AddValidationResult(TaskErrors.TaskNotFound);
return;
}
await _taskDirectory.WriteTask(inputData);
if (taskReference.IsEnabled)
{
var hash = _taskDirectory.ComputeTaskHash(inputData);
await _management.CancelTask(inputData.Id);
await _management.InitializeTask(inputData, hash, transmit : true, executeLocally : true);
}
}
public MazeTaskService(MazeTask mazeTask, ITaskResultStorage taskResultStorage, IServiceProvider services)
{
_taskResultStorage = taskResultStorage;
MazeTask = mazeTask;
Services = services;
Logger = services.GetRequiredService <ILogger <MazeTaskService> >();
}
public async Task <TaskSession> OpenSession(SessionKey sessionKey, MazeTask mazeTask, string description)
{
using (await _readerWriterLock.ReaderLockAsync())
{
var file = _fileSystem.FileInfo.FromFileName(GetTaskDbFilename(mazeTask));
if (file.Exists)
{
using (var dbStream = file.OpenRead())
using (var db = new LiteDatabase(dbStream))
{
var collection = db.GetCollection <TaskSession>(nameof(TaskSession));
collection.EnsureIndex(x => x.TaskSessionId, true);
var taskSession = collection.IncludeAll().FindById(sessionKey.Hash);
if (taskSession != null)
{
return(taskSession);
}
}
}
}
return(new TaskSession
{
TaskSessionId = sessionKey.Hash,
Description = description,
CreatedOn = DateTimeOffset.UtcNow,
TaskReference = new TaskReference {
TaskId = mazeTask.Id
},
TaskReferenceId = mazeTask.Id,
Executions = ImmutableList <TaskExecution> .Empty
});
}
public async Task <TaskReference> BizActionAsync(MazeTask inputData)
{
if (ValidateModelFailed(inputData))
{
return(null);
}
var taskReference = await _dbAccess.FindAsync(inputData.Id);
if (taskReference != null)
{
return(ReturnError <TaskReference>(TaskErrors.TaskAlreadyExists));
}
await _taskDirectory.WriteTask(inputData);
taskReference = new TaskReference {
TaskId = inputData.Id, IsCompleted = false, IsEnabled = true, AddedOn = DateTimeOffset.UtcNow
};
await _dbAccess.CreateAsync(taskReference);
var hash = _taskDirectory.ComputeTaskHash(inputData);
await _management.InitializeTask(inputData, hash, transmit : true, executeLocally : true);
return(taskReference);
}
public MazeTaskWriterTests()
{
_task = new MazeTask
{
Name = "TestCommand",
Id = Guid.Parse("53221F85-23DC-4C4C-BD27-A26A5F85BCA0"),
Audience = new AudienceCollection {
IsAll = true, IncludesServer = true
},
Filters = new List <FilterInfo> {
new OperatingSystemFilterInfo {
Min = "Windows10"
}
},
Triggers =
new List <TriggerInfo> {
new DateTimeTriggerInfo {
Date = new DateTimeOffset(2017, 8, 10, 1, 0, 0, TimeSpan.Zero)
}
},
StopEvents = new List <StopEventInfo> {
new DurationStopEvent {
Duration = TimeSpan.FromMinutes(1.36)
}
},
Commands = new List <CommandInfo> {
new WakeOnLanCommand {
Content = "Hello World!!!", Hash = 2845
}
}
};
}
public TaskRunner(MazeTask mazeTask, ITaskStorage taskStorage, IServiceProvider services)
{
MazeTask = mazeTask;
Services = services;
Logger = services.GetRequiredService <ILogger <TaskRunner> >();
_storage = taskStorage;
}
public void TestWriteTaskEmptyCommand()
{
var task = new MazeTask
{
Name = "TestCommand",
Id = Guid.Parse("53221F85-23DC-4C4C-BD27-A26A5F85BCA0"),
StopEvents = new List <StopEventInfo> {
new DurationStopEvent {
Duration = TimeSpan.FromMinutes(1.36)
}
},
Commands = new List <CommandInfo> {
new WakeOnLanCommand {
Content = "Hello World!!!", Hash = 2845
}, new EmptyCommandInfo()
}
};
var expected = @"<?xml version=""1.0"" encoding=""utf-8""?>
<task>
<metadata>
<name>TestCommand</name>
<id>53221f85-23dc-4c4c-bd27-a26a5f85bca0</id>
</metadata>
<stop>
<Duration duration=""PT1M21.6S"" />
</stop>
<commands>
<Command name=""Maze.WakeOnLan"" modules=""SystemUtilities;TaskManager"" hash=""2845"">Hello World!!!</Command>
<Command name=""Empty"" />
</commands>
</task>";
CompareWriteTask(task, TaskDetails.Execution, expected);
}
public DefaultTaskExecutionContext(TaskSession session, MazeTask mazeTask, IServiceProvider services, Func <CommandProcessDto, Task> updateStatus)
{
Session = session;
MazeTask = mazeTask;
Services = services;
_statusUpdate = new MessageThrottleService <CommandProcessDto>(updateStatus);
}
public override void Apply(MazeTask mazeTask)
{
mazeTask.Triggers = new List <TriggerInfo>();
foreach (var taskView in _childs)
{
var dto = TaskServiceViewModelUtils.Build <TriggerInfo>(taskView.ViewModel);
mazeTask.Triggers.Add(dto);
}
}
public Task AppendCommandResult(MazeTask mazeTask, CommandResult commandResult)
{
lock (_commandResultsLock)
{
CommandResults.Add(commandResult);
}
return(Task.CompletedTask);
}
public TaskInfo(MazeTask mazeTask, Hash hash, bool executeOnServer, bool executeOnClients)
{
_cancellationTokenSource = new CancellationTokenSource();
Token = _cancellationTokenSource.Token;
MazeTask = mazeTask;
Hash = hash;
ExecuteOnServer = executeOnServer;
ExecuteOnClients = executeOnClients;
}
public TaskActivityWatcher Execute(MazeTask mazeTask, ICommandDescription commandDescription)
{
var task = TasksResource.Execute(mazeTask, _taskComponentResolver, _xmlSerializerCache, _restClient);
var watcher = _serviceProvider.GetRequiredService <TaskActivityWatcher>();
watcher.InitializeWatch(mazeTask.Id);
PendingCommands.Insert(0, new PendingCommandViewModel(commandDescription, task, mazeTask, watcher));
return(watcher);
}
public PendingCommandViewModel(ICommandDescription commandDescription, Task <TaskSessionsInfo> task, MazeTask mazeTask, TaskActivityWatcher taskActivityWatcher)
{
CommandDescription = commandDescription;
Task = task;
MazeTask = mazeTask;
TaskActivityWatcher = taskActivityWatcher;
Task.ContinueWith(x =>
{
RaisePropertyChanged(nameof(IsCompleted));
TaskActivityWatcher.Dispose();
});
}
public Task <TaskSession> OpenSession(SessionKey sessionKey, MazeTask mazeTask, string description)
{
return(Task.FromResult(new TaskSession
{
TaskSessionId = sessionKey.Hash,
Description = description,
CreatedOn = DateTimeOffset.UtcNow,
TaskReference = new TaskReference {
TaskId = mazeTask.Id
},
TaskReferenceId = mazeTask.Id,
Executions = ImmutableList <TaskExecution> .Empty
}));
}
public TaskExecutor(MazeTask mazeTask, TaskSession taskSession, ITaskResultStorage taskResultStorage, IServiceProvider services)
{
_mazeTask = mazeTask;
_taskSession = taskSession;
_taskResultStorage = taskResultStorage;
_services = services;
_logger = services.GetRequiredService <ILogger <TaskExecutor> >();
_activeTasksManager = services.GetRequiredService <ActiveTasksManager>();
_hubContext = services.GetRequiredService <IHubContext <AdministrationHub> >();
_executorTypes = _mazeTask.Commands.ToDictionary(x => x, commandInfo => typeof(ITaskExecutor <>).MakeGenericType(commandInfo.GetType()));
_executionMethods = _executorTypes.Values.ToDictionary(x => x, executorType => executorType.GetMethod("InvokeAsync"));
}
public async Task <TaskSessionsInfo> BizActionAsync(MazeTask inputData)
{
var builder = new TaskSessionInfoBuilder(inputData.Id);
builder.TaskSessionAdded += BuilderOnTaskSessionAdded;
builder.TaskExecutionAdded += BuilderOnTaskExecutionAdded;
builder.TaskResultAdded += BuilderOnTaskResultAdded;
var storage = new MemoryTaskResultStorage();
//trigger locally
await _management.TriggerNow(inputData, SessionKey.Create("Execute"), storage);
builder.Add(new TaskSessionsInfo
{
Sessions = storage.Sessions,
Executions = storage.Executions,
Results = storage.CommandResults
}, TargetId.ServerId);
//trigger on clients
var audienceFilter = new AudienceFilter(inputData.Audience);
var clients = (await _dbContext.Clients.Select(x => x.ClientId).ToListAsync()).ToHashSet();
var onlineClients = _connectionManager.ClientConnections.Where(x => clients.Contains(x.Key));
var tasks = new Dictionary <Task <TaskSessionsInfo>, int>();
foreach (var onlineClient in onlineClients)
{
if (audienceFilter.Invoke(onlineClient.Key))
{
//add all at once because the tasks don't do anything except waiting for the completion source anyways
var task = TasksResource.ExecuteTask(inputData, _taskComponentResolver, _xmlSerializerCache, onlineClient.Value);
tasks.Add(task, onlineClient.Key);
}
}
while (tasks.Any())
{
var task = await Task.WhenAny(tasks.Keys);
builder.Add(task.Result, new TargetId(tasks[task]));
tasks.Remove(task);
}
return(builder.Build());
}
public static async Task <TaskSessionsInfo> ExecuteTask(MazeTask mazeTask, ITaskComponentResolver componentResolver,
IXmlSerializerCache xmlCache, IRestClient restClient)
{
using (var taskMemoryStream = new MemoryStream())
{
var taskWriter = new MazeTaskWriter(taskMemoryStream, componentResolver, xmlCache);
taskWriter.Write(mazeTask, TaskDetails.Client);
taskMemoryStream.Position = 0;
var stream = new StreamContent(taskMemoryStream);
stream.Headers.ContentEncoding.Add("xml");
return(await CreateRequest(HttpVerb.Post, "execute", stream).Execute(restClient).Return <TaskSessionsInfo>());
}
}
public static async Task Update(MazeTask mazeTask, ITaskComponentResolver componentResolver, IXmlSerializerCache xmlCache,
IRestClient restClient)
{
using (var taskMemoryStream = new MemoryStream())
{
var taskWriter = new MazeTaskWriter(taskMemoryStream, componentResolver, xmlCache);
taskWriter.Write(mazeTask, TaskDetails.Server);
taskMemoryStream.Position = 0;
var stream = new StreamContent(taskMemoryStream);
stream.Headers.ContentEncoding.Add("xml");
await CreateRequest(HttpVerb.Put, mazeTask.Id, stream).Execute(restClient);
}
}
public async Task AppendCommandResult(MazeTask mazeTask, CommandResult commandResult)
{
using (await _readerWriterLock.WriterLockAsync())
{
var file = _fileSystem.FileInfo.FromFileName(GetTaskDbFilename(mazeTask));
file.Directory.Create();
using (var dbStream = file.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite))
using (var db = new LiteDatabase(dbStream))
{
var results = db.GetCollection <CommandResult>(nameof(CommandResult));
results.Insert(commandResult);
await _requestTransmitter.Transmit(TaskExecutionsResource.CreateCommandResultRequest(commandResult));
}
}
}
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 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 override void Initialize(MazeTask mazeTask)
{
foreach (var triggerInfo in mazeTask.Triggers)
{
var triggerInfoType = triggerInfo.GetType();
var description = AvailableServices.First(x => x.DtoType == triggerInfoType);
var view = CreateView(description);
TaskServiceViewModelUtils.Initialize(view.ViewModel, triggerInfo);
AddChild(view);
if (mazeTask.Triggers.Count == 1)
{
SetProperty(ref _selectedService, description, nameof(SelectedService));
SetProperty(ref _selectedChild, view, nameof(SelectedChild));
}
}
}
public async Task <TaskReference> BizActionAsync(MazeTask inputData)
{
if (ValidateModelFailed(inputData))
{
return(null);
}
var taskReference = await _dbAccess.FindAsync(inputData.Id);
if (taskReference == null)
{
taskReference = new TaskReference {
TaskId = inputData.Id, IsCompleted = false, IsEnabled = true, AddedOn = DateTimeOffset.UtcNow
};
await _dbAccess.CreateAsync(taskReference);
}
return(taskReference);
}
public async Task MarkTaskFinished(MazeTask mazeTask)
{
using (await _readerWriterLock.WriterLockAsync())
{
var file = _fileSystem.FileInfo.FromFileName(GetTaskDbFilename(mazeTask));
file.Directory.Create();
using (var dbStream = file.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite))
using (var db = new LiteDatabase(dbStream))
{
var entities = db.GetCollection <MazeTaskStatus>(nameof(MazeTaskStatus));
entities.Delete(x => true);
entities.Insert(new MazeTaskStatus {
IsFinished = true
});
}
}
}
private static void CompareWriteTask(MazeTask mazeTask, TaskDetails details, string expected)
{
var mock = new Mock <ITaskComponentResolver>();
mock.Setup(x => x.ResolveName(It.IsAny <Type>())).Returns <Type>(GetName);
using (var memoryStream = new MemoryStream())
{
var xmlWriter = XmlWriter.Create(memoryStream,
new XmlWriterSettings {
OmitXmlDeclaration = false, Indent = true, IndentChars = " ", Encoding = new UTF8Encoding(false)
});
var writer = new MazeTaskWriter(xmlWriter, mock.Object, new XmlSerializerCache());
writer.Write(mazeTask, details);
var result = Encoding.UTF8.GetString(memoryStream.ToArray());
Assert.Equal(expected, result);
}
}
public async Task <bool> CheckTaskFinished(MazeTask mazeTask)
{
using (await _readerWriterLock.ReaderLockAsync())
{
var file = _fileSystem.FileInfo.FromFileName(GetTaskDbFilename(mazeTask));
if (!file.Exists)
{
return(false);
}
using (var dbStream = file.Open(FileMode.Open, FileAccess.ReadWrite))
using (var db = new LiteDatabase(dbStream))
{
var entities = db.GetCollection <MazeTaskStatus>(nameof(MazeTaskStatus));
var entity = entities.FindAll().FirstOrDefault();
return(entity?.IsFinished == true);
}
}
}
public ValidationResult ValidateContext(MazeTask mazeTask) => ValidationResult.Success;
public static ValidationResult ValidateContext(object viewModel, MazeTask mazeTask)
{
var method = viewModel.GetType().GetMethod(nameof(ITaskServiceViewModel <string> .ValidateContext), BindingFlags.Instance | BindingFlags.Public);
return((ValidationResult)method.Invoke(viewModel, new object[] { mazeTask }));
}
public Task <bool> CheckTaskFinished(MazeTask mazeTask) => Task.FromResult(_finishedTasks.ContainsKey(mazeTask.Id));
public Task MarkTaskFinished(MazeTask mazeTask)
{
_finishedTasks.TryAdd(mazeTask.Id, null);
return(Task.CompletedTask);
}
