예제 #1
0
        /// <summary>
        /// Create a new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class based on the specified retry strategy.
        /// </summary>
        /// <param name="retryStrategy">The retry strategy.</param>
        /// <param name="retryingHandler">The callback function that will be invoked whenever a retry condition is encountered.</param>
        /// <returns>A new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class.</returns>
        public static RetryPolicy HandleWith(this RetryStrategy retryStrategy, EventHandler <RetryingEventArgs> retryingHandler)
        {
            Guard.ArgumentNotNull(retryStrategy, nameof(retryStrategy));
            Guard.ArgumentNotNull(retryingHandler, nameof(retryingHandler));

            return(CreateRetryPolicy(retryStrategy).HandleWith(retryingHandler));
        }
 public UpdateSessionManagerRetryDecorator(IUpdateSessionManager updateSessionManager,
     RetryStrategy retryStrategy,
     ITransientErrorDetectionStrategy errorDetectionStrategy)
 {
     _updateSessionManager = updateSessionManager;
     _retryPolicy = new RetryPolicy(errorDetectionStrategy, retryStrategy);
 }
 /// <summary>
 /// Create a new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class with the specified retry strategy.
 /// </summary>
 /// <param name="retryStrategy">The retry strategy.</param>
 /// <param name="isTransient">The predicate function to detect whether the specified exception is transient.</param>
 /// <typeparam name="TException">The type of the transient exception.</typeparam>
 /// <returns>A new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class.</returns>
 public static RetryPolicy Catch <TException>(
     this RetryStrategy retryStrategy,
     Func <TException, bool>?isTransient = null) where TException : Exception =>
 CreateRetryPolicy(
     Argument.NotNull(retryStrategy, nameof(retryStrategy)),
     isTransient is null
             ? exception => exception is TException
     : exception => exception is TException specifiedException && isTransient(specifiedException));
        /// <summary>
        /// Repetitively executes the specified action while it satisfies the specified retry strategy.
        /// </summary>
        /// <param name="action">A delegate that represents the executable action that doesn't return any results.</param>
        /// <param name="retryStrategy">The retry strategy.</param>
        /// <param name="isTransient">The predicate function to detect whether the specified exception is transient.</param>
        /// <param name="retryingHandler">The callback function that will be invoked whenever a retry condition is encountered.</param>
        /// <exception cref="ArgumentNullException">action</exception>
        public static void Execute(
            Action action,
            RetryStrategy retryStrategy        = null,
            Func <Exception, bool> isTransient = null,
            EventHandler <RetryingEventArgs> retryingHandler = null)
        {
            Guard.ArgumentNotNull(action, nameof(action));

            CreateRetryPolicy(retryStrategy, isTransient, retryingHandler).ExecuteAction(action);
        }
        /// <summary>
        /// Repeatedly executes the specified asynchronous function while it satisfies the current retry policy.
        /// </summary>
        /// <param name="func">A asynchronous function that returns a started task (also known as "hot" task).</param>
        /// <param name="retryStrategy">The retry strategy.</param>
        /// <param name="isTransient">The predicate function to detect whether the specified exception is transient.</param>
        /// <param name="retryingHandler">The callback function that will be invoked whenever a retry condition is encountered.</param>
        /// <returns>Returns a task that will run to completion if the original task completes successfully (either the first time or after retrying transient failures). If the task fails with a non-transient error or the retry limit is reached, the returned task will transition to a faulted state and the exception must be observed.</returns>
        /// <exception cref="ArgumentNullException">func</exception>
        public static Task ExecuteAsync(
            Func <Task> func,
            RetryStrategy retryStrategy        = null,
            Func <Exception, bool> isTransient = null,
            EventHandler <RetryingEventArgs> retryingHandler = null)
        {
            Guard.ArgumentNotNull(func, nameof(func));

            return(CreateRetryPolicy(retryStrategy, isTransient, retryingHandler).ExecuteAsync(func));
        }
예제 #6
0
 /// <summary>
 /// Initializes a new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class with the specified number of retry attempts and parameters defining the progressive delay between retries.
 /// </summary>
 /// <param name="errorDetectionStrategy">The <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.ITransientErrorDetectionStrategy" /> that is responsible for detecting transient conditions.</param>
 /// <param name="retryStrategy">The strategy to use for this retry policy.</param>
 public RetryPolicy(ITransientErrorDetectionStrategy errorDetectionStrategy, RetryStrategy retryStrategy)
 {
     Guard.ArgumentNotNull(errorDetectionStrategy, "errorDetectionStrategy");
     Guard.ArgumentNotNull(retryStrategy, "retryPolicy");
     this.ErrorDetectionStrategy = errorDetectionStrategy;
     if (errorDetectionStrategy == null)
     {
         throw new InvalidOperationException("The error detection strategy type must implement the ITransientErrorDetectionStrategy interface.");
     }
     this.RetryStrategy = retryStrategy;
 }
예제 #7
0
        /// <summary>
        /// Create a new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class with the specified retry strategy.
        /// </summary>
        /// <param name="retryStrategy">The retry strategy.</param>
        /// <param name="isTransient">The predicate function to detect whether the specified exception is transient.</param>
        /// <typeparam name="TException">The type of the transient exception.</typeparam>
        /// <returns>A new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class.</returns>
        public static RetryPolicy Catch <TException>(
            this RetryStrategy retryStrategy,
            Func <TException, bool> isTransient = null) where TException : Exception
        {
            Guard.ArgumentNotNull(retryStrategy, nameof(retryStrategy));

            return(CreateRetryPolicy(
                       retryStrategy,
                       isTransient == null
                    ? new Func <Exception, bool>(exception => exception is TException)
                    : exception => exception is TException specifiedException && isTransient(specifiedException)));
        }
예제 #8
0
        /// <summary>
        /// Create a new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class with the specified retry strategy.
        /// </summary>
        /// <param name="retryStrategy">The retry strategy.</param>
        /// <param name="isTransient">The predicate function to detect whether the specified exception is transient.</param>
        /// <param name="retryingHandler">The callback function that will be invoked whenever a retry condition is encountered.</param>
        /// <returns>A new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class with the specified number of retry attempts and parameters defining the progressive delay between retries.</returns>
        public static RetryPolicy CreateRetryPolicy(
            RetryStrategy retryStrategy        = null,
            Func <Exception, bool> isTransient = null,
            EventHandler <RetryingEventArgs> retryingHandler = null)
        {
            RetryPolicy retryPolicy = new RetryPolicy(
                new ExceptionDetection(isTransient), retryStrategy ?? RetryStrategy.NoRetry);

            if (retryingHandler != null)
            {
                retryPolicy.Retrying += retryingHandler;
            }

            return(retryPolicy);
        }
        protected override void Arrange()
        {
            this.defaultStrategy = new FixedInterval("default", 5, TimeSpan.FromMilliseconds(10));
            this.otherStrategy = new Incremental("other", 5, TimeSpan.FromMilliseconds(10), TimeSpan.FromMilliseconds(10));
            this.defaultSqlConnectionStrategy = new FixedInterval("defaultSqlConnection", 5, TimeSpan.FromMilliseconds(10));
            this.defaultSqlCommandStrategy = new FixedInterval("defaultSqlCommand", 5, TimeSpan.FromMilliseconds(10));
            this.defaultAzureServiceBusStrategy = new FixedInterval("defaultAzureServiceBusStrategy", 5, TimeSpan.FromMilliseconds(10));
            this.defaultAzureCachingStrategy = new FixedInterval("defaultAzureCachingStrategy", 5, TimeSpan.FromMilliseconds(10));
            this.defaultAzureStorageStrategy = new FixedInterval("defaultAzureStorageStrategy", 5, TimeSpan.FromMilliseconds(10));

            this.managerWithAllDefaults = new RetryManager(
                new[]
                {
                    this.defaultStrategy,
                    this.defaultSqlConnectionStrategy,
                    this.defaultSqlCommandStrategy,
                    this.otherStrategy,
                    this.defaultAzureServiceBusStrategy,
                    this.defaultAzureCachingStrategy, this.defaultAzureStorageStrategy
                },
                "default",
                new Dictionary<string, string> 
                { 
                    { "SQL", "defaultSqlCommand" },
                    { "SQLConnection", "defaultSqlConnection" },
                    { "ServiceBus", "defaultAzureServiceBusStrategy" },
                    { "Caching", "defaultAzureCachingStrategy" },
                    { "WindowsAzure.Storage", "defaultAzureStorageStrategy" },
                });

            this.managerWithOnlyDefault = new RetryManager(
              new[]
                {
                    this.defaultStrategy,
                    this.defaultSqlConnectionStrategy,
                    this.defaultSqlCommandStrategy,
                    this.otherStrategy,
                    this.defaultAzureServiceBusStrategy,
                    this.defaultAzureCachingStrategy, this.defaultAzureStorageStrategy
                },
              "default");
        }
예제 #10
0
        protected SubscriptionReceiver(ServiceBusSettings settings, string topic, string subscription, bool processInParallel, ISubscriptionReceiverInstrumentation instrumentation, int maxNumberRetry, RetryStrategy backgroundRetryStrategy)
        {
            this.settings = settings;
            this.topic = topic;
            this.subscription = subscription;
            this.processInParallel = processInParallel;
            this.instrumentation = instrumentation;

            var messagingFactory = MessagingFactory.CreateFromConnectionString(this.settings.ConnectionString);
            this.client = messagingFactory.CreateSubscriptionClient(topic, subscription);
            if (this.processInParallel)
            {
                this.client.PrefetchCount = 500;
            }
            else
            {
                this.client.PrefetchCount = 100;
            }

            this.dynamicThrottling =
                new DynamicThrottling(
                    maxDegreeOfParallelism: 10000,
                    minDegreeOfParallelism: 50,
                    penaltyAmount: 3,
                    workFailedPenaltyAmount: 5,
                    workCompletedParallelismGain: 1,
                    intervalForRestoringDegreeOfParallelism: 8000);

            this.retryStrategy = backgroundRetryStrategy;
            this.maxNumberRetry = maxNumberRetry;

            this.receiveRetryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(backgroundRetryStrategy);
            this.receiveRetryPolicy.Retrying += (s, e) =>
            {
                this.dynamicThrottling.Penalize();
                Trace.TraceWarning(
                    "An error occurred in attempt number {1} to receive a message from subscription {2}: {0}",
                    e.LastException.Message,
                    e.CurrentRetryCount,
                    this.subscription);
            };
        }
예제 #11
0
        /// <summary>
        /// Initializes a new instance of the <see cref="TopicSender"/> class, 
        /// automatically creating the given topic if it does not exist.
        /// </summary>
        protected TopicSender(ServiceBusSettings settings, string topic, int maxNumberRetry, RetryStrategy retryStrategy)
        {
            this.settings = settings;
            this.topic = topic;

            this.retryStrategy = retryStrategy;
            this.maxNumberRetry = maxNumberRetry;

            this.messagingFactory = MessagingFactory.CreateFromConnectionString(settings.ConnectionString);
            this.topicClient = messagingFactory.CreateTopicClient(this.topic);

            this.retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(this.retryStrategy);
            this.retryPolicy.Retrying += (s, e) =>
            {
                var handler = this.Retrying;
                if (handler != null)
                {
                    handler(this, EventArgs.Empty);
                }

                Trace.TraceWarning("An error occurred in attempt number {1} to send a message: {0}", e.LastException.Message, e.CurrentRetryCount);
            };
        }
        /// <summary>
        /// Wraps a Transient Fault Handling Application Block retry strategy into a Microsoft.WindowsAzure.StorageClient.RetryPolicy.
        /// </summary>
        /// <param name="retryStrategy">The Transient Fault Handling Application Block retry strategy to wrap.</param>
        /// <returns>Returns a wrapped Transient Fault Handling Application Block retry strategy into a Microsoft.WindowsAzure.StorageClient.RetryPolicy.</returns>
        public static Microsoft.WindowsAzure.StorageClient.RetryPolicy AsAzureStorageClientRetryPolicy(this RetryStrategy retryStrategy)
        {
            if (retryStrategy == null)
            {
                throw new ArgumentNullException("retryStrategy");
            }

            return(() => new ShouldRetryWrapper(retryStrategy.GetShouldRetry()).ShouldRetry);
        }
 protected override void Act()
 {
     this.retryStrategy = new FixedInterval(5);
     this.shouldRetry = this.retryStrategy.GetShouldRetry();
 }
 protected override void Act()
 {
     this.retryStrategy = new FixedInterval("name", 5, TimeSpan.FromSeconds(5));
     this.shouldRetry = this.retryStrategy.GetShouldRetry();
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy`1" /> class with the specified number of retry attempts and parameters defining the progressive delay between retries.
 /// </summary>
 /// <param name="retryStrategy">The strategy to use for this retry policy.</param>
 public RetryPolicy(RetryStrategy retryStrategy) :
     base(default(T) is null ? Activator.CreateInstance <T>() : default !, retryStrategy)
 {
 }
예제 #16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="T:GlebTeterin.ReliableSql.ReliableSqlConnection"/> class with a connection string and a <see cref="P:GlebTeterin.ReliableSql.AzureSqlStrategy"/>.
 /// </summary>
 public ReliableSqlConnection(string connectionString, ITransientErrorDetectionStrategy errorDetectionStrategy, RetryStrategy retryStrategy)
     : this(connectionString, new SmartRetryPolicy(errorDetectionStrategy, retryStrategy))
 {
 }
 protected override void Act()
 {
     this.retryStrategy = new Incremental();
     this.shouldRetry = this.retryStrategy.GetShouldRetry();
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class with the specified number of retry attempts and parameters defining the progressive delay between retries.
 /// </summary>
 /// <param name="errorDetectionStrategy">The <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.ITransientErrorDetectionStrategy" /> that is responsible for detecting transient conditions.</param>
 /// <param name="retryStrategy">The strategy to use for this retry policy.</param>
 public RetryPolicy(ITransientErrorDetectionStrategy errorDetectionStrategy, RetryStrategy retryStrategy)
 {
     this.ErrorDetectionStrategy = Argument.NotNull(errorDetectionStrategy, nameof(errorDetectionStrategy));
     this.RetryStrategy          = Argument.NotNull(retryStrategy, nameof(retryStrategy));
 }
예제 #19
0
 protected override void Act()
 {
     this.retryStrategy = this.managerWithAllDefaults.GetRetryStrategy();
 }
 public UpdateBlobFactoryRetryLockDecorator(IUpdateBlobFactory updateBlobFactory, RetryStrategy retryStrategy)
 {
     _updateBlobFactory = updateBlobFactory;
     _retryPolicy = new RetryPolicy(new LockUpdateBlobErrorDetectionStrategy(), retryStrategy);
 }
 protected override void Act()
 {
     this.retryStrategy = new Incremental("name", 5, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(2));
     this.shouldRetry = this.retryStrategy.GetShouldRetry();
 }
 /// <summary>
 /// Create a new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class with the specified retry strategy.
 /// </summary>
 /// <param name="retryStrategy">The retry strategy.</param>
 /// <param name="isTransient">The predicate function to detect whether the specified exception is transient.</param>
 /// <returns>A new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class.</returns>
 public static RetryPolicy Catch(this RetryStrategy retryStrategy, Func <Exception, bool>?isTransient = null) =>
 CreateRetryPolicy(Argument.NotNull(retryStrategy, nameof(retryStrategy)), isTransient);
 protected override void Act()
 {
     this.retryStrategy = new ExponentialBackoff();
     this.shouldRetry = this.retryStrategy.GetShouldRetry();
 }
		/// <summary>
		///		Create a retry policy for RavenDB concurrency errors.
		/// </summary>
		/// <param name="retryStrategy">
		///		An optional retry strategy to use (defaults to 3 retries, incremental back-off).
		/// </param>
		/// <returns>
		///		The retry policy.
		/// </returns>
		public static RetryPolicy<RavenConcurrencyErrorDetectionStrategy> Concurrency(RetryStrategy retryStrategy = null)
		{
            return new RetryPolicy<RavenConcurrencyErrorDetectionStrategy>(retryStrategy ?? DefaultConcurrencyRetryStrategy);
		}
 protected override void Act()
 {
     this.retryStrategy = new ExponentialBackoff("name", 5, TimeSpan.FromSeconds(5), TimeSpan.FromMinutes(5), TimeSpan.FromSeconds(10));
     this.shouldRetry = this.retryStrategy.GetShouldRetry();
 }
예제 #26
0
        /// <summary>
        /// Create a new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class with the specified retry strategy.
        /// </summary>
        /// <param name="retryStrategy">The retry strategy.</param>
        /// <param name="isTransient">The predicate function to detect whether the specified exception is transient.</param>
        /// <returns>A new instance of the <see cref="T:Microsoft.Practices.EnterpriseLibrary.TransientFaultHandling.RetryPolicy" /> class.</returns>
        public static RetryPolicy Catch(this RetryStrategy retryStrategy, Func <Exception, bool> isTransient = null)
        {
            Guard.ArgumentNotNull(retryStrategy, nameof(retryStrategy));

            return(CreateRetryPolicy(retryStrategy, isTransient));
        }
예제 #27
0
 /// <summary>
 /// Initializes a new instance of the <see cref="T:GlebTeterin.ReliableSql.ConnectionManager"/> class with a connection string and a <see cref="P:GlebTeterin.ReliableSql.AzureSqlStrategy"/>.
 /// </summary>
 public ConnectionManager(string connectionString, ITransientErrorDetectionStrategy errorDetectionStrategy, RetryStrategy retryStrategy)
     : this(connectionString, new SmartRetryPolicy(errorDetectionStrategy, retryStrategy))
 {
 }
예제 #28
0
 /// <summary>
 /// Initializes a new instance of the <see cref="RetryPolicy{T}"/> class with the specified number of retry attempts and parameters defining the progressive delay between retries.
 /// </summary>
 /// <param name="retryStrategy">The strategy to use for this retry policy.</param>
 public RetryPolicy(RetryStrategy retryStrategy)
     : base(new T(), retryStrategy)
 {
 }
예제 #29
0
 public TestExecutor(string connectionString, ITransientErrorDetectionStrategy errorDetectionStrategy, RetryStrategy retryStrategy)
 {
     _connectionManager = new ConnectionManager(connectionString, errorDetectionStrategy, retryStrategy);
 }