goback: github.com/carlescere/goback Index | Files

package goback

import "github.com/carlescere/goback"

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

Package Files

goback.go

Variables

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

func After Uses

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 Uses

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 Uses

func Wait(b Backoff) error

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

type Backoff Uses

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 Uses

type JitterBackoff SimpleBackoff

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

func (*JitterBackoff) NextAttempt Uses

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

NextAttempt returns the duration to wait for the next retry.

type SimpleBackoff Uses

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 Uses

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

NextAttempt returns the duration to wait for the next retry.

func (*SimpleBackoff) Reset Uses

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).

Package goback imports 4 packages (graph) and is imported by 2 packages. Updated 2016-07-16. Refresh now. Tools for package owners.