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