Update server dependencies

vendor/github.com/cenkalti/backoff/v4/.travis.yml

@@ -1,6 +1,6 @@
 language: go
 go:
-  - 1.7
+  - 1.12
   - 1.x
   - tip
 before_install:

vendor/github.com/cenkalti/backoff/v4/README.md

@@ -9,7 +9,10 @@ The retries exponentially increase and stop increasing when a certain threshold
 
 ## Usage
 
-See https://godoc.org/github.com/cenkalti/backoff#pkg-examples
+Import path is `github.com/cenkalti/backoff/v4`. Please note the version part at the end.
+
+godoc.org does not support modules yet,
+so you can use https://godoc.org/gopkg.in/cenkalti/backoff.v4 to view the documentation.
 
 ## Contributing
 

vendor/github.com/cenkalti/backoff/v4/context.go

@@ -7,7 +7,7 @@ import (
 
 // BackOffContext is a backoff policy that stops retrying after the context
 // is canceled.
-type BackOffContext interface {
+type BackOffContext interface { // nolint: golint
 	BackOff
 	Context() context.Context
 }
@@ -20,7 +20,7 @@ type backOffContext struct {
 // WithContext returns a BackOffContext with context ctx
 //
 // ctx must not be nil
-func WithContext(b BackOff, ctx context.Context) BackOffContext {
+func WithContext(b BackOff, ctx context.Context) BackOffContext { // nolint: golint
 	if ctx == nil {
 		panic("nil context")
 	}
@@ -38,11 +38,14 @@ func WithContext(b BackOff, ctx context.Context) BackOffContext {
 	}
 }
 
-func ensureContext(b BackOff) BackOffContext {
+func getContext(b BackOff) context.Context {
 	if cb, ok := b.(BackOffContext); ok {
-		return cb
+		return cb.Context()
 	}
-	return WithContext(b, context.Background())
+	if tb, ok := b.(*backOffTries); ok {
+		return getContext(tb.delegate)
+	}
+	return context.Background()
 }
 
 func (b *backOffContext) Context() context.Context {
@@ -56,7 +59,7 @@ func (b *backOffContext) NextBackOff() time.Duration {
 	default:
 	}
 	next := b.BackOff.NextBackOff()
-	if deadline, ok := b.ctx.Deadline(); ok && deadline.Sub(time.Now()) < next {
+	if deadline, ok := b.ctx.Deadline(); ok && deadline.Sub(time.Now()) < next { // nolint: gosimple
 		return Stop
 	}
 	return next

vendor/github.com/cenkalti/backoff/v4/exponential.go

@@ -56,9 +56,10 @@ type ExponentialBackOff struct {
 	RandomizationFactor float64
 	Multiplier          float64
 	MaxInterval         time.Duration
-	// After MaxElapsedTime the ExponentialBackOff stops.
+	// After MaxElapsedTime the ExponentialBackOff returns Stop.
 	// It never stops if MaxElapsedTime == 0.
 	MaxElapsedTime time.Duration
+	Stop           time.Duration
 	Clock          Clock
 
 	currentInterval time.Duration
@@ -87,6 +88,7 @@ func NewExponentialBackOff() *ExponentialBackOff {
 		Multiplier:          DefaultMultiplier,
 		MaxInterval:         DefaultMaxInterval,
 		MaxElapsedTime:      DefaultMaxElapsedTime,
+		Stop:                Stop,
 		Clock:               SystemClock,
 	}
 	b.Reset()
@@ -103,20 +105,23 @@ func (t systemClock) Now() time.Time {
 var SystemClock = systemClock{}
 
 // Reset the interval back to the initial retry interval and restarts the timer.
+// Reset must be called before using b.
 func (b *ExponentialBackOff) Reset() {
 	b.currentInterval = b.InitialInterval
 	b.startTime = b.Clock.Now()
 }
 
 // NextBackOff calculates the next backoff interval using the formula:
-// 	Randomized interval = RetryInterval +/- (RandomizationFactor * RetryInterval)
+// 	Randomized interval = RetryInterval * (1 ± RandomizationFactor)
 func (b *ExponentialBackOff) NextBackOff() time.Duration {
 	// Make sure we have not gone over the maximum elapsed time.
-	if b.MaxElapsedTime != 0 && b.GetElapsedTime() > b.MaxElapsedTime {
-		return Stop
+	elapsed := b.GetElapsedTime()
+	next := getRandomValueFromInterval(b.RandomizationFactor, rand.Float64(), b.currentInterval)
+	b.incrementCurrentInterval()
+	if b.MaxElapsedTime != 0 && elapsed+next > b.MaxElapsedTime {
+		return b.Stop
 	}
-	defer b.incrementCurrentInterval()
-	return getRandomValueFromInterval(b.RandomizationFactor, rand.Float64(), b.currentInterval)
+	return next
 }
 
 // GetElapsedTime returns the elapsed time since an ExponentialBackOff instance
@@ -140,7 +145,7 @@ func (b *ExponentialBackOff) incrementCurrentInterval() {
 }
 
 // Returns a random value from the following interval:
-// 	[randomizationFactor * currentInterval, randomizationFactor * currentInterval].
+// 	[currentInterval - randomizationFactor * currentInterval, currentInterval + randomizationFactor * currentInterval].
 func getRandomValueFromInterval(randomizationFactor, random float64, currentInterval time.Duration) time.Duration {
 	var delta = randomizationFactor * float64(currentInterval)
 	var minInterval = float64(currentInterval) - delta

vendor/github.com/cenkalti/backoff/v4/go.mod

@@ -0,0 +1,3 @@
+module github.com/cenkalti/backoff/v4
+
+go 1.12

vendor/github.com/cenkalti/backoff/v4/retry.go

@@ -21,16 +21,31 @@ type Notify func(error, time.Duration)
 //
 // 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) }
+func Retry(o Operation, b BackOff) error {
+	return RetryNotify(o, b, nil)
+}
 
 // RetryNotify calls notify function with the error and wait duration
 // for each failed attempt before sleep.
 func RetryNotify(operation Operation, b BackOff, notify Notify) error {
+	return RetryNotifyWithTimer(operation, b, notify, nil)
+}
+
+// RetryNotifyWithTimer calls notify function with the error and wait duration using the given Timer
+// for each failed attempt before sleep.
+// A default timer that uses system timer is used when nil is passed.
+func RetryNotifyWithTimer(operation Operation, b BackOff, notify Notify, t Timer) error {
 	var err error
 	var next time.Duration
-	var t *time.Timer
+	if t == nil {
+		t = &defaultTimer{}
+	}
 
-	cb := ensureContext(b)
+	defer func() {
+		t.Stop()
+	}()
+
+	ctx := getContext(b)
 
 	b.Reset()
 	for {
@@ -42,7 +57,7 @@ func RetryNotify(operation Operation, b BackOff, notify Notify) error {
 			return permanent.Err
 		}
 
-		if next = cb.NextBackOff(); next == Stop {
+		if next = b.NextBackOff(); next == Stop {
 			return err
 		}
 
@@ -50,17 +65,12 @@ func RetryNotify(operation Operation, b BackOff, notify Notify) error {
 			notify(err, next)
 		}
 
-		if t == nil {
-			t = time.NewTimer(next)
-			defer t.Stop()
-		} else {
-			t.Reset(next)
-		}
+		t.Start(next)
 
 		select {
-		case <-cb.Context().Done():
-			return err
-		case <-t.C:
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-t.C():
 		}
 	}
 }
@@ -74,6 +84,10 @@ func (e *PermanentError) Error() string {
 	return e.Err.Error()
 }
 
+func (e *PermanentError) Unwrap() error {
+	return e.Err
+}
+
 // Permanent wraps the given err in a *PermanentError.
 func Permanent(err error) *PermanentError {
 	return &PermanentError{

vendor/github.com/cenkalti/backoff/v4/ticker.go

@@ -1,6 +1,7 @@
 package backoff
 
 import (
+	"context"
 	"sync"
 	"time"
 )
@@ -12,7 +13,9 @@ import (
 type Ticker struct {
 	C        <-chan time.Time
 	c        chan time.Time
-	b        BackOffContext
+	b        BackOff
+	ctx      context.Context
+	timer    Timer
 	stop     chan struct{}
 	stopOnce sync.Once
 }
@@ -24,12 +27,23 @@ type Ticker struct {
 // provided backoff policy (notably calling NextBackOff or Reset)
 // while the ticker is running.
 func NewTicker(b BackOff) *Ticker {
+	return NewTickerWithTimer(b, &defaultTimer{})
+}
+
+// NewTickerWithTimer returns a new Ticker with a custom timer.
+// A default timer that uses system timer is used when nil is passed.
+func NewTickerWithTimer(b BackOff, timer Timer) *Ticker {
+	if timer == nil {
+		timer = &defaultTimer{}
+	}
 	c := make(chan time.Time)
 	t := &Ticker{
-		C:    c,
-		c:    c,
-		b:    ensureContext(b),
-		stop: make(chan struct{}),
+		C:     c,
+		c:     c,
+		b:     b,
+		ctx:   getContext(b),
+		timer: timer,
+		stop:  make(chan struct{}),
 	}
 	t.b.Reset()
 	go t.run()
@@ -59,7 +73,7 @@ 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():
+		case <-t.ctx.Done():
 			return
 		}
 	}
@@ -78,5 +92,6 @@ func (t *Ticker) send(tick time.Time) <-chan time.Time {
 		return nil
 	}
 
-	return time.After(next)
+	t.timer.Start(next)
+	return t.timer.C()
 }

vendor/github.com/cenkalti/backoff/v4/timer.go

@@ -0,0 +1,35 @@
+package backoff
+
+import "time"
+
+type Timer interface {
+	Start(duration time.Duration)
+	Stop()
+	C() <-chan time.Time
+}
+
+// defaultTimer implements Timer interface using time.Timer
+type defaultTimer struct {
+	timer *time.Timer
+}
+
+// C returns the timers channel which receives the current time when the timer fires.
+func (t *defaultTimer) C() <-chan time.Time {
+	return t.timer.C
+}
+
+// Start starts the timer to fire after the given duration
+func (t *defaultTimer) Start(duration time.Duration) {
+	if t.timer == nil {
+		t.timer = time.NewTimer(duration)
+	} else {
+		t.timer.Reset(duration)
+	}
+}
+
+// Stop is called when the timer is not used anymore and resources may be freed.
+func (t *defaultTimer) Stop() {
+	if t.timer != nil {
+		t.timer.Stop()
+	}
+}

vendor/github.com/cenkalti/backoff/v4/tries.go

@@ -20,6 +20,9 @@ type backOffTries struct {
 }
 
 func (b *backOffTries) NextBackOff() time.Duration {
+	if b.maxTries == 0 {
+		return Stop
+	}
 	if b.maxTries > 0 {
 		if b.maxTries <= b.numTries {
 			return Stop