public async Task <JobQueue> GetFirstUnassignedQueuedJob(string engine, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var queuedJobSpec = new JobQueueFilterSpecification();
var job = await _jobQueueRepository.GetSingleBySpec(queuedJobSpec, cancellationToken);
if (!string.IsNullOrEmpty(engine))
{
if (job == null)
{
var pendingJobSpec = new JobQueueFilterSpecification(null, JobStatus.Queued, engine);
job = await _jobQueueRepository.GetSingleBySpec(pendingJobSpec, cancellationToken);
}
try
{
job.CatapultEngineId = engine;
await _jobQueueRepository.Update(job, cancellationToken);
}
catch (Exception)
{
job = null;
}
}
return(job);
}
public async Task <List <JobQueue> > GetJobQueuesByStatus(string status, CancellationToken cancellationToken = default(CancellationToken))
{
var queueSpec = new JobQueueFilterSpecification(null, status);
var jobQueues = await _jobQueueRepository.GetBySpec(queueSpec, cancellationToken);
return(jobQueues.ToList());
}
public async Task UpdateJobQueue(JobQueue updatedJobQueue, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var jobQueueSpec = new JobQueueFilterSpecification(updatedJobQueue.ProjectId, updatedJobQueue.Id);
jobQueueSpec.Includes.Add(j => j.Project);
var jobQueue = await _jobQueueRepository.GetSingleBySpec(jobQueueSpec, cancellationToken);
if (jobQueue != null && jobQueue.Project.Status != ProjectStatusFilterType.Archived)
{
if (updatedJobQueue.ProjectId == 0 && !string.IsNullOrEmpty(jobQueue.CatapultEngineId) && jobQueue.CatapultEngineId != updatedJobQueue.CatapultEngineId)
{
throw new JobProcessedByOtherEngineException(jobQueue.Id);
}
jobQueue.CatapultEngineId = updatedJobQueue.CatapultEngineId;
jobQueue.CatapultEngineIPAddress = updatedJobQueue.CatapultEngineIPAddress;
jobQueue.CatapultEngineMachineName = updatedJobQueue.CatapultEngineMachineName;
jobQueue.Status = updatedJobQueue.Status;
jobQueue.JobTasksStatus = updatedJobQueue.JobTasksStatus;
jobQueue.JobType = updatedJobQueue.JobType;
jobQueue.OutputValues = updatedJobQueue.OutputValues;
jobQueue.Remarks = updatedJobQueue.Remarks;
await _jobQueueRepository.Update(jobQueue, cancellationToken);
}
}
public async Task SendNotification(int jobQueueId, string webUrl, CancellationToken cancellationToken = default(CancellationToken))
{
var jobQueueSpec = new JobQueueFilterSpecification(0, jobQueueId);
jobQueueSpec.Includes.Add(q => q.Project.Members);
var jobQueue = await _jobQueueRepository.GetSingleBySpec(jobQueueSpec, cancellationToken);
var users = await _userRepository.GetUsersByIds(jobQueue.Project.Members.Select(m => m.UserId).ToArray());
var jobQueueWebUrl = $"{webUrl}/project/{jobQueue.ProjectId}/job-queue/{jobQueueId}";
await _notificationProvider.SendNotification(new SendNotificationRequest
{
MessageType = NotificationConfig.JobQueueCompleted,
Emails = users.Select(u => u.Email).Distinct().ToList()
}, new Dictionary <string, string>
{
{ MessageParameter.JobCode, jobQueue.Code },
{ MessageParameter.JobDefinitionName, jobQueue.JobDefinitionName },
{ MessageParameter.ProjectName, jobQueue.Project.Name },
{ MessageParameter.JobStatus, jobQueue.Status },
{ MessageParameter.Remarks, jobQueue.Remarks },
{ MessageParameter.WebUrl, jobQueueWebUrl },
{ MessageParameter.JobTaskStatus, GenerateJobTaskStatusNotificationMessage(jobQueue.JobTasksStatus) }
});
}
public async Task <JobQueue> GetJobQueueByCode(int projectId, string jobQueueCode, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var jobQueueSpec = new JobQueueFilterSpecification(projectId, jobQueueCode, null);
var jobQueue = await _jobQueueRepository.GetSingleBySpec(jobQueueSpec, cancellationToken);
return(jobQueue);
}
public async Task <JobQueue> GetJobQueueByCode(string jobQueueCode, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var queueSpec = new JobQueueFilterSpecification(jobQueueCode, null);
queueSpec.Includes.Add(q => q.JobDefinition);
var queue = await _jobQueueRepository.GetSingleBySpec(queueSpec, cancellationToken);
return(queue);
}
public async Task <JobQueue> GetJobQueueById(int projectId, int id, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var jobQueueSpec = new JobQueueFilterSpecification(projectId, id);
jobQueueSpec.Includes.Add(q => q.JobDefinition);
var jobQueue = await _jobQueueRepository.GetSingleBySpec(jobQueueSpec, cancellationToken);
return(jobQueue);
}
public async Task <int> AddJobQueue(int projectId, string originUrl, string jobType, int?jobDefinitionId, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var project = await _projectRepository.GetById(projectId, cancellationToken);
bool projectAllowAddingQueue = project?.Status == ProjectStatusFilterType.Active ||
(project?.Status == ProjectStatusFilterType.Deleting && jobType == JobType.Delete);
if (project == null || !projectAllowAddingQueue)
{
throw new ProjectNotFoundException(projectId);
}
var inProgressJobSpec = new JobQueueFilterSpecification(projectId, _inProgressJobStatus);
var inProgressJob = await _jobQueueRepository.GetSingleBySpec(inProgressJobSpec, cancellationToken);
if (inProgressJob != null)
{
if (project.Status == ProjectStatusFilterType.Deleting && jobType != JobType.Delete)
{
return(inProgressJob.Id);
}
throw new JobQueueInProgressException(projectId);
}
// detemine the jobQueue type if it is not provided by the caller
if (string.IsNullOrWhiteSpace(jobType))
{
jobType = JobType.Create;
var hasBeenCreatedBefore = (await _jobQueueRepository.CountBySpec(new JobQueueFilterSpecification(projectId, new string[] { JobStatus.Completed }))) > 0;
if (hasBeenCreatedBefore)
{
jobType = JobType.Update;
}
}
var newJobQueue = new JobQueue
{
ProjectId = projectId,
Code = await GetNextJobCode(),
OriginUrl = originUrl,
JobType = jobType,
JobDefinitionId = jobDefinitionId,
Status = JobStatus.Queued
};
return(await _jobQueueRepository.Create(newJobQueue, cancellationToken));
}
public async Task CancelJobQueue(int id, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var jobQueueSpec = new JobQueueFilterSpecification(0, id);
jobQueueSpec.Includes.Add(q => q.Project);
var jobQueue = await _jobQueueRepository.GetSingleBySpec(jobQueueSpec, cancellationToken);
if (jobQueue != null)
{
if (!_inProgressJobStatus.Contains(jobQueue.Status))
{
throw new CancelCompletedJobException(id);
}
jobQueue.Status = JobStatus.Cancelled;
await _jobQueueRepository.Update(jobQueue, cancellationToken);
}
}
public async Task <List <JobQueue> > GetJobQueues(int projectId, string filter, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
JobQueueFilterSpecification queueSpec;
switch (filter?.ToLower())
{
case JobQueueFilterType.All:
queueSpec = new JobQueueFilterSpecification(projectId, null);
break;
case JobQueueFilterType.Current:
queueSpec = new JobQueueFilterSpecification(projectId, _inProgressJobStatus);
break;
case JobQueueFilterType.Past:
queueSpec = new JobQueueFilterSpecification(projectId, _pastJobStatus);
break;
case JobQueueFilterType.Succeeded:
queueSpec = new JobQueueFilterSpecification(projectId, new string[] { JobStatus.Completed });
break;
case JobQueueFilterType.Failed:
queueSpec = new JobQueueFilterSpecification(projectId, new string[] { JobStatus.Error });
break;
default:
throw new FilterTypeNotFoundException(filter);
}
queueSpec.Includes.Add(q => q.JobDefinition);
var jobQueues = await _jobQueueRepository.GetBySpec(queueSpec, cancellationToken);
return(jobQueues.ToList());
}
