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