backoff: github.com/azr/backoff Index | Examples | Files

package backoff

import "github.com/azr/backoff"

Package backoff helps you at backing off !

It was forked from github.com/cenkalti/backoff which is awesome.

This BackOff sleeps upon BackOff() and calculates its next backoff time instead of returning the duration to sleep.

Index

Examples

Package Files

backoff.go exponential.go linear.go

Constants

const (
    DefaultInitialInterval     = 500 * time.Millisecond
    DefaultRandomizationFactor = 0.5
    DefaultMultiplier          = 1.5
    DefaultMaxInterval         = 60 * time.Second
)

Default values for ExponentialBackOff.

type ConstantBackOff Uses

type ConstantBackOff struct {
    Interval time.Duration
}

func NewConstant Uses

func NewConstant(d time.Duration) *ConstantBackOff

func (*ConstantBackOff) BackOff Uses

func (b *ConstantBackOff) BackOff()

func (*ConstantBackOff) Reset Uses

func (b *ConstantBackOff) Reset()

type ExponentialBackOff Uses

type ExponentialBackOff struct {
    InitialInterval time.Duration

    MaxInterval time.Duration

    RandomizationFactor float64
    Multiplier          float64
    // contains filtered or unexported fields
}

ExponentialBackOff is an implementation of BackOff that increases it's back off period for each retry attempt using a randomization function that grows exponentially. Backoff() time is calculated using the following formula:

randomized_interval =
    retry_interval * (random value in range [1 - randomization_factor, 1 + randomization_factor])

In other words BackOff() will sleep for times between the randomization factor percentage below and above the retry interval. For example, using 2 seconds as the base retry interval and 0.5 as the randomization factor, the actual back off period used in the next retry attempt will be between 1 and 3 seconds.

Note: max_interval caps the retry_interval and not the randomized_interval.

Example: The default retry_interval is .5 seconds, default randomization_factor is 0.5, default multiplier is 1.5 and the max_interval is set to 25 seconds. For 12 tries the sequence will sleep (values in seconds) (output from ExampleExpBackOffTimes) :

request#     retry_interval     randomized_interval

1             0.5                [0.25,   0.75]
2             0.75               [0.375,  1.125]
3             1.125              [0.562,  1.687]
4             1.687              [0.8435, 2.53]
5             2.53               [1.265,  3.795]
6             3.795              [1.897,  5.692]
7             5.692              [2.846,  8.538]
8             8.538              [4.269, 12.807]
9            12.807              [6.403, 19.210]
10           19.22               [9.611, 28.833]
11           25                  [12.5,  37.5]
12           25                  [12.5,  37.5]

Implementation is not thread-safe.

func NewExponential Uses

func NewExponential() *ExponentialBackOff

NewExponential creates an instance of ExponentialBackOff using default values.

Code:

exp := backoff.NewExponential()

for i := 0; i < 25; i++ {
    d := exp.GetSleepTime()
    fmt.Printf("Random duration was %2.2fs, interval: %2.2fs in [ %2.2fs , %2.2fs ]\n",
        d.Seconds(),
        exp.Inverval().Seconds(),
        (exp.Inverval() - time.Duration(exp.RandomizationFactor*float64(exp.Inverval()))).Seconds(),
        (exp.Inverval() + time.Duration(exp.RandomizationFactor*float64(exp.Inverval()))).Seconds(),
    )
    exp.IncrementCurrentInterval()
    // exp.BackOff() would have executed time.Sleep(exp.GetSleepTime()) and exp.IncrementCurrentInterval()
}

Output:

Random duration was 0.51s, interval: 0.50s in [ 0.25s , 0.75s ]
Random duration was 0.99s, interval: 0.75s in [ 0.38s , 1.12s ]
Random duration was 0.80s, interval: 1.12s in [ 0.56s , 1.69s ]
Random duration was 1.49s, interval: 1.69s in [ 0.84s , 2.53s ]
Random duration was 2.07s, interval: 2.53s in [ 1.27s , 3.80s ]
Random duration was 3.68s, interval: 3.80s in [ 1.90s , 5.70s ]
Random duration was 4.46s, interval: 5.70s in [ 2.85s , 8.54s ]
Random duration was 6.78s, interval: 8.54s in [ 4.27s , 12.81s ]
Random duration was 15.11s, interval: 12.81s in [ 6.41s , 19.22s ]
Random duration was 13.81s, interval: 19.22s in [ 9.61s , 28.83s ]
Random duration was 20.27s, interval: 28.83s in [ 14.42s , 43.25s ]
Random duration was 37.23s, interval: 43.25s in [ 21.62s , 64.87s ]
Random duration was 64.24s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 81.75s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 47.59s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 47.82s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 75.15s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 42.39s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 81.92s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 71.80s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 61.43s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 31.70s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 39.50s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 66.44s, interval: 60.00s in [ 30.00s , 90.00s ]
Random duration was 88.51s, interval: 60.00s in [ 30.00s , 90.00s ]

func (*ExponentialBackOff) BackOff Uses

func (b *ExponentialBackOff) BackOff()

func (*ExponentialBackOff) GetSleepTime Uses

func (b *ExponentialBackOff) GetSleepTime() time.Duration

func (*ExponentialBackOff) IncrementCurrentInterval Uses

func (b *ExponentialBackOff) IncrementCurrentInterval()

Increments the current interval by multiplying it with the multiplier.

func (*ExponentialBackOff) Inverval Uses

func (b *ExponentialBackOff) Inverval() time.Duration

func (*ExponentialBackOff) Reset Uses

func (b *ExponentialBackOff) Reset()

Reset the interval back to the initial retry interval and restarts the timer.

type Interface Uses

type Interface interface {
    // Example usage:
    //
    //   for ;; {
    //       err, canRetry := somethingThatCanFail()
    //       if err != nil && canRetry {
    //           backoffer.Backoff()
    //       }
    //   }
    BackOff()

    // Reset to initial state.
    Reset()
}

Interface interface to use after a retryable operation failed. A Interface.BackOff sleeps.

type LinearBackOff Uses

type LinearBackOff struct {
    InitialInterval time.Duration
    Multiplier      float64
    Increment       time.Duration
    MaxInterval     time.Duration
    // contains filtered or unexported fields
}

grows linearly until

func NewLinear Uses

func NewLinear(from, to, incr time.Duration, mult float64) *LinearBackOff

func (*LinearBackOff) BackOff Uses

func (lb *LinearBackOff) BackOff()

func (*LinearBackOff) Reset Uses

func (lb *LinearBackOff) Reset()

type ZeroBackOff Uses

type ZeroBackOff struct{}

ZeroBackOff is a fixed back-off policy whose back-off time is always zero, meaning that the operation is retried immediately without waiting.

func (*ZeroBackOff) BackOff Uses

func (b *ZeroBackOff) BackOff()

func (*ZeroBackOff) Reset Uses

func (b *ZeroBackOff) Reset()

Package backoff imports 2 packages (graph) and is imported by 30 packages. Updated 2016-07-29. Refresh now. Tools for package owners.