/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the raised exception and the current sleep duration. /// On each retry, the duration to wait is calculated by calling <paramref name="sleepDurationProvider"/> with /// the current retry attempt allowing an exponentially increasing wait time (exponential backoff). /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="sleepDurationProvider">The function that provides the duration to wait for for a particular retry attempt.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than zero.</exception> /// <exception cref="System.ArgumentNullException"> /// timeSpanProvider /// or /// onRetry /// </exception> public static Policy WaitAndRetry(this PolicyBuilder policyBuilder, int retryCount, Func <int, TimeSpan> sleepDurationProvider, Action <Exception, TimeSpan> onRetry) { if (retryCount <= 0) { throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than zero."); } if (sleepDurationProvider == null) { throw new ArgumentNullException("sleepDurationProvider"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } var sleepDurations = Enumerable.Range(1, retryCount) .Select(sleepDurationProvider); return(new Policy( action => RetryPolicy.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyStateWithSleep(sleepDurations, onRetry) ), policyBuilder.ExceptionPredicates )); }
/// <summary> Builds <see cref="ActionPolicy"/> that will keep retrying forever </summary> /// <param name="syntax">The syntax to extend.</param> /// <param name="onRetry">The action to perform when the exception could be retried.</param> /// <returns> reusable instance of policy</returns> public static ActionPolicy RetryForever(this Syntax <ExceptionHandler> syntax, Action <Exception> onRetry) { Enforce.Arguments(() => syntax, () => onRetry); var state = new RetryState(onRetry); return(new ActionPolicy(action => RetryPolicy.Implementation(action, syntax.Target, () => state))); }
/// <summary> /// Builds <see cref="ActionPolicy"/> that will retry exception handling /// for a couple of times before giving up. /// </summary> /// <param name="syntax">The syntax.</param> /// <param name="retryCount">The retry count.</param> /// <returns>reusable instance of policy</returns> public static ActionPolicy Retry(this Syntax <ExceptionHandler> syntax, int retryCount) { Enforce.Argument(() => syntax); Func <IRetryState> state = () => new RetryStateWithCount(retryCount, DoNothing2); return(new ActionPolicy(action => RetryPolicy.Implementation(action, syntax.Target, state))); }
/// <summary> <para>Builds the policy that will keep retrying as long as /// the exception could be handled by the <paramref name="syntax"/> being /// built and <paramref name="sleepDurations"/> is providing the sleep intervals. /// </para> /// <para>See <see cref="Range"/> for methods to create long intervals on-the-fly</para> /// </summary> /// <param name="syntax">The syntax.</param> /// <param name="sleepDurations">The sleep durations.</param> /// <returns>new policy instance</returns> public static ActionPolicy WaitAndRetry(this Syntax <ExceptionHandler> syntax, IEnumerable <TimeSpan> sleepDurations) { Enforce.Arguments(() => syntax, () => sleepDurations); Func <IRetryState> state = () => new RetryStateWithSleep(sleepDurations, DoNothing2); return(new ActionPolicy(action => RetryPolicy.Implementation(action, syntax.Target, state))); }
/// <summary> /// Builds <see cref="ActionPolicy"/> that will retry exception handling /// for a couple of times before giving up. /// </summary> /// <param name="syntax">The syntax.</param> /// <param name="retryCount">The retry count.</param> /// <param name="onRetry">The action to perform on retry (i.e.: write to log). /// First parameter is the exception and second one is its number in sequence. </param> /// <returns>reusable policy instance </returns> public static ActionPolicy Retry(this Syntax <ExceptionHandler> syntax, int retryCount, Action <Exception, int> onRetry) { Enforce.Arguments(() => syntax, () => onRetry); Enforce.Argument(() => retryCount, Is.GreaterThan(0)); Func <IRetryState> state = () => new RetryStateWithCount(retryCount, onRetry); return(new ActionPolicy(action => RetryPolicy.Implementation(action, syntax.Target, state))); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the raised exception and /// execution context. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static ContextualPolicy RetryForever(this PolicyBuilder policyBuilder, Action <Exception, Context> onRetry) { if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new ContextualPolicy((action, context) => RetryPolicy.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyState(onRetry, context) ))); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry indefinitely /// calling <paramref name="onRetry"/> on each retry with the raised exception. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static Policy RetryForever(this PolicyBuilder policyBuilder, Action <Exception> onRetry) { if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new Policy( action => RetryPolicy.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyState(onRetry) ), policyBuilder.ExceptionPredicates )); }
/// <summary> /// Builds a <see cref="Policy"/> that will retry <paramref name="retryCount"/> times /// calling <paramref name="onRetry"/> on each retry with the raised exception and retry count. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="retryCount">The retry count.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentOutOfRangeException">retryCount;Value must be greater than zero.</exception> /// <exception cref="System.ArgumentNullException">onRetry</exception> public static Policy Retry(this PolicyBuilder policyBuilder, int retryCount, Action <Exception, int> onRetry) { if (retryCount <= 0) { throw new ArgumentOutOfRangeException("retryCount", "Value must be greater than zero."); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new Policy( action => RetryPolicy.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyStateWithCount(retryCount, onRetry)))); }
/// <summary> /// Builds a <see cref="Policy"/> that will wait and retry as many times as there are provided <paramref name="sleepDurations"/> /// calling <paramref name="onRetry"/> on each retry with the raised exception, current sleep duration and /// execution context. /// On each retry, the duration to wait is the current <paramref name="sleepDurations"/> item. /// </summary> /// <param name="policyBuilder">The policy builder.</param> /// <param name="sleepDurations">The sleep durations to wait for on each retry.</param> /// <param name="onRetry">The action to call on each retry.</param> /// <returns>The policy instance.</returns> /// <exception cref="System.ArgumentNullException"> /// sleepDurations /// or /// onRetry /// </exception> public static ContextualPolicy WaitAndRetry(this PolicyBuilder policyBuilder, IEnumerable <TimeSpan> sleepDurations, Action <Exception, TimeSpan, Context> onRetry) { if (sleepDurations == null) { throw new ArgumentNullException("sleepDurations"); } if (onRetry == null) { throw new ArgumentNullException("onRetry"); } return(new ContextualPolicy((action, context) => RetryPolicy.Implementation( action, policyBuilder.ExceptionPredicates, () => new RetryPolicyStateWithSleep(sleepDurations, onRetry, context) ))); }