public IntervalRetryPolicy(IPolicyExceptionFilter filter, params TimeSpan[] intervals) { if (intervals == null) throw new ArgumentNullException(nameof(intervals)); if (intervals.Length == 0) throw new ArgumentOutOfRangeException(nameof(intervals), "At least one interval must be specified"); _filter = filter; _intervals = intervals; }
/// <summary> /// Rescue exceptions via the alternate pipe /// </summary> /// <typeparam name="T"></typeparam> /// <param name="configurator"></param> /// <param name="rescuePipe"></param> /// <param name="exceptionFilter"></param> public static void UseRescue(this IPipeConfigurator<ReceiveContext> configurator, IPipe<ExceptionReceiveContext> rescuePipe, IPolicyExceptionFilter exceptionFilter = null) { if (configurator == null) throw new ArgumentNullException(nameof(configurator)); var rescueConfigurator = new ReceiveContextRescuePipeSpecification(rescuePipe, exceptionFilter); configurator.AddPipeSpecification(rescueConfigurator); }
public IntervalRetryPolicy(IPolicyExceptionFilter filter, params int[] intervals) { if (intervals == null) throw new ArgumentNullException(nameof(intervals)); if (intervals.Length == 0) throw new ArgumentOutOfRangeException(nameof(intervals), "At least one interval must be specified"); _filter = filter; _intervals = intervals.Select(x => TimeSpan.FromMilliseconds(x)).ToArray(); }
public ExponentialRetryPolicy(IPolicyExceptionFilter filter, int retryLimit, TimeSpan minInterval, TimeSpan maxInterval, TimeSpan intervalDelta) { _filter = filter; _retryLimit = retryLimit; _minInterval = (int)minInterval.TotalMilliseconds; _maxInterval = (int)maxInterval.TotalMilliseconds; _lowInterval = (int)(intervalDelta.TotalMilliseconds * 0.8); _highInterval = (int)(intervalDelta.TotalMilliseconds * 1.2); }
/// <summary> /// Rescue exceptions via the alternate pipe /// </summary> /// <typeparam name="T"></typeparam> /// <param name="configurator"></param> /// <param name="rescuePipe"></param> /// <param name="exceptionFilter"></param> public static void UseRescue(this IPipeConfigurator <ReceiveContext> configurator, IPipe <ExceptionReceiveContext> rescuePipe, IPolicyExceptionFilter exceptionFilter = null) { if (configurator == null) { throw new ArgumentNullException(nameof(configurator)); } var rescueConfigurator = new ReceiveContextRescuePipeSpecification(rescuePipe, exceptionFilter); configurator.AddPipeSpecification(rescueConfigurator); }
public IntervalRetryPolicy(IPolicyExceptionFilter filter, params TimeSpan[] intervals) { if (intervals == null) { throw new ArgumentNullException(nameof(intervals)); } if (intervals.Length == 0) { throw new ArgumentOutOfRangeException(nameof(intervals), "At least one interval must be specified"); } _filter = filter; _intervals = intervals; }
public IntervalRetryPolicy(IPolicyExceptionFilter filter, params int[] intervals) { if (intervals == null) { throw new ArgumentNullException(nameof(intervals)); } if (intervals.Length == 0) { throw new ArgumentOutOfRangeException(nameof(intervals), "At least one interval must be specified"); } _filter = filter; _intervals = intervals.Select(x => TimeSpan.FromMilliseconds(x)).ToArray(); }
public IncrementalRetryPolicy(IPolicyExceptionFilter filter, int retryLimit, TimeSpan initialInterval, TimeSpan intervalIncrement) { if (initialInterval < TimeSpan.Zero) { throw new ArgumentOutOfRangeException(nameof(initialInterval), "The initialInterval must be non-negative or -1, and it must be less than or equal to TimeSpan.MaxValue."); } if (intervalIncrement < TimeSpan.Zero) { throw new ArgumentOutOfRangeException(nameof(intervalIncrement), "The intervalIncrement must be non-negative or -1, and it must be less than or equal to TimeSpan.MaxValue."); } _filter = filter; _retryLimit = retryLimit; _initialInterval = initialInterval; _intervalIncrement = intervalIncrement; }
public ReceiveContextRescuePipeSpecification(IPipe <ExceptionReceiveContext> rescuePipe, IPolicyExceptionFilter exceptionFilter) { _rescuePipe = rescuePipe; _exceptionFilter = exceptionFilter; }
public RescueConsumeFilter(IPipe <ConsumeContext <T> > rescuePipe, IPolicyExceptionFilter exceptionFilter) { _rescuePipe = rescuePipe; _exceptionFilter = exceptionFilter; }
public ImmediateRetryPolicy(IPolicyExceptionFilter filter, int retryLimit) { _filter = filter; _retryLimit = retryLimit; }
public RescueReceiveContextFilter(IPipe <ExceptionReceiveContext> rescuePipe, IPolicyExceptionFilter exceptionFilter) { _rescuePipe = rescuePipe; _exceptionFilter = exceptionFilter; }
/// <summary> /// Create an interval retry policy with the specified number of retries at a fixed interval /// </summary> /// <param name="filter"></param> /// <param name="retryCount">The number of retry attempts</param> /// <param name="interval">The interval between each retry attempt</param> /// <returns></returns> public static IRetryPolicy Interval(this IPolicyExceptionFilter filter, int retryCount, TimeSpan interval) { return(new IntervalRetryPolicy(filter, Enumerable.Repeat(interval, retryCount).ToArray())); }
/// <summary> /// Create an exponential retry policy with the specified number of retries at exponential /// intervals /// </summary> /// <param name="filter"></param> /// <param name="retryLimit"></param> /// <param name="minInterval"></param> /// <param name="maxInterval"></param> /// <param name="intervalDelta"></param> /// <returns></returns> public static IRetryPolicy Exponential(this IPolicyExceptionFilter filter, int retryLimit, TimeSpan minInterval, TimeSpan maxInterval, TimeSpan intervalDelta) { return(new ExponentialRetryPolicy(filter, retryLimit, minInterval, maxInterval, intervalDelta)); }
/// <summary> /// Create an incremental retry policy with the specified number of retry attempts with an incrementing /// interval between retries /// </summary> /// <param name="filter"></param> /// <param name="retryLimit">The number of retry attempts</param> /// <param name="initialInterval">The initial retry interval</param> /// <param name="intervalIncrement">The interval to add to the retry interval with each subsequent retry</param> /// <returns></returns> public static IRetryPolicy Incremental(this IPolicyExceptionFilter filter, int retryLimit, TimeSpan initialInterval, TimeSpan intervalIncrement) { return(new IncrementalRetryPolicy(filter, retryLimit, initialInterval, intervalIncrement)); }
/// <summary> /// Create an immediate retry policy with the specified number of retries, with no /// delay between attempts. /// </summary> /// <param name="filter"></param> /// <param name="retryLimit">The number of retries to attempt</param> /// <returns></returns> public static IRetryPolicy Immediate(this IPolicyExceptionFilter filter, int retryLimit) { return(new ImmediateRetryPolicy(filter, retryLimit)); }
/// <summary> /// Create an interval retry policy with the specified intervals. The retry count equals /// the number of intervals provided /// </summary> /// <param name="filter"></param> /// <param name="intervals">The intervals before each subsequent retry attempt</param> /// <returns></returns> public static IRetryPolicy Intervals(this IPolicyExceptionFilter filter, params int[] intervals) { return(new IntervalRetryPolicy(filter, intervals)); }