Handle overflow cases (#13)

Author: sethvargo

backoff.go

@@ -103,7 +103,7 @@ func WithCappedDuration(cap time.Duration, next Backoff) Backoff {
 			return 0, true
 		}
 
-		if val > cap {
+		if val <= 0 || val > cap {
 			val = cap
 		}
 		return val, false
@@ -127,7 +127,7 @@ func WithMaxDuration(timeout time.Duration, next Backoff) Backoff {
 			return 0, true
 		}
 
-		if val > diff {
+		if val <= 0 || val > diff {
 			val = diff
 		}
 		return val, false

backoff_exponential.go

@@ -2,6 +2,7 @@ package retry
 
 import (
 	"context"
+	"math"
 	"sync/atomic"
 	"time"
 )
@@ -11,17 +12,19 @@ type exponentialBackoff struct {
 	attempt uint64
 }
 
-// Exponential is a wrapper around Retry that uses an exponential backoff. It's
-// very efficient, but does not check for overflow, so ensure you bound the
-// retry. It panics if the given base is less than zero.
+// Exponential is a wrapper around Retry that uses an exponential backoff. See
+// NewExponential.
 func Exponential(ctx context.Context, base time.Duration, f RetryFunc) error {
 	return Do(ctx, NewExponential(base), f)
 }
 
 // NewExponential creates a new exponential backoff using the starting value of
 // base and doubling on each failure (1, 2, 4, 8, 16, 32, 64...), up to max.
-// It's very efficient, but does not check for overflow, so ensure you bound the
-// retry. It panics if the given base is less than 0.
+//
+// Once it overflows, the function constantly returns the maximum time.Duration
+// for a 64-bit integer.
+//
+// It panics if the given base is less than zero.
 func NewExponential(base time.Duration) Backoff {
 	if base <= 0 {
 		panic("base must be greater than 0")
@@ -34,5 +37,11 @@ func NewExponential(base time.Duration) Backoff {
 
 // Next implements Backoff. It is safe for concurrent use.
 func (b *exponentialBackoff) Next() (time.Duration, bool) {
-	return b.base << (atomic.AddUint64(&b.attempt, 1) - 1), false
+	next := b.base << (atomic.AddUint64(&b.attempt, 1) - 1)
+	if next <= 0 {
+		atomic.AddUint64(&b.attempt, ^uint64(0))
+		next = math.MaxInt64
+	}
+
+	return next, false
 }

backoff_exponential_test.go

@@ -2,6 +2,7 @@ package retry_test
 
 import (
 	"fmt"
+	"math"
 	"reflect"
 	"sort"
 	"testing"
@@ -48,6 +49,23 @@ func TestExponentialBackoff(t *testing.T) {
 				8192 * time.Nanosecond,
 			},
 		},
+		{
+			name:  "overflow",
+			base:  100_000 * time.Hour,
+			tries: 10,
+			exp: []time.Duration{
+				100_000 * time.Hour,
+				200_000 * time.Hour,
+				400_000 * time.Hour,
+				800_000 * time.Hour,
+				1_600_000 * time.Hour,
+				math.MaxInt64,
+				math.MaxInt64,
+				math.MaxInt64,
+				math.MaxInt64,
+				math.MaxInt64,
+			},
+		},
 	}
 
 	for _, tc := range cases {

backoff_fibonacci.go

@@ -2,6 +2,7 @@ package retry
 
 import (
 	"context"
+	"math"
 	"sync/atomic"
 	"time"
 	"unsafe"
@@ -13,16 +14,20 @@ type fibonacciBackoff struct {
 	state unsafe.Pointer
 }
 
-// Fibonacci is a wrapper around Retry that uses a Fibonacci backoff. It panics
-// if the given base is less than zero.
+// Fibonacci is a wrapper around Retry that uses a Fibonacci backoff. See
+// NewFibonacci.
 func Fibonacci(ctx context.Context, base time.Duration, f RetryFunc) error {
 	return Do(ctx, NewFibonacci(base), f)
 }
 
 // NewFibonacci creates a new Fibonacci backoff using the starting value of
 // base. The wait time is the sum of the previous two wait times on each failed
-// attempt (1, 1, 2, 3, 5, 8, 13...). It panics if the given base is less than
-// zero.
+// attempt (1, 1, 2, 3, 5, 8, 13...).
+//
+// Once it overflows, the function constantly returns the maximum time.Duration
+// for a 64-bit integer.
+//
+// It panics if the given base is less than zero.
 func NewFibonacci(base time.Duration) Backoff {
 	if base <= 0 {
 		panic("base must be greater than 0")
@@ -40,6 +45,10 @@ func (b *fibonacciBackoff) Next() (time.Duration, bool) {
 		currState := (*state)(curr)
 		next := currState[0] + currState[1]
 
+		if next <= 0 {
+			return math.MaxInt64, false
+		}
+
 		if atomic.CompareAndSwapPointer(&b.state, curr, unsafe.Pointer(&state{currState[1], next})) {
 			return next, false
 		}

backoff_fibonacci_test.go

@@ -2,6 +2,7 @@ package retry_test
 
 import (
 	"fmt"
+	"math"
 	"reflect"
 	"sort"
 	"testing"
@@ -60,6 +61,23 @@ func TestFibonacciBackoff(t *testing.T) {
 				610 * time.Nanosecond,
 			},
 		},
+		{
+			name:  "overflow",
+			base:  100_000 * time.Hour,
+			tries: 10,
+			exp: []time.Duration{
+				100_000 * time.Hour,
+				200_000 * time.Hour,
+				300_000 * time.Hour,
+				500_000 * time.Hour,
+				800_000 * time.Hour,
+				1_300_000 * time.Hour,
+				2_100_000 * time.Hour,
+				math.MaxInt64,
+				math.MaxInt64,
+				math.MaxInt64,
+			},
+		},
 	}
 
 	for _, tc := range cases {