public async Task <IHttpActionResult> Average(AverageProjectsModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!AllProjectsExist(model.Projects))
{
return(NotFound());
}
var now = DateTime.UtcNow;
var project = new Project
{
UserId = User.Identity.GetUserId(),
TraceId = Guid.NewGuid(),
Name = model.Name,
FileName = FormatStitchedFrom(model.Projects),
TestName = model.TestName,
TestType = model.TestType,
Channel = model.Channel,
Tag = model.Tag,
Mass = model.Mass,
Area = model.Area,
Comments = $"{model.Comments} {FormatStitchedFromNames(model.Projects)}",
IsAveragePlot = true,
CreatedAt = now,
UpdatedAt = now,
StitchedFromNames = FormatStitchedFromNames(model.Projects),
};
_db.Projects.Add(project);
await _db.SaveChangesAsync();
var traceId = project.TraceId.ToString();
project.JobId = _jobClient.Enqueue <IBackgroundProcessor>(
p => p.PrepareAverageProject(
traceId,
project.Id,
model.Projects,
JobCancellationToken.Null));
await _db.SaveChangesAsync();
var timeoutJobId = _jobClient.Schedule <IBackgroundProcessor>(
p => p.HandleTimeout(traceId, project.Id),
_options.ProjectPrepareTimeout);
_jobClient.ContinueWith <IBackgroundProcessor>(project.JobId,
p => p.CancelTimeout(traceId, project.Id, timeoutJobId),
JobContinuationOptions.OnAnyFinishedState);
return(Ok());
}
public IHttpActionResult Delete([FromODataUri] int key)
{
var project = GetAllUserProjects().SingleOrDefault(p => p.Id == key);
if (project == null)
{
return(NotFound());
}
var userId = HttpContext.Current.User.Identity.GetUserId();
var traceId = project.TraceId.ToString();
_db.SP_DeleteProject(userId, key);
_db.SaveChanges();
if (!string.IsNullOrWhiteSpace(project.JobId) && _jobClient.Delete(project.JobId))
{
_jobClient.ContinueWith <IBackgroundProcessor>(project.JobId, p => p.DeleteProjectData(traceId, project.Id), JobContinuationOptions.OnAnyFinishedState);
if (project.InternalFileName != null)
{
if (_options.RawFileRetentionPeriod > TimeSpan.Zero)
{
_jobClient.Schedule <IBackgroundProcessor>(p => p.DeleteRawFile(traceId, project.Id, project.InternalFileName), _options.RawFileRetentionPeriod);
}
else
{
_jobClient.ContinueWith <IBackgroundProcessor>(project.JobId, p => p.DeleteRawFile(traceId, project.Id, project.InternalFileName), JobContinuationOptions.OnAnyFinishedState);
}
}
}
else
{
_jobClient.Enqueue <IBackgroundProcessor>(p => p.DeleteProjectData(traceId, project.Id));
if (project.InternalFileName != null)
{
if (_options.RawFileRetentionPeriod > TimeSpan.Zero)
{
_jobClient.Schedule <IBackgroundProcessor>(p => p.DeleteRawFile(traceId, project.Id, project.InternalFileName), _options.RawFileRetentionPeriod);
}
else
{
_jobClient.Enqueue <IBackgroundProcessor>(p => p.DeleteRawFile(traceId, project.Id, project.InternalFileName));
}
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public string ProcessTask(TaskInpuModel inputModel)
{
var state = new EnqueuedState(JobQueues.Task);
var jobId = jobClient.Create <ITaskJob>(job => job.Run(inputModel, null), state);
state = new EnqueuedState(JobQueues.Notify);
jobId = jobClient.ContinueWith <INotifyJob>(jobId, job => job.Notify(inputModel, null), state);
return(jobId);
}
/// <summary>
/// Handles the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task<System.String>.</returns>
public Task <string> Handle(AWSTestDeploymentScriptCommand request, CancellationToken cancellationToken)
{
var parentJobId = _backgroungJobClient.Enqueue <IAWSResourcesService>(c => c.CreateDockerVM(
request.StackName, request.Json, request.Parameters, request.CredentialsId));
if (request.DockerImageId != Guid.Empty)
{
_backgroungJobClient.ContinueWith <IAWSResourcesService>(parentJobId, x => x.DeployImageToVM(request.StackName, request.CredentialsId, request.DockerImageId));
}
return(Task.FromResult(parentJobId));
}
/// <summary>
/// Handles the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task<System.String>.</returns>
public async Task <string> Handle(AzureTestCreateResourcesCommand request, CancellationToken cancellationToken)
{
var parentJobId = _backgroungJobClient.Enqueue <IAzureResourceService>(c => c.TestCreateResources(
request.ResourceName, request.Region, request.DeploymentJson, request.DeploymentParameters, request.CredentialsId));
if (request.DockerImageId != Guid.Empty)
{
_backgroungJobClient.ContinueWith <IAzureResourceService>(parentJobId, x => x.DeployImageToAzureHost(request.ResourceName, request.CredentialsId, request.DockerImageId));
}
return(await Task.FromResult(parentJobId));
}
/// <summary>
/// Starts a new job if we are running inside a job, it marks it as a child.
/// </summary>
public void Start <TJob>([InstantHandle][NotNull] Expression <Action <TJob> > methodCall)
{
var context = performingContextAccessor.Get();
if (context != null)
{
backgroundJobClient.ContinueWith(context.BackgroundJob.Id, methodCall);
}
else
{
backgroundJobClient.Enqueue(methodCall);
}
}
void ITenantJobs.ScheduleTableauPdfDownload(CreatePdfOptions options)
{
var jobId = InnerBackgroundJobClient.Enqueue <ITenantJobs>(z => z.CreateTableauPdf(options));
InnerBackgroundJobClient.ContinueWith <ITenantJobs>(jobId, y => y.DownloadTableauPdfContinuationJobAsync());
}
private void QueueReportDownload(CreatePdfOptions options)
{
var jobId = Backgrounder.Enqueue <ITenantJobs>(z => z.CreateTableauPdf(options));
Backgrounder.ContinueWith <ITenantJobs>(jobId, y => y.DownloadTableauPdfContinuationJobAsync());
}
private void ScheduleProjectForProcessing(Project entity)
{
var timeoutJobId = _jobClient.Schedule <IBackgroundProcessor>(p => p.HandleTimeout(entity.TraceId.ToString(), entity.Id), _options.ProjectPrepareTimeout);
_jobClient.ContinueWith <IBackgroundProcessor>(entity.JobId, p => p.CancelTimeout(entity.TraceId.ToString(), entity.Id, timeoutJobId), JobContinuationOptions.OnAnyFinishedState);
}
