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