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