delay based on error

.travis.yml

@@ -1,7 +1,6 @@
 language: go
 
 go:
-  - 1.7
   - 1.8
   - 1.9
   - "1.10"

README.md

@@ -61,8 +61,9 @@ slightly similar as this package, don't have 'simple' `Retry` method
 * [matryer/try](https://github.com/matryer/try) - very popular package,
 nonintuitive interface (for me)
 
-
-### BREAKING CHANGES
+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
 
@@ -98,7 +99,7 @@ var (
 #### 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
 
@@ -111,7 +112,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
 
@@ -125,7 +126,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
 
@@ -147,9 +148,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
 

VERSION

@@ -1 +1 @@
-2.7.0
+3.0.0

examples/custom_retry_function_test.go

@@ -1,8 +1,10 @@
 package retry_test
 
 import (
+	"fmt"
 	"io/ioutil"
 	"net/http"
+	"net/http/httptest"
 	"testing"
 	"time"
 
@@ -11,12 +13,16 @@ import (
 )
 
 func TestCustomRetryFunction(t *testing.T) {
-	url := "http://example.com"
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintln(w, "hello")
+	}))
+	defer ts.Close()
+
 	var body []byte
 
 	err := retry.Do(
 		func() error {
-			resp, err := http.Get(url)
+			resp, err := http.Get(ts.URL)
 
 			if err == nil {
 				defer func() {
@@ -29,7 +35,7 @@ func TestCustomRetryFunction(t *testing.T) {
 
 			return err
 		},
-		retry.DelayType(func(n uint, config *retry.Config) time.Duration {
+		retry.DelayType(func(n uint, _ error, config *retry.Config) time.Duration {
 			return 0
 		}),
 	)

examples/delay_based_on_error_test.go

@@ -0,0 +1,84 @@
+// This test delay is based on kind of error
+// e.g. HTTP response [Retry-After](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After)
+package retry_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/avast/retry-go"
+	"github.com/stretchr/testify/assert"
+)
+
+type RetryAfterError struct {
+	response http.Response
+}
+
+func (err RetryAfterError) Error() string {
+	return fmt.Sprintf(
+		"Request to %s fail %s (%d)",
+		err.response.Request.RequestURI,
+		err.response.Status,
+		err.response.StatusCode,
+	)
+}
+
+type SomeOtherError struct {
+	err        string
+	retryAfter time.Duration
+}
+
+func (err SomeOtherError) Error() string {
+	return err.err
+}
+
+func TestCustomRetryFunctionBasedOnKindOfError(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintln(w, "hello")
+	}))
+	defer ts.Close()
+
+	var body []byte
+
+	err := retry.Do(
+		func() error {
+			resp, err := http.Get(ts.URL)
+
+			if err == nil {
+				defer func() {
+					if err := resp.Body.Close(); err != nil {
+						panic(err)
+					}
+				}()
+				body, err = ioutil.ReadAll(resp.Body)
+			}
+
+			return err
+		},
+		retry.DelayType(func(n uint, err error, config *retry.Config) time.Duration {
+			switch e := err.(type) {
+			case RetryAfterError:
+				if t, err := parseRetryAfter(e.response.Header.Get("Retry-After")); err == nil {
+					return time.Until(t)
+				}
+			case SomeOtherError:
+				return e.retryAfter
+			}
+
+			//default is backoffdelay
+			return retry.BackOffDelay(n, err, config)
+		}),
+	)
+
+	assert.NoError(t, err)
+	assert.NotEmpty(t, body)
+}
+
+// use https://github.com/aereal/go-httpretryafter instead
+func parseRetryAfter(_ string) (time.Time, error) {
+	return time.Now().Add(1 * time.Second), nil
+}

examples/http_get_test.go

@@ -1,21 +1,27 @@
 package retry_test
 
 import (
+	"fmt"
 	"io/ioutil"
 	"net/http"
+	"net/http/httptest"
 	"testing"
 
 	"github.com/avast/retry-go"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestGet(t *testing.T) {
-	url := "http://example.com"
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintln(w, "hello")
+	}))
+	defer ts.Close()
+
 	var body []byte
 
 	err := retry.Do(
 		func() error {
-			resp, err := http.Get(url)
+			resp, err := http.Get(ts.URL)
 
 			if err == nil {
 				defer func() {

options.go

@@ -14,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
@@ -81,45 +82,48 @@ func DelayType(delayType DelayTypeFunc) Option {
 }
 
 // BackOffDelay is a DelayType which increases delay between consecutive retries
-func BackOffDelay(n uint, config *Config) time.Duration {
+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 {
 	const maxInt64 = uint64(math.MaxInt64)
 
-	return func(n uint, config *Config) time.Duration {
+	return func(n uint, err error, config *Config) time.Duration {
 		var total uint64
 		for _, delay := range delays {
-			total += uint64(delay(n, config))
+			total += uint64(delay(n, err, config))
 			if total > maxInt64 {
 				total = maxInt64
 			}
 		}
+
 		return time.Duration(total)
 	}
 }

retry.go

@@ -44,6 +44,9 @@ 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
 
@@ -134,7 +137,7 @@ 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
 			}

retry_test.go

@@ -199,7 +199,7 @@ func TestBackOffDelay(t *testing.T) {
 				config := Config{
 					delay: c.delay,
 				}
-				delay := BackOffDelay(c.n, &config)
+				delay := BackOffDelay(c.n, nil, &config)
 				assert.Equal(t, c.expectedMaxN, config.maxBackOffN, "max n mismatch")
 				assert.Equal(t, c.expectedDelay, delay, "delay duration mismatch")
 			},
@@ -209,7 +209,7 @@ func TestBackOffDelay(t *testing.T) {
 
 func TestCombineDelay(t *testing.T) {
 	f := func(d time.Duration) DelayTypeFunc {
-		return func(_ uint, _ *Config) time.Duration {
+		return func(_ uint, _ error, _ *Config) time.Duration {
 			return d
 		}
 	}
@@ -254,7 +254,7 @@ func TestCombineDelay(t *testing.T) {
 				for i, d := range c.delays {
 					funcs[i] = f(d)
 				}
-				actual := CombineDelay(funcs...)(0, nil)
+				actual := CombineDelay(funcs...)(0, nil, nil)
 				assert.Equal(t, c.expected, actual, "delay duration mismatch")
 			},
 		)