public async Task <SortJob> Process(SortJob job)
{
_logger.LogInformation("Processing job with ID '{JobId}'.", job.Id);
_jobsDetails.TryAdd(job.Id, job);
var stopwatch = Stopwatch.StartNew();
var output = job.Input.OrderBy(n => n).ToArray();
await Task.Delay(5000); // NOTE: This is just to simulate a more expensive operation
var duration = stopwatch.Elapsed;
_logger.LogInformation("Completed processing job with ID '{JobId}'. Duration: '{Duration}'.", job.Id, duration);
var completed = new SortJob(
id: job.Id,
status: SortJobStatus.Completed,
duration: duration,
input: job.Input,
output: output);
_jobsDetails.TryUpdate(job.Id, completed, job);
return(completed);
}
public void Process()
{
var job = DataStorage.GetDataAll().Where(x => x.Status == SortJobStatus.Pending).FirstOrDefault();
if (job != null)
{
_logger.LogInformation("Processing job with ID '{JobId}'.", job.Id);
var stopwatch = Stopwatch.StartNew();
var output = job.Input.OrderBy(n => n).ToArray();
//await Task.Delay(5000); // NOTE: This is just to simulate a more expensive operation
var duration = stopwatch.Elapsed;
_logger.LogInformation("Completed processing job with ID '{JobId}'. Duration: '{Duration}'.", job.Id, duration);
var updatedJob = new SortJob(
id: job.Id,
status: SortJobStatus.Completed,
duration: duration,
input: job.Input,
output: output);
//Remove old item
DataStorage.GetDataAll().Remove(job);
//Add updated item
DataStorage.GetDataAll().Add(updatedJob);
}
//return null;
}
public Task <SortJob> GetJob(Guid jobid)
{
var data = listOfJobs.Where(j => j.Id == jobid).ToList();
SortJob sortJob = new SortJob(data[0].Id, data[0].Status, data[0].Duration, data[0].Input, data[0].Output);
return(Task.FromResult(sortJob));
}
public async Task AddJob(SortJob job)
{
await Task.Run(() =>
{
Jobs.Enqueue(job);
JobDictionary.TryAdd(job.Id.ToString(), job);
});
}
public SortJob?GetJob(Guid jobId)
{
int[] input = {};
SortJob?value = new SortJob(jobId, SortJobStatus.Pending, null, input, null);
_jobsDetails.TryGetValue(jobId, out value);
return(value);
}
public SortJob PushQueue(SortJob sortJob)
{
if (!_jobQueue.Any(x => x.Id == sortJob.Id))
{
_logger.LogInformation("Enqueueing the JobID {0}", sortJob.Id);
_jobQueue.Enqueue(sortJob);
}
return(sortJob);
}
public async void Enqueue(SortJob job)
{
_logger.LogInformation("Enqueue Job in List '{JobId}'.", job.Id);
srtJobs.Add(job);
await Task.Delay(5000); //wait for 5 sec to process the queued job
await ProcessQueue();
}
public void EnqueueJob(SortJob objJob)
{
_pendingJobs.Add(objJob);
Task.Factory.StartNew(() =>
{
ProcessJob(objJob);
}
);
}
/// <summary>
/// Enqueues the sorting job request coming from the API.
/// </summary>
/// <param name="job">The sorting job.</param>
/// <returns>The response of the sort job.</returns>
public async Task <SortJob> EnqueueJob(SortJob job)
{
await this.jobPersistenceStore.PersistSortJob(job);
await Task.Factory.StartNew(
() => this.Process(job));
return(job);
}
public async Task <SortJob> CreateJob(IReadOnlyCollection <int> input)
{
var pendingJob = new SortJob(Guid.NewGuid(), SortJobStatus.Pending, null, input, null);
_sortJobsRepo.Add(pendingJob.Id, pendingJob);
ProcessJob(pendingJob);
return(await Task.FromResult(pendingJob));
}
private async Task <SortJob> UpdatePersistedJob(SortJob sortJob, Guid jobId)
{
if (storedData.ContainsKey(jobId))
{
storedData.Remove(jobId);
storedData.Add(jobId, sortJob);
}
return(await Task.Run(() => sortJob));
}
/// <summary>
/// Enqueues job in TPL task and add job reference in {_jobs} ConcurrentDictionary
/// TPL task will wait explictily and updates the job status in ConcurrentDictionary after the job completion
/// </summary>
/// <param name="job"></param>
public void Enqueue(SortJob job)
{
_logger.LogInformation("Enqueuing job with ID '{JobId}'.", job.Id);
_jobs.Add(job.Id, job);
Task.Run(() =>
{
var completedJob = Process(job).Result;
_jobs[job.Id] = completedJob;
});
}
public SortJob PushInQueue(int[] values)
{
SortJob?pendingJob = new SortJob(
id: Guid.NewGuid(),
status: SortJobStatus.Pending,
duration: null,
input: values,
output: null);
Queue.Add(pendingJob.Id, pendingJob);
return(pendingJob);
}
public async Task <SortJob> EnqueueJob(SortJob job)
{
await Task.Delay(0);
DataStorage.SetData(job);
//jobQueue.Add(job);
return(new SortJob(
id: job.Id,
status: SortJobStatus.Pending,
duration: null,
input: job.Input,
output: null));
}
/// <summary>
/// Persists the sorting job in in-memory object.
/// </summary>
/// <param name="sortJob">The sort object.</param>
/// <param name="isUpdateOperation">The value which tells us whether this method is used for adding or updating jobs.</param>
/// <param name="updatingJobId">The job id of the updating job.</param>
/// <returns>The persisted sorting job.</returns>
public async Task <SortJob> PersistSortJob(
SortJob sortJob,
bool isUpdateOperation = false,
Guid updatingJobId = default)
{
if (isUpdateOperation)
{
return(await this.UpdatePersistedJob(sortJob, updatingJobId));
}
storedData.Add(sortJob.Id, sortJob);
return(sortJob);
}
/// <summary>
/// Enqueues incoming jobs to be sorted
/// </summary>
/// <param name="job">incoming job</param>
/// <returns>List of all the jobs in the queue</returns>
async Task <IEnumerable <SortJob> > ISortJobProcessor.QueueJob(SortJob job)
{
List <SortJob> sortJob = new List <SortJob>();
await Task.Run(() => {
ApplicationCache.AppCache.Add(job.Id, job); //Insert the job in inmemory cache
});
foreach (var item in ApplicationCache.AppCache.Keys)
{
sortJob.Add(ApplicationCache.AppCache[item]);
}
return(sortJob.ToList());
}
/// <summary>
/// This method is to push the job into the concurrent queue.
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public bool SubmitJob(SortJob job)
{
bool IsSubmitted = false;
try
{
_logger.LogInformation("Pushing job into concurrent queue with ID '{JobId}'.", job.Id);
if (!_jobQueue.Any(x => x.Id == job.Id))
{
_memoryCache.Set(job.Id, job);
_jobQueue.Enqueue(job);
IsSubmitted = true;
}
}
catch (Exception)
{
throw;
}
return(IsSubmitted);
}
public async Task <SortJob> Process(SortJob job)
{
_logger.LogInformation("Processing job with ID '{JobId}'.", job.Id);
var stopwatch = Stopwatch.StartNew();
var output = job.Input.OrderBy(n => n).ToArray();
await Task.Delay(5000); // NOTE: This is just to simulate a more expensive operation
var duration = stopwatch.Elapsed;
_logger.LogInformation("Completed processing job with ID '{JobId}'. Duration: '{Duration}'.", job.Id, duration);
var updatedJob = new SortJob(
id: job.Id,
status: SortJobStatus.Completed,
duration: duration,
input: job.Input,
output: output);
return(await this.jobPersistenceStore.PersistSortJob(updatedJob, true, updatedJob.Id));
}
public async Task BackgroundProcess(SortJob pendingJob)
{
object j = new object();
var completedJob = await Process(pendingJob);
await Task.Run(() => {
j = ApplicationCache.AppCache[completedJob.Id];
});
var job = (SortJob)j;
var updatedJob = new SortJob(
id: Guid.NewGuid(),
status: SortJobStatus.Completed,
duration: completedJob.Duration,
input: job.Input,
output: completedJob.Output);
await Task.Run(() => {
ApplicationCache.AppCache[job.Id] = updatedJob; //Update the job in inmemory cache dictionary
});
}
public async Task <SortJob> Process(SortJob job)
{
_logger.LogInformation("Processing job with ID '{JobId}'.", job.Id);
_listSortJob.Add(job);
var stopwatch = Stopwatch.StartNew();
var output = job.Input.OrderBy(n => n).ToArray();
await Task.Delay(50000); // NOTE: This is just to simulate a more expensive operation
var duration = stopwatch.Elapsed;
_logger.LogInformation("Completed processing job with ID '{JobId}'. Duration: '{Duration}'.", job.Id, duration);
var item = _listSortJob.Remove(_listSortJob.Where(x => x.Id == job.Id).FirstOrDefault());
var completedJob = new SortJob(
id: job.Id,
status: SortJobStatus.Completed,
duration: duration,
input: job.Input,
output: output);
_listSortJob.Add(completedJob);
return(completedJob);
}
public static void SetData(SortJob sortJob)
{
jobQueue.Add(sortJob);
}
public async Task ProcessAsync(SortJob job)
{
await _jobStore.AddJob(job);
}
private void ProcessJob(SortJob objJob)
{
_completedJobs.Add(_sortJobProcessor.Process(objJob).Result);
}
private async void ProcessJob(SortJob job)
{
var completedJob = await _sortJobProcessor.Process(job);
_sortJobsRepo[job.Id] = completedJob;
}
