public TaskService( SteamfitterContext context, IAuthorizationService authorizationService, IPrincipal user, IMapper mapper, IStackStormService stackStormService, IOptions <VmTaskProcessingOptions> options, IResultService resultService, ILogger <TaskService> logger, IPlayerService playerService, IPlayerVmService playerVmService, IHttpClientFactory httpClientFactory, ClientOptions clientSettings, IHubContext <EngineHub> engineHub, ITaskExecutionQueue taskexecutionQueue) { _context = context; _authorizationService = authorizationService; _user = user as ClaimsPrincipal; _mapper = mapper; _stackStormService = stackStormService; _options = options.Value; _resultService = resultService; _httpClientFactory = httpClientFactory; _logger = logger; _playerService = playerService; _playerVmService = playerVmService; _isHttps = clientSettings.urls.playerApi.ToLower().StartsWith("https:"); _engineHub = engineHub; _taskExecutionQueue = taskexecutionQueue; }
public PermissionService(SteamfitterContext context, IAuthorizationService authorizationService, IPrincipal user, IMapper mapper) { _context = context; _authorizationService = authorizationService; _user = user as ClaimsPrincipal; _mapper = mapper; }
public EngineHub( SteamfitterContext db, IAuthorizationService authorizationService, IPrincipal user) { _db = db; _authorizationService = authorizationService; _user = user as ClaimsPrincipal; }
public FilesService(SteamfitterContext context, IAuthorizationService authorizationService, IPrincipal user, IMapper mapper, FilesOptions fileSettings) { _context = context; _authorizationService = authorizationService; _user = user as ClaimsPrincipal; _mapper = mapper; _options = fileSettings; }
private Entry[] GetEntries(SteamfitterContext db) { var entries = db.Entries .Where(x => x.State == EntityState.Added || x.State == EntityState.Modified || x.State == EntityState.Deleted) .ToList(); db.Entries.Clear(); return(entries.ToArray()); }
public SessionService(SteamfitterContext context, IAuthorizationService authorizationService, IPrincipal user, IMapper mapper, IDispatchTaskService dispatchTaskService) { _context = context; _authorizationService = authorizationService; _user = user as ClaimsPrincipal; _mapper = mapper; _dispatchTaskService = dispatchTaskService; }
public VmCredentialService( SteamfitterContext context, IAuthorizationService authorizationService, IPrincipal user, IMapper mapper, ILogger <TaskService> logger) { _context = context; _authorizationService = authorizationService; _user = user as ClaimsPrincipal; _mapper = mapper; _logger = logger; }
public ScenarioService(SteamfitterContext context, IAuthorizationService authorizationService, IPrincipal user, IMapper mapper, ITaskService taskService, IStackStormService stackstormService) { _context = context; _authorizationService = authorizationService; _user = user as ClaimsPrincipal; _mapper = mapper; _taskService = taskService; _stackstormService = stackstormService; }
public ScenarioTemplateService( SteamfitterContext context, IAuthorizationService authorizationService, ITaskService taskService, IPrincipal user, IMapper mapper, IHubContext <EngineHub> engineHub) { _context = context; _authorizationService = authorizationService; _taskService = taskService; _user = user as ClaimsPrincipal; _mapper = mapper; _engineHub = engineHub; }
private static void ProcessSeedDataOptions(SeedDataOptions options, SteamfitterContext context) { if (options.Permissions.Any()) { var dbPermissions = context.Permissions.ToList(); foreach (PermissionEntity permission in options.Permissions) { if (!dbPermissions.Where(x => x.Key == permission.Key && x.Value == permission.Value).Any()) { context.Permissions.Add(permission); } } context.SaveChanges(); } if (options.Users.Any()) { var dbUsers = context.Users.ToList(); foreach (UserEntity user in options.Users) { if (!dbUsers.Where(x => x.Id == user.Id).Any()) { context.Users.Add(user); } } context.SaveChanges(); } if (options.UserPermissions.Any()) { var dbUserPermissions = context.UserPermissions.ToList(); foreach (UserPermissionEntity userPermission in options.UserPermissions) { if (!dbUserPermissions.Where(x => x.UserId == userPermission.UserId && x.PermissionId == userPermission.PermissionId).Any()) { context.UserPermissions.Add(userPermission); } } context.SaveChanges(); } }
public DispatchTaskService( SteamfitterContext context, IAuthorizationService authorizationService, IPrincipal user, IMapper mapper, IStackStormService stackStormService, IOptions <VmTaskProcessingOptions> options, IDispatchTaskResultService dispatchTaskResultService, ILogger <DispatchTaskService> logger, IPlayerVmService playerVmService, IHttpClientFactory httpClientFactory) { _context = context; _authorizationService = authorizationService; _user = user as ClaimsPrincipal; _mapper = mapper; _stackStormService = stackStormService; _options = options.Value; _dispatchTaskResultService = dispatchTaskResultService; _httpClientFactory = httpClientFactory; _logger = logger; _playerVmService = playerVmService; }
private IEnumerable <TaskEntity> GetSubtasksToExecute(Guid executedTaskId, SteamfitterContext steamfitterContext, Data.TaskStatus executedTaskStatus) { var subtaskEntities = steamfitterContext.Tasks.Where(t => t.TriggerTaskId == executedTaskId); if (subtaskEntities.Any()) { // filter the sutaskEntities based on the trigger task's status switch (executedTaskStatus) { case Data.TaskStatus.succeeded: { subtaskEntities = subtaskEntities.Where(s => s.TriggerCondition == TaskTrigger.Success || s.TriggerCondition == TaskTrigger.Completion); break; } case Data.TaskStatus.failed: { subtaskEntities = subtaskEntities.Where(s => s.TriggerCondition == TaskTrigger.Failure || s.TriggerCondition == TaskTrigger.Completion); break; } case Data.TaskStatus.expired: { subtaskEntities = subtaskEntities.Where(s => s.TriggerCondition == TaskTrigger.Expiration); break; } default: { // Any other status (cancellation in particular) should not launch subtasks return(new List <TaskEntity>()); } } } return(subtaskEntities); }
public UserClaimsService(SteamfitterContext context, IMemoryCache cache, ClaimsTransformationOptions options) { _context = context; _options = options; _cache = cache; }
private async STT.Task <Data.TaskStatus> ProcessTaskAsync(TaskEntity taskToExecute, List <ResultEntity> resultEntityList, SteamfitterContext steamfitterContext, CancellationToken ct) { var overallStatus = Data.TaskStatus.succeeded; var tasks = new List <STT.Task <string> >(); var xref = new Dictionary <int, ResultEntity>(); foreach (var resultEntity in resultEntityList) { resultEntity.InputString = resultEntity.InputString.Replace("{moid}", resultEntity.VmId.ToString()); resultEntity.VmName = _stackStormService.GetVmName((Guid)resultEntity.VmId); resultEntity.Status = TaskStatus.pending; resultEntity.StatusDate = DateTime.UtcNow; // if no expiration is set, us the maximum allowed by the TaskProcessMaxWaitSeconds setting resultEntity.ExpirationSeconds = resultEntity.ExpirationSeconds <= 0 ? _vmTaskProcessingOptions.CurrentValue.TaskProcessMaxWaitSeconds : resultEntity.ExpirationSeconds; var task = RunTask(taskToExecute, resultEntity, ct); tasks.Add(task); xref[task.Id] = resultEntity; await steamfitterContext.SaveChangesAsync(); _engineHub.Clients.All.SendAsync(EngineMethods.ResultUpdated, _mapper.Map <ViewModels.Result>(resultEntity)); } foreach (var bucket in AsCompletedBuckets(tasks)) { try { var task = await bucket; var resultEntity = xref[task.Id]; resultEntity.ActualOutput = task.Result == null ? "" : task.Result.ToString(); resultEntity.Status = ProcessResult(resultEntity, ct); resultEntity.StatusDate = DateTime.UtcNow; if (resultEntity.Status != Data.TaskStatus.succeeded) { if (overallStatus != Data.TaskStatus.failed) { overallStatus = resultEntity.Status; } } await steamfitterContext.SaveChangesAsync(); _engineHub.Clients.All.SendAsync(EngineMethods.ResultUpdated, _mapper.Map <ViewModels.Result>(resultEntity)); } catch (OperationCanceledException) { _logger.LogInformation("the executing task was cancelled"); } catch (Exception ex) { _logger.LogInformation("the executing task caused an exception", ex); } } return(overallStatus); }
private async STT.Task <bool> VerifyTaskToExecuteAsync(TaskEntity taskToExecute, SteamfitterContext steamfitterContext, CancellationToken ct) { if (taskToExecute == null || taskToExecute.ScenarioTemplateId != null) { var message = $"Task {taskToExecute.Id} is part of scenario template, so it cannot be executed."; _logger.LogDebug(message); return(false); } else if (taskToExecute.ScenarioId != null) { var scenario = await steamfitterContext.Scenarios.FindAsync(taskToExecute.ScenarioId); if (scenario.Status != ScenarioStatus.active) { var message = $"Task {taskToExecute.Id} is part of scenario {scenario.Id}, which is not currently active. A Scenario must be active in order to execute its Task."; _logger.LogDebug(message); return(false); } else { return(true); } } else { return(true); } }
private async STT.Task <bool> VerifyTaskToExecuteAsync(TaskEntity taskToExecute, SteamfitterContext steamfitterContext, CancellationToken ct) { var message = $"Task '{taskToExecute.Name}' ({taskToExecute.Id}) was not executed. "; if (taskToExecute == null || taskToExecute.ScenarioTemplateId != null) { message = message + $"It is a scenario template task."; _logger.LogDebug(message); return(false); } else if (taskToExecute.Status == TaskStatus.cancelled) { message = message + $"It has been cancelled."; _logger.LogDebug(message); return(false); } else if (taskToExecute.ScenarioId != null) { var scenario = await steamfitterContext.Scenarios.FindAsync(taskToExecute.ScenarioId); if (scenario.Status != ScenarioStatus.active) { message = message + $"Its scenario {scenario.Id}, is not active."; _logger.LogDebug(message); return(false); } else { return(true); } } else { return(true); } }