internal static async Task <TReturn> ExecAsync <TReturn>(
Func <Task <TReturn> > operation,
IJobExceptionState jobExceptionState,
ICancellationSource cancellationSource,
ILogger logger)
{
try
{
logger.Verbose("Before try operation");
var result = await operation().ConfigureAwait(false);
logger.Verbose("After try operation");
return(result);
}
catch (OperationCanceledException operationCanceledException)
{
logger.Verbose("Caught OperationCanceledException");
if (!cancellationSource.IsCancellationRequested)
{
logger.Verbose("Before log OperationCanceledException");
HandleException(jobExceptionState, operationCanceledException, logger.Warning);
logger.Verbose("After log OperationCanceledException");
}
}
catch (AggregateException aggregateException)
{
logger.Verbose("Caught AggregateException");
aggregateException.Handle((e) =>
{
if (e is OperationCanceledException)
{
if (!cancellationSource.IsCancellationRequested)
{
logger.Verbose("Before log aggregate's OperationCanceledException");
HandleException(jobExceptionState, e, logger.Warning);
logger.Verbose("After log aggregate's OperationCanceledException");
}
return(true);
}
logger.Verbose("Before log aggregate's other inner exception");
HandleException(jobExceptionState, e, logger.Error);
logger.Verbose("After log aggregate's other inner exception");
return(false);
});
}
catch (Exception exception)
{
logger.Verbose("Before log Exception");
HandleException(jobExceptionState, exception, logger.Error);
logger.Verbose("After log Exception");
}
return(default(TReturn));
}
public bool HandleException(IJobExceptionState jobExceptionState, ILogger logger)
{
if (jobExceptionState.LastExceptionCount == 3)
{
logger.Warning("Handling exception that has occurred too many times");
return(false);
}
m_sleepInterval = m_sleepInterval.Subtract(TimeSpan.FromMilliseconds(2000));
return(true);
}
internal static async Task ExecAsync(
Func <Task> operation,
IJobExceptionState jobExceptionState,
ICancellationSource cancellationSource,
ILogger logger)
{
await ExecAsync(async() =>
{
await operation().ConfigureAwait(false);
return(0);
},
jobExceptionState,
cancellationSource,
logger);
}
public async Task <JobResult> Run(IJobExceptionState jobExceptionState, ILogger logger, CancellationToken cancellationToken)
{
logger.Verbose($"jobExceptionState.LastExceptionCount: {jobExceptionState.LastExceptionCount}");
//if (taskContext.LastExceptionCount > 3) return false;
logger.Information("Attempting HTTP GET that will timeout");
var httpClient = new HttpClient();
// Use this to create aggregate exception with TaskCancelled inner
//httpClient.Timeout = TimeSpan.FromMilliseconds(10);
//var task = httpClient.GetAsync("http://www.google.com", cancellationToken);
//await Task.WhenAny(task, Task.CompletedTask);
//var response = task.Result;
//httpClient.Timeout = TimeSpan.FromMilliseconds(10);
var response = await httpClient.GetAsync("http://www.google.com", cancellationToken);
HttpGetCompleted?.Invoke(this, new HttpGetCompletedEventArgs(response, cancellationToken));
return(JobResult.TrueResult);
}
private static void HandleException(IJobExceptionState jobExceptionState, Exception exception, Action <string> logAction)
{
// If no jobExceptionState, ignore this operation's exception
if (jobExceptionState == JobExceptionState.None)
{
return;
}
jobExceptionState.LastException = exception;
jobExceptionState.ExceptionCount++;
string message = exception.ExpandMessage();
if (message != jobExceptionState.LastExceptionMessage)
{
jobExceptionState.LastExceptionCount = 1;
jobExceptionState.LastExceptionMessage = message;
logAction(message);
}
else
{
jobExceptionState.LastExceptionCount++;
}
}
public bool HandleException(IJobExceptionState jobExceptionState, ILogger logger)
{
m_mre.Reset();
return(true);
}
