goback

package module
Version: v0.0.0-...-ebe1050 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 14, 2015 License: MIT Imports: 4 Imported by: 10

README

goback

GoDoc Build Status Coverage Status

Goback implements a simple exponential backoff.

An exponential backoff approach is typically used when treating with potentially faulty/slow systems. If a system fails quick retries may exacerbate the system specially when the system is dealing with several clients. In this case a backoff provides the faulty system enough room to recover.

How to use

func main() {
        b := &goback.SimpleBackoff(
                Min:    100 * time.Millisecond,
                Max:    60 * time.Second,
                Factor: 2,
        )
        goback.Wait(b)           // sleeps 100ms
        goback.Wait(b)           // sleeps 200ms
        goback.Wait(b)           // sleeps 400ms
        fmt.Println(b.NextRun()) // prints 800ms
        b.Reset()                // resets the backoff
        goback.Wait(b)           // sleeps 100ms
}

Furter examples can be found in the examples folder.

Strategies

At the moment there are two backoff strategies implemented.

Simple Backoff

It starts with a minumum duration and multiplies it by the factor until the maximum waiting time is reached. In that case it will return Max.

The optional MaxAttempts will limit the maximum number of retries and will return an error when is exceeded.

Jitter Backoff

The Jitter strategy is based on the simple backoff but adds a light randomisation to minimise collisions between contending clients.

The result of the 'NextDuration()' method will be a random duration between [d-min, d+min] where d is the expected duration without jitter and min is the minimum duration.

Extensibility

By creating structs that implement the methods of the Backoff interface you will be able to use them as a backoff strategy.

A naive example of this is:

type NaiveBackoff struct{}

func (b *NaiveBackoff) NextAttempt() (time.Duration, error) { return time.Second, nil }
func (b *NaiveBackoff) Reset() { }

This will return always a 1s duration.

Credits

This package is inspired in https://github.com/jpillora/backoff

License

Distributed under MIT license. See LICENSE file for more information.

Documentation

Overview

Package goback implements a simple exponential backoff

An exponential backoff approach is typically used when treating with potentially faulty/slow systems. If a system fails quick retries may exacerbate the system specially when the system is dealing with several clients. In this case a backoff provides the faulty system enough room to recover.

Simple example:

 func main() {
	    b := &goback.SimpleBackoff(
		    Min:    100 * time.Millisecond,
		    Max:    60 * time.Second,
		    Factor: 2,
	    )
	    goback.Wait(b)           // sleeps 100ms
	    goback.Wait(b)           // sleeps 200ms
	    goback.Wait(b)           // sleeps 400ms
	    fmt.Println(b.NextRun()) // prints 800ms
	    b.Reset()                // resets the backoff
	    goback.Wait(b)           // sleeps 100ms
 }

Furter examples can be found in the examples folder in the repository.

Index

Constants

This section is empty.

Variables

View Source
var (
	// ErrMaxAttemptsExceeded indicates that the maximum retries has been
	// excedeed. Usually to consider a service unreachable/unavailable.
	ErrMaxAttemptsExceeded = errors.New("maximum of attempts exceeded")
)

Functions

func After

func After(b Backoff) <-chan error

After returns a channel that will be called after the time specified by the backoff strategy or will exit immediately with an error.

func GetNextDuration

func GetNextDuration(min, max time.Duration, factor float64, attempts int) time.Duration

GetNextDuration returns the duration for the strategies considering the minimum and maximum durations, the factor of increase and the number of attemtps tried.

func Wait

func Wait(b Backoff) error

Wait sleeps for the duration of the time specified by the backoff strategy.

Types

type Backoff

type Backoff interface {
	// NextAttempt returns the duration to wait for the next retry.
	NextAttempt() (time.Duration, error)
	// Reset clears the number of tries. Next call to NextAttempt will return
	// the minimum backoff time (if there is no error).
	Reset()
}

Backoff is the interface that any Backoff strategy needs to implement.

type JitterBackoff

type JitterBackoff SimpleBackoff

JitterBackoff provides an strategy similar to SimpleBackoff but lightly randomises the duration to minimise collisions between contending clients.

func (*JitterBackoff) NextAttempt

func (b *JitterBackoff) NextAttempt() (time.Duration, error)

NextAttempt returns the duration to wait for the next retry.

type SimpleBackoff

type SimpleBackoff struct {
	Attempts    int
	MaxAttempts int
	Factor      float64
	Min         time.Duration
	Max         time.Duration
}

SimpleBackoff provides a simple strategy to backoff.

func (*SimpleBackoff) NextAttempt

func (b *SimpleBackoff) NextAttempt() (time.Duration, error)

NextAttempt returns the duration to wait for the next retry.

func (*SimpleBackoff) Reset

func (b *SimpleBackoff) Reset()

Reset clears the number of tries. Next call to NextAttempt will return the minimum backoff time (if there is no error).

Source Files

Directories

Path Synopsis
examples

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL