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