build: upgrade to go 1.17 and dependencies

vendor/github.com/avast/retry-go/.travis.yml

@@ -1,13 +1,14 @@
 language: go
 
 go:
-  - 1.6
-  - 1.7
   - 1.8
   - 1.9
   - "1.10"
   - 1.11
   - 1.12
+  - 1.13
+  - 1.14
+  - 1.15
 
 install:
   - make setup

vendor/github.com/avast/retry-go/README.md

@@ -64,6 +64,12 @@ nonintuitive interface (for me)
 
 ### BREAKING CHANGES
 
+3.0.0
+
+* `DelayTypeFunc` accepts a new parameter `err` - this breaking change affects
+only your custom Delay Functions. This change allow [make delay functions based
+on error](examples/delay_based_on_error_test.go).
+
 1.0.2 -> 2.0.0
 
 * argument of `retry.Delay` is final delay (no multiplication by `retry.Units`
@@ -91,13 +97,14 @@ var (
 	DefaultRetryIf       = IsRecoverable
 	DefaultDelayType     = CombineDelay(BackOffDelay, RandomDelay)
 	DefaultLastErrorOnly = false
+	DefaultContext       = context.Background()
 )
 ```
 
 #### func  BackOffDelay
 
 ```go
-func BackOffDelay(n uint, config *Config) time.Duration
+func BackOffDelay(n uint, _ error, config *Config) time.Duration
 ```
 BackOffDelay is a DelayType which increases delay between consecutive retries
 
@@ -110,7 +117,7 @@ func Do(retryableFunc RetryableFunc, opts ...Option) error
 #### func  FixedDelay
 
 ```go
-func FixedDelay(_ uint, config *Config) time.Duration
+func FixedDelay(_ uint, _ error, config *Config) time.Duration
 ```
 FixedDelay is a DelayType which keeps delay the same through all iterations
 
@@ -124,7 +131,7 @@ IsRecoverable checks if error is an instance of `unrecoverableError`
 #### func  RandomDelay
 
 ```go
-func RandomDelay(_ uint, config *Config) time.Duration
+func RandomDelay(_ uint, _ error, config *Config) time.Duration
 ```
 RandomDelay is a DelayType which picks a random delay up to config.maxJitter
 
@@ -146,9 +153,11 @@ type Config struct {
 #### type DelayTypeFunc
 
 ```go
-type DelayTypeFunc func(n uint, config *Config) time.Duration
+type DelayTypeFunc func(n uint, err error, config *Config) time.Duration
 ```
 
+DelayTypeFunc is called to return the next delay to wait after the retriable
+function fails on `err` after `n` attempts.
 
 #### func  CombineDelay
 
@@ -207,6 +216,26 @@ func Attempts(attempts uint) Option
 ```
 Attempts set count of retry default is 10
 
+#### func  Context
+
+```go
+func Context(ctx context.Context) Option
+```
+Context allow to set context of retry default are Background context
+
+example of immediately cancellation (maybe it isn't the best example, but it
+describes behavior enough; I hope)
+
+    ctx, cancel := context.WithCancel(context.Background())
+    cancel()
+
+    retry.Do(
+    	func() error {
+    		...
+    	},
+    	retry.Context(ctx),
+    )
+
 #### func  Delay
 
 ```go

vendor/github.com/avast/retry-go/VERSION

@@ -1 +1 @@
-2.6.0
+3.0.0

vendor/github.com/avast/retry-go/options.go

@@ -1,6 +1,8 @@
 package retry
 
 import (
+	"context"
+	"math"
 	"math/rand"
 	"time"
 )
@@ -12,7 +14,8 @@ type RetryIfFunc func(error) bool
 // n = count of attempts
 type OnRetryFunc func(n uint, err error)
 
-type DelayTypeFunc func(n uint, config *Config) time.Duration
+// DelayTypeFunc is called to return the next delay to wait after the retriable function fails on `err` after `n` attempts.
+type DelayTypeFunc func(n uint, err error, config *Config) time.Duration
 
 type Config struct {
 	attempts      uint
@@ -23,6 +26,9 @@ type Config struct {
 	retryIf       RetryIfFunc
 	delayType     DelayTypeFunc
 	lastErrorOnly bool
+	context       context.Context
+
+	maxBackOffN uint
 }
 
 // Option represents an option for retry.
@@ -76,28 +82,49 @@ func DelayType(delayType DelayTypeFunc) Option {
 }
 
 // BackOffDelay is a DelayType which increases delay between consecutive retries
-func BackOffDelay(n uint, config *Config) time.Duration {
-	return config.delay * (1 << n)
+func BackOffDelay(n uint, _ error, config *Config) time.Duration {
+	// 1 << 63 would overflow signed int64 (time.Duration), thus 62.
+	const max uint = 62
+
+	if config.maxBackOffN == 0 {
+		if config.delay <= 0 {
+			config.delay = 1
+		}
+
+		config.maxBackOffN = max - uint(math.Floor(math.Log2(float64(config.delay))))
+	}
+
+	if n > config.maxBackOffN {
+		n = config.maxBackOffN
+	}
+
+	return config.delay << n
 }
 
 // FixedDelay is a DelayType which keeps delay the same through all iterations
-func FixedDelay(_ uint, config *Config) time.Duration {
+func FixedDelay(_ uint, _ error, config *Config) time.Duration {
 	return config.delay
 }
 
 // RandomDelay is a DelayType which picks a random delay up to config.maxJitter
-func RandomDelay(_ uint, config *Config) time.Duration {
+func RandomDelay(_ uint, _ error, config *Config) time.Duration {
 	return time.Duration(rand.Int63n(int64(config.maxJitter)))
 }
 
 // CombineDelay is a DelayType the combines all of the specified delays into a new DelayTypeFunc
 func CombineDelay(delays ...DelayTypeFunc) DelayTypeFunc {
-	return func(n uint, config *Config) time.Duration {
-		var total time.Duration
+	const maxInt64 = uint64(math.MaxInt64)
+
+	return func(n uint, err error, config *Config) time.Duration {
+		var total uint64
 		for _, delay := range delays {
-			total += delay(n, config)
+			total += uint64(delay(n, err, config))
+			if total > maxInt64 {
+				total = maxInt64
+			}
 		}
-		return total
+
+		return time.Duration(total)
 	}
 }
 
@@ -149,3 +176,23 @@ func RetryIf(retryIf RetryIfFunc) Option {
 		c.retryIf = retryIf
 	}
 }
+
+// Context allow to set context of retry
+// default are Background context
+//
+// example of immediately cancellation (maybe it isn't the best example, but it describes behavior enough; I hope)
+//
+//	ctx, cancel := context.WithCancel(context.Background())
+//	cancel()
+//
+//	retry.Do(
+//		func() error {
+//			...
+//		},
+//		retry.Context(ctx),
+//	)
+func Context(ctx context.Context) Option {
+	return func(c *Config) {
+		c.context = ctx
+	}
+}

vendor/github.com/avast/retry-go/retry.go

@@ -43,8 +43,14 @@ SEE ALSO
 
 * [matryer/try](https://github.com/matryer/try) - very popular package, nonintuitive interface (for me)
 
+
 BREAKING CHANGES
 
+3.0.0
+
+* `DelayTypeFunc` accepts a new parameter `err` - this breaking change affects only your custom Delay Functions. This change allow [make delay functions based on error](examples/delay_based_on_error_test.go).
+
+
 1.0.2 -> 2.0.0
 
 * argument of `retry.Delay` is final delay (no multiplication by `retry.Units` anymore)
@@ -65,6 +71,7 @@ BREAKING CHANGES
 package retry
 
 import (
+	"context"
 	"fmt"
 	"strings"
 	"time"
@@ -81,6 +88,7 @@ var (
 	DefaultRetryIf       = IsRecoverable
 	DefaultDelayType     = CombineDelay(BackOffDelay, RandomDelay)
 	DefaultLastErrorOnly = false
+	DefaultContext       = context.Background()
 )
 
 func Do(retryableFunc RetryableFunc, opts ...Option) error {
@@ -95,6 +103,7 @@ func Do(retryableFunc RetryableFunc, opts ...Option) error {
 		retryIf:       DefaultRetryIf,
 		delayType:     DefaultDelayType,
 		lastErrorOnly: DefaultLastErrorOnly,
+		context:       DefaultContext,
 	}
 
 	//apply opts
@@ -102,6 +111,10 @@ func Do(retryableFunc RetryableFunc, opts ...Option) error {
 		opt(config)
 	}
 
+	if err := config.context.Err(); err != nil {
+		return err
+	}
+
 	var errorLog Error
 	if !config.lastErrorOnly {
 		errorLog = make(Error, config.attempts)
@@ -127,11 +140,17 @@ func Do(retryableFunc RetryableFunc, opts ...Option) error {
 				break
 			}
 
-			delayTime := config.delayType(n, config)
+			delayTime := config.delayType(n, err, config)
 			if config.maxDelay > 0 && delayTime > config.maxDelay {
 				delayTime = config.maxDelay
 			}
-			time.Sleep(delayTime)
+
+			select {
+			case <-time.After(delayTime):
+			case <-config.context.Done():
+				return config.context.Err()
+			}
+
 		} else {
 			return nil
 		}