public async Task <WrappedResponse <bool> > RunByIdAsync([FromQuery] Guid projectId)
{
using (CallProxy)
{
return(await CallProxy.CallAsync(async() => await runner.RunAsync(projectId)));
}
}
internal override async Task <ExceptionDispatchInfo?> InvokeAsync(IRunner runner, CancellationToken cancellationToken)
{
ExceptionDispatchInfo?info = null;
await runner.RunAsync(() =>
{
try
{
return(this._stackFactory());
}
// because we are newing a generic, reflection comes in to
// construct the instance. And if there is an exception in
// the constructor of the user-provided TStack, it will be wrapped
// in TargetInvocationException - which is not the exception
// we want to throw to the consumer.
catch (TargetInvocationException ex)
{
info = ex.InnerException != null
? ExceptionDispatchInfo.Capture(ex.InnerException)
: ExceptionDispatchInfo.Capture(ex);
throw;
}
catch (Exception ex)
{
info = ExceptionDispatchInfo.Capture(ex);
throw;
}
}).ConfigureAwait(false);
return(info);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
notifier.Notify("Debug: Start program from ConsoleRunner.");
await runner.RunAsync(stoppingToken);
notifier.Notify("Program End.");
}
public async Task <IExecutionResult> ExecuteAsync()
{
var tasks = _runner.RunAsync(_script).ToList();
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
return(new AggregateResult(results));
}
private async Task RunSingleTask(ITaskDefinition <TIdentifier> singleTaskDefinition, PreconditionEvaluator <TIdentifier> preconditionEvaluator, ImmutableList <ISchedule <TIdentifier> > schedules, ImmutableList <TaskPrecondition <TIdentifier> > preconditions, SessionRunResult <TIdentifier> sessionRunResult, DateTime startTime, Guid runId)
{
var taskSchedule = schedules.Single(candidateSchedule => EqualityComparer <TIdentifier> .Default.Equals(candidateSchedule.TaskDefinitionId, singleTaskDefinition.Id));
var history = historyReader.GetNew();
history.StartTime = startTime;
history.TaskDefinitionId = singleTaskDefinition.Id;
history.RunId = runId;
var runResult = default(SingleTaskRunResult);
var failingPrecondition = await preconditionEvaluator.GetFailingPrecondition(singleTaskDefinition, preconditions);
var allPreconditionsPassed = string.IsNullOrEmpty(failingPrecondition);
if (allPreconditionsPassed)
{
try
{
runResult = await runner.RunAsync(singleTaskDefinition);
}
catch (Exception e)
{
await faultHandler.HandleAsync(singleTaskDefinition, e);
runResult = new SingleTaskRunResult
{
Succeeded = false,
Remarks = e.Message,
};
}
finally
{
if (taskSchedule.IsOnDemand)
{
onDemandQueueManager.DeQueue(taskSchedule.TaskDefinitionId);
}
}
history.Remarks = runResult.Remarks;
history.Status = runResult.Succeeded ? RunHistoryStatuses.CompletedSuccessfully : RunHistoryStatuses.Failed;
}
else
{
history.Remarks = $"Precondition '{failingPrecondition}' failed";
history.Status = RunHistoryStatuses.PreconditionPreventedRun;
}
history.EndTime = taskSchedule.LastRun = DateTime.Now;
sessionRunResult.Histories = sessionRunResult.Histories.Add(history);
sessionRunResult.Schedules = sessionRunResult.Schedules.Add(taskSchedule);
}
internal override async Task <ExceptionDispatchInfo?> InvokeAsync(IRunner runner, CancellationToken cancellationToken)
{
ExceptionDispatchInfo?info = null;
await runner.RunAsync(async() =>
{
try
{
return(await this._program(cancellationToken).ConfigureAwait(false));
}
catch (Exception ex)
{
info = ExceptionDispatchInfo.Capture(ex);
throw;
}
}, null).ConfigureAwait(false);
return(info);
}
/// <inheritdoc/> internal override Task <int> InvokeAsync(IRunner runner, CancellationToken cancellationToken) => runner.RunAsync(this._stackFactory);
/// <inheritdoc/> internal override Task <int> InvokeAsync(IRunner runner, CancellationToken cancellationToken) => runner.RunAsync(() => this._program(cancellationToken), null);
