public override Task <Response> HandleAsync() { log.Trace("Handle: '{0}' JobId: '{1}'", request.Handle, request.JobId); return(Task.Run <Response>(() => { LinkResponse response = null; Job job = jobManager.GetJob(request.JobId); if (job == null) { ResponseData responseData = GetResponseData(true, Resources.JobRequestHandler_NoSuchJob_Message); response = new LinkResponse { ExitStatus = (uint)responseData.ExitStatus, Stderr = responseData.Message, }; } else { IJobResult result = job.RunnableTask.Result; response = new LinkResponse { ExitStatus = (uint)result.ExitCode, Stderr = result.Stderr, Stdout = result.Stdout, }; } response.Info = BuildInfoResponse(); return response; })); }
public async Task <StreamResponse> HandleAsync(MessageWriter messageWriter, CancellationToken cancellationToken) { if (messageWriter == null) { throw new ArgumentNullException("messageWriter"); } if (cancellationToken == null) { throw new ArgumentNullException("cancellationToken"); } this.messageWriter = messageWriter; log.Trace("HandleAsync: '{0}' JobId: '{1}''", request.Handle, request.JobId); StreamResponse streamResponse = null; Job job = GetJobById(request.JobId, ref streamResponse); // if job is null, streamResponse is set to error if (job != null) { if (job.HasStatus) { var awaitables = new List <Task>(); foreach (IJobStatus status in job.RetrieveStatus()) { awaitables.Add(ListenStatusAsync(status)); } await Task.WhenAll(awaitables); } try { if (job.IsCompleted) { if (job.Result == null) { streamResponse = ToStreamResponse(GetResponseData(true, "Error! Job with ID '{0}' is completed but no result is available!\n", request.JobId)); } else { streamResponse = ToStreamResponse(job.Result); } } else { job.AttachListener(this); IJobResult result = await job.ListenAsync(); streamResponse = StreamResponse.Create(result.ExitCode); } } finally { jobManager.RemoveJob(request.JobId); } } return(streamResponse); }
private void FinishJob(IJobResult jobResult) { var nextOperation = OperationManager.GetNextOperation(key: jobResult.Key); if (nextOperation != null) { nextOperation.StartConditions.PreCondition = true; Agent.DebugMessage(msg: $"PreCondition for operation {nextOperation.Operation.Name} at {_articleToProduce.Article.Name} was set true."); Agent.Send(instruction: BasicInstruction.UpdateStartConditions.Create(message: nextOperation.GetStartCondition(), target: nextOperation.HubAgent)); return; } Agent.DebugMessage(msg: $"All operations for article {_articleToProduce.Article.Name} {_articleToProduce.Key} finished."); //TODO add production amount to productionresult, currently static 1 var productionResponse = new FProductionResult(key: _articleToProduce.Key , trackingId: _articleToProduce.StockExchangeId , creationTime: 0 , amount: 1); Agent.Send(instruction: Storage.Instruction.ResponseFromProduction.Create(message: productionResponse, target: _articleToProduce.StorageAgent)); if (_articleToProduce.IsHeadDemand) { var pub = new FThroughPutTime(articleKey: _articleToProduce.Key , articleName: _articleToProduce.Article.Name , start: _articleToProduce.CreationTime , end: Agent.CurrentTime); Agent.Context.System.EventStream.Publish(@event: pub); } Agent.TryToFinish(); }
private void UpdateCompletionList(IWorkContext context, IJobResult jobResult) { context.Verify(nameof(context)).IsNotNull(); jobResult.Verify(nameof(jobResult)).IsNotNull(); jobResult.JobId.Verify(nameof(jobResult.JobId)).IsNotNull(); context.Telemetry.ActivityStop(context, $"{nameof(UpdateCompletionList)} for JobId={((Guid)jobResult.JobId).ToString()}, Status={jobResult.Status}", (long)(jobResult.Duration?.TotalMilliseconds ?? 0)); if (_semaphore != null) { _semaphore.Release(); context.Telemetry.TrackMetric(context, $"{nameof(RunJobGraph)}:Release-Semaphore-CurrentCount", (double)_semaphore.CurrentCount); } lock (_lock) { if (_processedDict.TryGetValue((Guid)jobResult.JobId, out TKey value)) { if (jobResult.Status == JobStatus.Completed) { _graphContext.AddProcessedNodeKey(value); } else { _graphContext.AddStopNodeKey(value); } _runningKeys.Remove(value); } } }
public void FinishJob(IJobResult jobResult) { var operation = _operationList.Find(match: x => x.Key == jobResult.Key); Agent.DebugMessage(msg: $"Resource called Item {operation.Operation.Name} {jobResult.Key} finished."); Agent.Send(instruction: BasicInstruction.FinishJob.Create(message: jobResult, target: operation.ProductionAgent)); _operationList.Remove(item: operation); }
public override Task <Response> HandleAsync() { log.Trace("Handle: '{0}' JobId: '{1}'", request.Handle, request.JobId); return(Task.Run <Response>(async() => { LinkResponse response = null; Job job = jobManager.GetJob(request.JobId); if (job == null) { ResponseData responseData = GetResponseData(true, Resources.JobRequestHandler_NoSuchJob_Message); response = new LinkResponse { ExitStatus = (uint)responseData.ExitStatus, Stderr = responseData.Message, }; } else { IJobResult result = await job.RunnableTask; response = new LinkResponse { ExitStatus = (uint)result.ExitCode, Stderr = result.Stderr, Stdout = result.Stdout, }; } try { response.Info = await BuildInfoResponseAsync(); } catch (OperationCanceledException) { // If the container is shutting down the link request may be completed and unable to build an information response // via normal channels. In this case, we return a stopped info response. response.Info = new InfoResponse() { State = IronFrame.ContainerState.Stopped.ToString() }; } catch (Exception) { response.Info = new InfoResponse() { State = IronFrame.ContainerState.Stopped.ToString() }; } return response; })); }
public void JobCompleted(IJobDetail jobDetail, IJobResult jobResult) { if (!_jobs.ContainsKey(jobDetail.Id)) { return; } var currentJobDetail = _jobs[jobDetail.Id]; jobDetail.Status = JobStatus.Completed; _jobs.TryUpdate(jobDetail.Id, jobDetail, currentJobDetail); _results.TryAdd(jobDetail, jobResult); }
public async void RunAsync() { try { runnableTask = runnable.RunAsync(); result = await runnableTask; } catch (Exception ex) { result = new JobExceptionResult(ex); } finally { isCompleted = true; } }
private void FinishJob(IJobResult jobResult) { Agent.DebugMessage(msg: $"Finished Work with {_jobInProgress.Current.Name} {_jobInProgress.Current.Key} take next..."); jobResult = jobResult.FinishedAt(Agent.CurrentTime); Agent.Send(instruction: BasicInstruction.FinishJob.Create(message: jobResult, target: _jobInProgress.Current.HubAgent)); _jobInProgress.Reset(); // then requeue processing queue if the item was delayed if (jobResult.OriginalDuration != Agent.CurrentTime - jobResult.Start) { RequeueAllRemainingJobs(); } // Do Work TryToWork(); }
public virtual async void RunAsync() { try { runnableTask = runnable.RunAsync(); result = await runnableTask; } catch (Exception ex) { log.Error("Exception running job: {0}", ex.ToString()); result = new JobExceptionResult(ex); } finally { isCompleted = true; } }
public override Task <Response> HandleAsync() { log.Trace("Handle: '{0}' Script: '{1}'", request.Handle, request.Script); IJobRunnable runnable = base.GetRunnableFor(request); return(Task.Run <Response>(() => { IJobResult result = runnable.Run(); // run synchronously return new RunResponse { ExitStatus = (uint)result.ExitCode, Stdout = result.Stdout, Stderr = result.Stderr, Info = BuildInfoResponse() }; })); }
public IJob CreateFromResult(IJobResult result, IFractalSettings settings, IShader shader, int numberOfSectors) { // TODO: this should use the same grouping logic as the algorithm var allParts = result.RenderResults.Select(r => r.CalculatedFractalPart).OrderBy(r => r.ScreenPosition.Left).ToArray(); var sizePerSector = settings.ScreenWidth / numberOfSectors; var combinedParts = new List <CalculatedFractalPart>(); for (var sector = 0; sector < numberOfSectors; sector++) { var left = sizePerSector * sector; var right = sector == numberOfSectors - 1 ? settings.ScreenWidth - 1 : left + sizePerSector - 1; var relevantParts = allParts.Where(part => part.ScreenPosition.Left >= left && part.ScreenPosition.Right <= right); var paths = relevantParts.SelectMany(part => part.Paths.Select(path => path.Adjust(part.ScreenPosition.Left - left, 0))); combinedParts.Add(new CalculatedFractalPart(new Rectangle <int>(left, 0, right, settings.ScreenHeight - 1), paths)); } var renderSpecs = combinedParts.Select(part => this.renderSpecificationFactory.CreateFromCalculatedPart(part, settings, shader)); return(new Job(settings, renderSpecs.ToArray())); }
private void Completed(IWorkContext context, Task task, Guid jobId, IJobResult jobResult) { JobEntry jobEntry = null; lock (_lock) { if (!_currentJob.TryGetValue(jobId, out jobEntry)) { return; } context.Telemetry.Verbose(context, $"Removed {jobId} from current job list because signaled completed"); _currentJob.Remove(jobId); } JobStatus status = task.IsFaulted ? JobStatus.Faulted : jobResult.Status; TimeSpan duration = DateTimeOffset.Now - jobEntry.StartTime; string msg = $"Job completed - Job Id={jobId}, Status={jobResult.Status}, IsFaulted={task.IsFaulted}, Duration={duration}"; if (!task.IsFaulted && jobResult.Status == JobStatus.Completed) { context.Telemetry.Verbose(context, msg); } else { context.Telemetry.Error(context, msg, task.Exception); } jobEntry?.CompletionNotification(context, new JobResult(jobId, status, duration, jobResult.Errors, task.Exception)); if (task.IsFaulted) { context.Telemetry.Verbose(context, "Task disposed"); task.Dispose(); } }
public async Task <IJobResult> ListenAsync() { if (this.listener == null) { throw new InvalidOperationException("Must attach listener before calling Listen()"); } if (this.runnableTask == null) { throw new InvalidOperationException("Must call Run() before calling Listen()"); } try { runnable.JobStatusAvailable += runnable_JobStatusAvailable; result = await runnableTask; } finally { runnable.JobStatusAvailable -= runnable_JobStatusAvailable; isCompleted = true; } return(result); }
public void FinishedWith(IJobResult jobResult) { _taskCompletionSource.SetResult(jobResult); }
private static StreamResponse ToStreamResponse(IJobResult result) { return StreamResponse.Create(result.ExitCode, result.Stdout, result.Stderr); }
public Job() { JobDetail = new JobDetail(); Results = new JobResult(); }
private static StreamResponse ToStreamResponse(IJobResult result) { return(StreamResponse.Create(result.ExitCode, result.Stdout, result.Stderr)); }