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);
}
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 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));
}
public ImmediateRetryPolicy(IPolicyExceptionFilter filter, int retryLimit)
{
_filter = filter;
_retryLimit = retryLimit;
}
/// <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));
}
