fixing backoff overflow

Author: brettsam

src/WebJobs.Script/Utility.cs

@@ -68,7 +68,16 @@ public static string GetSettingFromConfigOrEnvironment(string settingName)
         /// <returns>A <see cref="Task"/> representing the computed backoff interval.</returns>
         public static async Task DelayWithBackoffAsync(int exponent, CancellationToken cancellationToken, TimeSpan? unit = null, TimeSpan? min = null, TimeSpan? max = null)
         {
-            TimeSpan delay = ComputeBackoff(exponent, unit, min, max);
+            TimeSpan delay = TimeSpan.FromSeconds(5);
+
+            try
+            {
+                delay = ComputeBackoff(exponent, unit, min, max);
+            }
+            catch (Exception)
+            {
+                // Use the default if there is any problem computing backoff
+            }
 
             if (delay.TotalMilliseconds > 0)
             {
@@ -85,12 +94,27 @@ public static async Task DelayWithBackoffAsync(int exponent, CancellationToken c
 
         internal static TimeSpan ComputeBackoff(int exponent, TimeSpan? unit = null, TimeSpan? min = null, TimeSpan? max = null)
         {
+            TimeSpan maxValue = max ?? TimeSpan.MaxValue;
+
+            // prevent an OverflowException
+            if (exponent >= 64)
+            {
+                return maxValue;
+            }
+
             // determine the exponential backoff factor
             long backoffFactor = Convert.ToInt64((Math.Pow(2, exponent) - 1) / 2);
 
             // compute the backoff delay
             unit = unit ?? TimeSpan.FromSeconds(1);
             long totalDelayTicks = backoffFactor * unit.Value.Ticks;
+
+            // If we've overflowed long, return max.
+            if (backoffFactor > 0 && totalDelayTicks <= 0)
+            {
+                return maxValue;
+            }
+
             TimeSpan delay = TimeSpan.FromTicks(totalDelayTicks);
 
             // apply minimum restriction
@@ -100,9 +124,9 @@ internal static TimeSpan ComputeBackoff(int exponent, TimeSpan? unit = null, Tim
             }
 
             // apply maximum restriction
-            if (max.HasValue && delay > max)
+            if (delay > maxValue)
             {
-                delay = max.Value;
+                delay = maxValue;
             }
 
             return delay;

test/WebJobs.Script.Tests/UtilityTests.cs

@@ -131,6 +131,29 @@ public void ComputeBackoff_ReturnsExpectedValue(int exponent, string unitValue,
             Assert.Equal(expectedTimespan, result);
         }
 
+        [Theory]
+        [InlineData("00:02:00", "00:02:00")]
+        [InlineData(null, "10675199.02:48:05.4775807")]
+        public void ComputeBackoff_Overflow(string maxValue, string expected)
+        {
+            TimeSpan? max = null;
+            if (maxValue != null)
+            {
+                max = TimeSpan.Parse(maxValue);
+            }
+
+            TimeSpan expectedValue = TimeSpan.Parse(expected);
+
+            // Catches two overflow bugs:
+            // 1. Computed ticks would fluctuate between positive and negative, resulting in min-and-max alternating.
+            // 2. At 64+ we'd throw an OverflowException.
+            for (int i = 60; i < 70; i++)
+            {
+                TimeSpan result = Utility.ComputeBackoff(i, min: TimeSpan.FromSeconds(1), max: max);
+                Assert.Equal(expectedValue, result);
+            }
+        }
+
         [Theory]
         [InlineData(typeof(TestPoco), true)]
         [InlineData(typeof(TestStruct), true)]