refactoring retry handler.

Author: david-schrenker

src/SocketLabs/InjectionApi/Core/RetryHandler.cs

@@ -5,6 +5,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 
+// ReSharper disable MethodSupportsCancellation
 namespace SocketLabs.InjectionApi.Core
 {
     internal class RetryHandler 
@@ -39,78 +40,50 @@ public RetryHandler(HttpClient httpClient, string endpointUrl, RetrySettings set
         public async Task<HttpResponseMessage> SendAsync(StringContent content, CancellationToken cancellationToken)
         {
             if (RetrySettings.MaximumNumberOfRetries == 0)
-            {
-                return await HttpClient.PostAsync(EndpointUrl, content, cancellationToken)
+                return await HttpClient
+                    .PostAsync(EndpointUrl, content, cancellationToken)
                     .ConfigureAwait(false);
-            }
+            
 
             HttpResponseMessage response = null;
 
-            var numberOfAttempts = 0;
-            var sent = false;
+            var attempts = 0;
+            var waiting = true;
 
-            while (!sent)
+            do
             {
-                var waitFor = this.GetNextWaitInterval(numberOfAttempts);
+                var waitInterval = RetrySettings.GetNextWaitInterval(attempts);
 
                 try
                 {
-                    response = await HttpClient.PostAsync(EndpointUrl, content, cancellationToken).ConfigureAwait(false);
-                    
+                    response = await HttpClient.PostAsync(EndpointUrl, content, cancellationToken)
+                        .ConfigureAwait(false);
+
                     if (ErrorStatusCodes.Contains(response.StatusCode))
-                        throw new HttpRequestException($"HttpStatusCode: '{response.StatusCode}'. Response contains server error.");
-                    
+                        throw new HttpRequestException(
+                            $"HttpStatusCode: '{response.StatusCode}'. Response contains server error.");
 
-                    sent = true;
+                    waiting = false;
                 }
                 catch (TaskCanceledException)
                 {
-                    numberOfAttempts++;
-
-                    if (numberOfAttempts > RetrySettings.MaximumNumberOfRetries)
-                    {
-                        throw new TimeoutException();
-                    }
-
-                    // ReSharper disable once MethodSupportsCancellation, cancel will be indicated on the token
-                    await Task.Delay(waitFor).ConfigureAwait(false);
+                    attempts++;
+                    if (attempts > RetrySettings.MaximumNumberOfRetries) throw new TimeoutException();
+                    await Task.Delay(waitInterval).ConfigureAwait(false);
                 }
                 catch (HttpRequestException)
                 {
-                    numberOfAttempts++;
-
-                    if (numberOfAttempts > RetrySettings.MaximumNumberOfRetries)
-                    {
-                        throw;
-                    }
-
-                    await Task.Delay(waitFor).ConfigureAwait(false);
+                    attempts++;
+                    if (attempts > RetrySettings.MaximumNumberOfRetries) throw;
+                    await Task.Delay(waitInterval).ConfigureAwait(false);
                 }
-            }
-
-            return response;
-        }
-
-
-
-        internal virtual int GetRetryDelta(int numberOfAttempts)
-        {
-            var random = new Random();
 
-            var min = (int) (TimeSpan.FromSeconds(1).TotalMilliseconds * 0.8);
-            var max = (int) (TimeSpan.FromSeconds(1).TotalMilliseconds * 1.2);
+            } while (waiting);
 
-            return (int) ((Math.Pow(2.0, numberOfAttempts) - 1.0) * random.Next(min, max));
+            return response;
         }
 
-        private TimeSpan GetNextWaitInterval(int numberOfAttempts)
-        {
-            var interval = (int)Math.Min(
-                RetrySettings.MinimumRetryTimeBetween.TotalMilliseconds + GetRetryDelta(numberOfAttempts),
-                RetrySettings.MaximumRetryTimeBetween.TotalMilliseconds);
 
-            return TimeSpan.FromMilliseconds(interval);
-        }
 
     }
 }

src/SocketLabs/InjectionApi/RetrySettings.cs

@@ -8,33 +8,16 @@ namespace SocketLabs.InjectionApi
     public class RetrySettings
     {
 
-        /// <summary>
-        /// The maximum number of retries when sending an Injection API Request before throwing an exception. Default: 0, no retries, you must explicitly enable retry settings
-        /// </summary>
-        public int MaximumNumberOfRetries { get; }
-
-        /// <summary>
-        /// The minimum wait time between between HTTP retries. Default: 1s
-        /// </summary>
-        public TimeSpan MinimumRetryTimeBetween { get; }
-        
-        /// <summary>
-        /// The maximum wait time between between retries. Default: 10s
-        /// </summary>
-        public TimeSpan MaximumRetryTimeBetween { get; }
-
         private const int _defaultNumberOfRetries = 0;
         private const int _maximumAllowedNumberOfRetries = 5;
-        private readonly TimeSpan _defaultMinimumRetryTime = TimeSpan.FromSeconds(1);
-        private readonly TimeSpan _defaultMaximumRetryTime = TimeSpan.FromSeconds(10);
+        private readonly TimeSpan _minimumRetryTime = TimeSpan.FromSeconds(1);
+        private readonly TimeSpan _maximumRetryTime = TimeSpan.FromSeconds(10);
 
         /// <summary>
         ///  Creates a new instance of the <c>RetrySettings</c>.
         /// </summary>
         /// <param name="maximumNumberOfRetries"></param>
-        /// <param name="minimumRetryTimeBetween"></param>
-        /// <param name="maximumRetryTimeBetween"></param>
-        public RetrySettings(int? maximumNumberOfRetries = null, TimeSpan? minimumRetryTimeBetween = null, TimeSpan? maximumRetryTimeBetween = null)
+        public RetrySettings(int? maximumNumberOfRetries = null)
         {
 
             if (maximumNumberOfRetries != null)
@@ -46,38 +29,37 @@ public RetrySettings(int? maximumNumberOfRetries = null, TimeSpan? minimumRetryT
             }
             else
                 MaximumNumberOfRetries = _defaultNumberOfRetries;
+            
+        }
 
 
+        /// <summary>
+        /// The maximum number of retries when sending an Injection API Request before throwing an exception. Default: 0, no retries, you must explicitly enable retry settings
+        /// </summary>
+        public int MaximumNumberOfRetries { get; }
+        
 
-            if (minimumRetryTimeBetween != null)
-            {
-                if (minimumRetryTimeBetween.Value.Ticks < 0) throw new ArgumentOutOfRangeException(nameof(minimumRetryTimeBetween), "minimumRetryTimeBetween must be greater than 0");
-
-                MinimumRetryTimeBetween = minimumRetryTimeBetween.Value;
-            }
-            else
-                MinimumRetryTimeBetween = _defaultMinimumRetryTime;
-
-
-            if (maximumRetryTimeBetween != null)
-            {
-                if (maximumRetryTimeBetween.Value.Ticks < 0) throw new ArgumentOutOfRangeException(nameof(maximumRetryTimeBetween), "maximumRetryTimeBetween must be greater than 0");
-                if (maximumRetryTimeBetween.Value.TotalSeconds > 30) throw new ArgumentOutOfRangeException(nameof(maximumRetryTimeBetween), "maximumRetryTimeBetween must be less than 30 seconds");
-
-                MaximumRetryTimeBetween = maximumRetryTimeBetween.Value;
-            }
-            else
-                MaximumRetryTimeBetween = _defaultMaximumRetryTime;
-
+        /// <summary>
+        /// Get the time period to wait before next call
+        /// </summary>
+        /// <param name="numberOfAttempts"></param>
+        /// <returns></returns>
+        public TimeSpan GetNextWaitInterval(int numberOfAttempts)
+        {
+            var interval = (int)Math.Min(
+                _minimumRetryTime.TotalMilliseconds + GetRetryDelta(numberOfAttempts),
+                _maximumRetryTime.TotalMilliseconds);
 
-            if (minimumRetryTimeBetween != null && maximumRetryTimeBetween != null)
-            {
-                if (minimumRetryTimeBetween.Value.TotalMilliseconds > maximumRetryTimeBetween.Value.TotalMilliseconds)
-                    throw new ArgumentOutOfRangeException(nameof(minimumRetryTimeBetween),
-                        "minimumRetryTimeBetween must be less than maximumRetryTimeBetween");
-            }
+            return TimeSpan.FromMilliseconds(interval);
+        }
+        internal virtual int GetRetryDelta(int numberOfAttempts)
+        {
+            var random = new Random();
 
+            var min = (int)(TimeSpan.FromSeconds(1).TotalMilliseconds * 0.8);
+            var max = (int)(TimeSpan.FromSeconds(1).TotalMilliseconds * 1.2);
 
+            return (int)((Math.Pow(2.0, numberOfAttempts) - 1.0) * random.Next(min, max));
         }
     }
 }