/// <summary>
/// Create query
/// </summary>
/// <param name="query"></param>
/// <param name="queryParameters"></param>
/// <returns></returns>
private static string CreateQuery(JobInfoQueryModel query,
out Dictionary <string, object> queryParameters)
{
queryParameters = new Dictionary <string, object>();
var queryString = $"SELECT * FROM r WHERE ";
if (query?.Status != null)
{
queryString +=
$"r.{nameof(JobDocument.Status)} = @state AND ";
queryParameters.Add("@state", query.Status.Value);
}
if (query?.Name != null)
{
queryString +=
$"r.{nameof(JobDocument.Name)} = @name AND ";
queryParameters.Add("@name", query.Name);
}
if (query?.JobConfigurationType != null)
{
queryString +=
$"r.{nameof(JobDocument.Type)} = @type AND ";
queryParameters.Add("@type", query.JobConfigurationType);
}
queryString +=
$"r.{nameof(JobDocument.ClassType)} = '{JobDocument.ClassTypeName}'";
return(queryString);
}
/// <inheritdoc/>
public async Task <JobInfoListModel> QueryJobsAsync(JobInfoQueryModel query,
int?maxResults, CancellationToken ct)
{
var request = query.Map <JobInfoQueryApiModel>();
var result = await _client.QueryJobsAsync(request, maxResults, ct);
return(result.Map <JobInfoListModel>());
}
/// <inheritdoc/>
public async Task <JobProcessingInstructionModel> GetAvailableJobAsync(string workerId,
JobRequestModel request, CancellationToken ct)
{
var query = new JobInfoQueryModel {
Status = JobStatus.Active // Only query active jobs
};
string continuationToken = null;
do
{
var jobList = await _jobRepository.QueryAsync(query, continuationToken, null, ct);
if (jobList?.Jobs == null)
{
break;
}
System.Diagnostics.Debug
.Assert(!jobList.Jobs.Any(j => j.LifetimeData.Status != JobStatus.Active));
// Filter demands
var demandFilteredJobs = jobList.Jobs
.Where(j => _demandMatcher.MatchCapabilitiesAndDemands(j.Demands,
request?.Capabilities))
.ToArray();
foreach (var job in demandFilteredJobs)
{
// Test the listed job first before hitting the database
var jobProcessInstruction = CalculateInstructions(job, workerId);
if (jobProcessInstruction != null)
{
try {
await _jobRepository.UpdateAsync(job.Id, existingJob => {
// Try again on the current value in the database
jobProcessInstruction = CalculateInstructions(existingJob, workerId);
if (jobProcessInstruction != null)
{
_jobEventHandler.OnJobAssignmentAsync(_jobService, jobProcessInstruction.Job, workerId).Wait();
}
return(Task.FromResult(jobProcessInstruction != null));
}, ct);
return(jobProcessInstruction);
}
catch (ResourceNotFoundException) {
continue; // Job deleted while updating, continue to next job
}
}
}
continuationToken = jobList.ContinuationToken;
}while (continuationToken != null);
return(null);
}
/// <inheritdoc/>
public async Task <JobInfoListModel> QueryAsync(JobInfoQueryModel query,
string continuationToken, int?maxResults, CancellationToken ct)
{
var client = _documents.OpenSqlClient();
var results = continuationToken != null?
client.Continue <JobDocument>(continuationToken, maxResults) :
client.Query <JobDocument>(CreateQuery(query, out var queryParameters),
queryParameters, maxResults);
if (!results.HasMore())
{
return(new JobInfoListModel());
}
var documents = await results.ReadAsync(ct);
return(new JobInfoListModel {
ContinuationToken = results.ContinuationToken,
Jobs = documents.Select(r => r.Value.ToFrameworkModel()).ToList()
});
}
/// <inheritdoc/>
public async Task <JobInfoListModel> QueryAsync(JobInfoQueryModel query,
string continuationToken, int?maxResults, CancellationToken ct)
{
await _lock.WaitAsync();
try {
var jobs = _jobs.Select(j => j.Clone()).ToList();
if (query != null)
{
// TODO
throw new NotImplementedException();
}
return(new JobInfoListModel {
Jobs = jobs
});
}
finally {
_lock.Release();
}
}
/// <inheritdoc/>
public async Task <JobInfoListModel> QueryJobsAsync(JobInfoQueryModel query,
int?maxResults, CancellationToken ct)
{
return(await _jobRepository.QueryAsync(query, null, maxResults, ct));
}
