Merge v1.2.1-master

Signed-off-by: Emile Vauge <emile@vauge.com>

vendor/github.com/cenk/backoff/context.go

@@ -0,0 +1,60 @@
+package backoff
+
+import (
+	"time"
+
+	"golang.org/x/net/context"
+)
+
+// BackOffContext is a backoff policy that stops retrying after the context
+// is canceled.
+type BackOffContext interface {
+	BackOff
+	Context() context.Context
+}
+
+type backOffContext struct {
+	BackOff
+	ctx context.Context
+}
+
+// WithContext returns a BackOffContext with context ctx
+//
+// ctx must not be nil
+func WithContext(b BackOff, ctx context.Context) BackOffContext {
+	if ctx == nil {
+		panic("nil context")
+	}
+
+	if b, ok := b.(*backOffContext); ok {
+		return &backOffContext{
+			BackOff: b.BackOff,
+			ctx:     ctx,
+		}
+	}
+
+	return &backOffContext{
+		BackOff: b,
+		ctx:     ctx,
+	}
+}
+
+func ensureContext(b BackOff) BackOffContext {
+	if cb, ok := b.(BackOffContext); ok {
+		return cb
+	}
+	return WithContext(b, context.Background())
+}
+
+func (b *backOffContext) Context() context.Context {
+	return b.ctx
+}
+
+func (b *backOffContext) NextBackOff() time.Duration {
+	select {
+	case <-b.Context().Done():
+		return Stop
+	default:
+		return b.BackOff.NextBackOff()
+	}
+}

vendor/github.com/cenk/backoff/exponential.go

@@ -89,11 +89,6 @@ func NewExponentialBackOff() *ExponentialBackOff {
 		MaxElapsedTime:      DefaultMaxElapsedTime,
 		Clock:               SystemClock,
 	}
-	if b.RandomizationFactor < 0 {
-		b.RandomizationFactor = 0
-	} else if b.RandomizationFactor > 1 {
-		b.RandomizationFactor = 1
-	}
 	b.Reset()
 	return b
 }

vendor/github.com/cenk/backoff/retry.go

@@ -17,6 +17,9 @@ type Notify func(error, time.Duration)
 // o is guaranteed to be run at least once.
 // It is the caller's responsibility to reset b after Retry returns.
 //
+// If o returns a *PermanentError, the operation is not retried, and the
+// wrapped error is returned.
+//
 // Retry sleeps the goroutine for the duration returned by BackOff after a
 // failed operation returns.
 func Retry(o Operation, b BackOff) error { return RetryNotify(o, b, nil) }
@@ -27,12 +30,18 @@ func RetryNotify(operation Operation, b BackOff, notify Notify) error {
 	var err error
 	var next time.Duration
 
+	cb := ensureContext(b)
+
 	b.Reset()
 	for {
 		if err = operation(); err == nil {
 			return nil
 		}
 
+		if permanent, ok := err.(*PermanentError); ok {
+			return permanent.Err
+		}
+
 		if next = b.NextBackOff(); next == Stop {
 			return err
 		}
@@ -41,6 +50,29 @@ func RetryNotify(operation Operation, b BackOff, notify Notify) error {
 			notify(err, next)
 		}
 
-		time.Sleep(next)
+		t := time.NewTimer(next)
+
+		select {
+		case <-cb.Context().Done():
+			t.Stop()
+			return err
+		case <-t.C:
+		}
+	}
+}
+
+// PermanentError signals that the operation should not be retried.
+type PermanentError struct {
+	Err error
+}
+
+func (e *PermanentError) Error() string {
+	return e.Err.Error()
+}
+
+// Permanent wraps the given err in a *PermanentError.
+func Permanent(err error) *PermanentError {
+	return &PermanentError{
+		Err: err,
 	}
 }

vendor/github.com/cenk/backoff/ticker.go

@@ -13,7 +13,7 @@ import (
 type Ticker struct {
 	C        <-chan time.Time
 	c        chan time.Time
-	b        BackOff
+	b        BackOffContext
 	stop     chan struct{}
 	stopOnce sync.Once
 }
@@ -26,7 +26,7 @@ func NewTicker(b BackOff) *Ticker {
 	t := &Ticker{
 		C:    c,
 		c:    c,
-		b:    b,
+		b:    ensureContext(b),
 		stop: make(chan struct{}),
 	}
 	go t.run()
@@ -58,6 +58,8 @@ func (t *Ticker) run() {
 		case <-t.stop:
 			t.c = nil // Prevent future ticks from being sent to the channel.
 			return
+		case <-t.b.Context().Done():
+			return
 		}
 	}
 }