/// <inheritdoc />
public TResult Execute(IBotOperation <TResult> operation, object correlationId, CancellationToken token)
{
Shield.EnsureNotNull(operation, nameof(operation));
Shield.EnsureNotNull(correlationId, nameof(correlationId));
return(this.Bot.Execute(operation, ExecutionContext.New(base.Configuration, correlationId), token));
}
public override void Execute(IBotOperation operation, ExecutionContext context, CancellationToken token)
{
var shouldLimitExecution = this.strategy.PreCheckCircuitState();
if (shouldLimitExecution && !this.executionBarrier.CompareExchange(false, true))
{
throw new HalfOpenExecutionLimitExceededException(Constants.HalfOpenExecutionLimitExceededExceptionMessage);
}
try
{
base.InnerBot.Execute(operation, context, token);
this.strategy.OperationSucceeded();
}
catch (Exception exception)
{
if (base.Configuration.HandlesException(exception))
{
this.strategy.OperationFailed();
}
throw;
}
finally
{
this.executionBarrier.SetValue(false);
}
}
public override void Execute(IBotOperation operation, ExecutionContext context, CancellationToken token)
{
if (this.strategy.ShouldLimit(out var retryAfter))
{
throw new RateLimitExceededException(Constants.RateLimitExceededExceptionMessage, retryAfter);
}
base.InnerBot.Execute(operation, context, token);
}
public override TResult Execute(IBotOperation <TResult> operation,
ExecutionContext context, CancellationToken token)
{
try
{
var result = base.InnerBot.Execute(operation, context, token);
return(base.Configuration.AcceptsResult(result) ? result : base.Configuration.RaiseFallbackEvent(result, null, context));
}
catch (Exception exception)
{
if (base.Configuration.HandlesException(exception))
{
return(base.Configuration.RaiseFallbackEvent(default, exception, context));
public override void Execute(IBotOperation operation,
ExecutionContext context, CancellationToken token)
{
try
{
base.InnerBot.Execute(operation, context, token);
}
catch (Exception exception)
{
if (!base.Configuration.HandlesException(exception))
{
throw;
}
base.Configuration.RaiseFallbackEvent(exception, context);
}
}
private TryResult Try(
IBotOperation operation,
ExecutionContext context,
CancellationToken token)
{
try
{
base.InnerBot.Execute(operation, context, token);
return(TryResult.Succeeded());
}
catch (Exception exception)
{
if (base.Configuration.HandlesException(exception))
{
return(TryResult.Failed(exception));
}
throw;
}
}
private TryResult <TResult> Try(
IBotOperation <TResult> operation,
ExecutionContext context,
CancellationToken token)
{
try
{
var result = base.InnerBot.Execute(operation, context, token);
return(this.HandleResult(result));
}
catch (Exception exception)
{
if (base.Configuration.HandlesException(exception))
{
return(TryResult <TResult> .Failed(exception));
}
throw;
}
}
public override void Execute(IBotOperation operation,
ExecutionContext context, CancellationToken token)
{
using (var timeoutTokenSource = new CancellationTokenSource())
using (var combinedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, timeoutTokenSource.Token))
{
try
{
timeoutTokenSource.CancelAfter(base.Configuration.Timeout);
base.InnerBot.Execute(operation, context, combinedTokenSource.Token);
}
catch (Exception ex)
{
if (!timeoutTokenSource.IsCancellationRequested)
{
throw;
}
base.Configuration.RaiseTimeoutEvent(context);
throw new OperationTimeoutException(Constants.TimeoutExceptionMessage, ex);
}
}
}
public override void Execute(IBotOperation operation,
ExecutionContext context, CancellationToken token)
{
var currentAttempt = 1;
var tryResult = TryResult.Default;
while (RetryBotUtils.ShouldExecute(tryResult, base.Configuration, currentAttempt, token))
{
tryResult = this.Try(operation, context, token);
if (tryResult.IsSucceeded)
{
if (currentAttempt > 1)
{
base.Configuration.RaiseRetrySucceededEvent(AttemptContext.New(currentAttempt, TimeSpan.Zero, context));
}
return;
}
if (RetryBotUtils.HasMaxAttemptsReached(base.Configuration, currentAttempt))
{
break;
}
var nextDelay = base.Configuration.CalculateNextDelay(currentAttempt, tryResult.Exception);
base.Configuration.RaiseRetryEvent(tryResult.Exception, AttemptContext.New(currentAttempt, nextDelay, context));
RetryBotUtils.Wait(nextDelay, token);
currentAttempt++;
}
token.ThrowIfCancellationRequested();
base.Configuration.RaiseRetryLimitReachedEvent(tryResult.Exception, context);
throw new MaxRetryAttemptsReachedException(Constants.MaxRetryExceptionMessage, tryResult.Exception, null);
}
public override void Execute(IBotOperation operation, ExecutionContext context, CancellationToken token) => this.InnerBot.Execute(operation, context, token);
/// <summary> /// Executes a given operation synchronously. /// </summary> /// <param name="operation">The operation.</param> /// <param name="context">The execution context which holds additional information about the current execution.</param> /// <param name="token">The cancellation token, used to cancel the execution of the given operation.</param> public abstract void Execute(IBotOperation operation, ExecutionContext context, CancellationToken token);
public override void Execute(IBotOperation operation, ExecutionContext context, CancellationToken token) => operation.Execute(context, token);
