/// <summary> /// Retry a task composition using the specified retry policy /// </summary> /// <param name="composer">The task composer</param> /// <param name="interval">The interval between each repetition</param> /// <param name="callback">The task composition callback</param> /// <param name="repeatCancellationToken">A cancellation token for the repeat-portion of the task composer</param> /// <returns>The original task composer</returns> public static Composer Repeat(this Composer composer, TimeSpan interval, Action <Composer> callback, CancellationToken repeatCancellationToken = default(CancellationToken)) { if (interval < TimeSpan.Zero) { throw new ArgumentOutOfRangeException("interval", "The interval must be non-negative, and it must be less than or equal to Int32.MaxValue."); } composer.ComposeTask(taskComposer => Attempt(taskComposer, interval, callback, repeatCancellationToken)); return(composer); }
/// <summary> /// Retry a task composition using the specified retry policy /// </summary> /// <param name="composer">The task composer</param> /// <param name="millisecondsInterval"></param> /// <param name="callback">The task composition callback</param> /// <param name="repeatCancellationToken"></param> /// <returns>The original task composer</returns> public static Composer Repeat(this Composer composer, int millisecondsInterval, Action <Composer> callback, CancellationToken repeatCancellationToken) { if (millisecondsInterval < 0) { throw new ArgumentOutOfRangeException("millisecondsInterval", "The interval must be non-negative, and it must be less than or equal to Int32.MaxValue."); } composer.ComposeTask( taskComposer => Attempt(taskComposer, TimeSpan.FromMilliseconds(millisecondsInterval), callback, repeatCancellationToken)); return(composer); }
static void Attempt(Composer composer, TimeSpan interval, Action <Composer> callback, CancellationToken repeatCancellationToken) { composer.ComposeTask(callback); composer.ExecuteAsync(token => { if (repeatCancellationToken.IsCancellationRequested) { return(TaskUtil.Completed()); } return(ComposerFactory.Compose(x => { x.Delay(interval); Attempt(x, interval, callback, repeatCancellationToken); }, token)); }, ExecuteOptions.RunSynchronously); }
static void Attempt <T>(Composer <T> composer, IRetryContext retryContext, Action <Composer <T> > callback) { composer.ComposeTask(callback); composer.Compensate(compensation => { TimeSpan delay; if (!retryContext.CanRetry(compensation.Exception, out delay)) { return(compensation.Throw()); } return(compensation.ComposeTask(x => { x.Delay(delay); Attempt(x, retryContext, callback); })); }); }
/// <summary> /// Retry a task composition using the specified retry policy /// </summary> /// <typeparam name="T">The composer payload type</typeparam> /// <param name="composer">The task composer</param> /// <param name="retryPolicy">The retry policy</param> /// <param name="callback">The task composition callback</param> /// <returns>The original task composer</returns> public static Composer <T> Retry <T>(this Composer <T> composer, IRetryPolicy retryPolicy, Action <Composer <T> > callback) { IRetryContext retryContext = null; composer.ComposeTask(taskComposer => { retryContext = retryPolicy.GetRetryContext(); Attempt(taskComposer, retryContext, callback); }); composer.Finally((_, status) => { if (retryContext != null) { retryContext.Complete(status); } }); return(composer); }
public void Compose <TPayload>(Composer <Payload <TPayload> > composer, Carrier <Tuple <TPayload, T> > next) { composer.ComposeTask(p => composer.Payload.MergeRight(new T()), next.Compose); }
public static Composer <Payload <T> > ComposeCarrier <T, TPayload>(this Composer <Payload <T> > composer, Carrier <Tuple <T, TPayload> > next, Func <Payload <T>, Payload <Tuple <T, TPayload> > > payload) { return(composer.ComposeTask(payload, next.Compose)); }
static void Attempt(Composer composer, TimeSpan interval, Action<Composer> callback, CancellationToken repeatCancellationToken) { composer.ComposeTask(callback); composer.ExecuteAsync(token => { if (repeatCancellationToken.IsCancellationRequested) return TaskUtil.Completed(); return ComposerFactory.Compose(x => { x.Delay(interval); Attempt(x, interval, callback, repeatCancellationToken); }, token); }, ExecuteOptions.RunSynchronously); }