package backoff

Import Path
	github.com/cenkalti/backoff/v4 (on go.dev)

Dependency Relation
	imports 5 packages, and imported by 3 packages


Involved Source Files

	
		Package backoff implements backoff algorithms for retrying operations.
		
		Use Retry function for retrying operations that may fail.
		If Retry does not meet your needs,
		copy/paste the function into your project and modify as you wish.
		
		There is also Ticker type similar to time.Ticker.
		You can use it if you need to work with channels.
		
		See Examples section below for usage examples.

	    context.go
	    exponential.go
	    retry.go
	    ticker.go
	    timer.go
	    tries.go


Code Examples

	
	  {
	  
	  	operation := func() error {
	  		return nil
	  	}
	  
	  	err := Retry(operation, NewExponentialBackOff())
	  	if err != nil {
	  
	  		return
	  	}
	  
	  }
	
	  {
	  
	  	ctx := context.Background()
	  
	  	operation := func() error {
	  		return nil
	  	}
	  
	  	b := WithContext(NewExponentialBackOff(), ctx)
	  
	  	err := Retry(operation, b)
	  	if err != nil {
	  
	  		return
	  	}
	  
	  }
	
	  {
	  
	  	operation := func() error {
	  		return nil
	  	}
	  
	  	ticker := NewTicker(NewExponentialBackOff())
	  
	  	var err error
	  
	  	for range ticker.C {
	  		if err = operation(); err != nil {
	  			log.Println(err, "will retry...")
	  			continue
	  		}
	  
	  		ticker.Stop()
	  		break
	  	}
	  
	  	if err != nil {
	  
	  		return
	  	}
	  
	  }



Package-Level Type Names (total 17, in which 13 are exported)


	/* sort exporteds by:  |  */
	
		BackOff is a backoff policy for retrying an operation.

		
			
				NextBackOff returns the duration to wait before retrying the operation,
				or backoff. Stop to indicate that no more retries should be made.
				
				Example usage:
				
					duration := backoff.NextBackOff();
					if (duration == backoff.Stop) {
						// Do not retry operation.
					} else {
						// Sleep for duration and retry operation.
					}

			
				Reset to initial state.

		
			 BackOffContext (interface)
			*ConstantBackOff
			*ExponentialBackOff
			*StopBackOff
			*ZeroBackOff
			
		
			func WithMaxRetries(b BackOff, max uint64) BackOff
			func github.com/gotd/td/internal/tdsync.SyncBackoff(from BackOff) BackOff
		
			func NewTicker(b BackOff) *Ticker
			func NewTickerWithTimer(b BackOff, timer Timer) *Ticker
			func Retry(o Operation, b BackOff) error
			func RetryNotify(operation Operation, b BackOff, notify Notify) error
			func RetryNotifyWithData[T](operation OperationWithData[T], b BackOff, notify Notify) (T, error)
			func RetryNotifyWithTimer(operation Operation, b BackOff, notify Notify, t Timer) error
			func RetryNotifyWithTimerAndData[T](operation OperationWithData[T], b BackOff, notify Notify, t Timer) (T, error)
			func RetryWithData[T](o OperationWithData[T], b BackOff) (T, error)
			func WithContext(b BackOff, ctx context.Context) BackOffContext
			func WithMaxRetries(b BackOff, max uint64) BackOff
			func github.com/gotd/td/internal/tdsync.SyncBackoff(from BackOff) BackOff
			


	
		BackOffContext is a backoff policy that stops retrying after the context
		is canceled.

		
			( BackOffContext) Context() context.Context
			
				NextBackOff returns the duration to wait before retrying the operation,
				or backoff. Stop to indicate that no more retries should be made.
				
				Example usage:
				
					duration := backoff.NextBackOff();
					if (duration == backoff.Stop) {
						// Do not retry operation.
					} else {
						// Sleep for duration and retry operation.
					}

			
				Reset to initial state.

		
			
		
			 BackOffContext : BackOff
		
			func WithContext(b BackOff, ctx context.Context) BackOffContext


	
		Clock is an interface that returns current time for BackOff.

		
			( Clock) Now() time.Time
		
			*github.com/gotd/neo.Time
			 github.com/gotd/td/clock.Clock (interface)
			 go.uber.org/zap/zapcore.Clock (interface)
			


	
		ConstantBackOff is a backoff policy that always returns the same backoff delay.
		This is in contrast to an exponential backoff policy,
		which returns a delay that grows longer as you call NextBackOff() over and over again.

		
			Interval time.Duration
		
			(*ConstantBackOff) NextBackOff() time.Duration
			(*ConstantBackOff) Reset()
		
			*ConstantBackOff : BackOff
		
			func NewConstantBackOff(d time.Duration) *ConstantBackOff


	
		ExponentialBackOff is a backoff implementation that increases the backoff
		period for each retry attempt using a randomization function that grows exponentially.
		
		NextBackOff() is calculated using the following formula:
		
		 randomized interval =
		     RetryInterval * (random value in range [1 - RandomizationFactor, 1 + RandomizationFactor])
		
		In other words NextBackOff() will range between the randomization factor
		percentage below and above the retry interval.
		
		For example, given the following parameters:
		
		 RetryInterval = 2
		 RandomizationFactor = 0.5
		 Multiplier = 2
		
		the actual backoff period used in the next retry attempt will range between 1 and 3 seconds,
		multiplied by the exponential, that is, between 2 and 6 seconds.
		
		Note: MaxInterval caps the RetryInterval and not the randomized interval.
		
		If the time elapsed since an ExponentialBackOff instance is created goes past the
		MaxElapsedTime, then the method NextBackOff() starts returning backoff.Stop.
		
		The elapsed time can be reset by calling Reset().
		
		Example: Given the following default arguments, for 10 tries the sequence will be,
		and assuming we go over the MaxElapsedTime on the 10th try:
		
		 Request #  RetryInterval (seconds)  Randomized Interval (seconds)
		
		  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.210                   backoff.Stop
		
		Note: Implementation is not thread-safe.

		
			Clock Clock
			InitialInterval time.Duration
			
				After MaxElapsedTime the ExponentialBackOff returns Stop.
				It never stops if MaxElapsedTime == 0.

			MaxInterval time.Duration
			Multiplier float64
			RandomizationFactor float64
			Stop time.Duration
			
		
			
				GetElapsedTime returns the elapsed time since an ExponentialBackOff instance
				is created and is reset when Reset() is called.
				
				The elapsed time is computed using time.Now().UnixNano(). It is
				safe to call even while the backoff policy is used by a running
				ticker.

			
				NextBackOff calculates the next backoff interval using the formula:
					Randomized interval = RetryInterval * (1 ± RandomizationFactor)

			
				Reset the interval back to the initial retry interval and restarts the timer.
				Reset must be called before using b.

			
		
			*ExponentialBackOff : BackOff
		
			func NewExponentialBackOff() *ExponentialBackOff


	
		Notify is a notify-on-error function. It receives an operation error and
		backoff delay if the operation failed (with an error).
		
		NOTE that if the backoff policy stated to stop retrying,
		the notify function isn't called.

		
			func RetryNotify(operation Operation, b BackOff, notify Notify) error
			func RetryNotifyWithData[T](operation OperationWithData[T], b BackOff, notify Notify) (T, error)
			func RetryNotifyWithTimer(operation Operation, b BackOff, notify Notify, t Timer) error
			func RetryNotifyWithTimerAndData[T](operation OperationWithData[T], b BackOff, notify Notify, t Timer) (T, error)
			


	
		An Operation is executing by Retry() or RetryNotify().
		The operation will be retried using a backoff policy if it returns an error.

		
			
		
			func Retry(o Operation, b BackOff) error
			func RetryNotify(operation Operation, b BackOff, notify Notify) error
			func RetryNotifyWithTimer(operation Operation, b BackOff, notify Notify, t Timer) error


	

		Type Parameters:
			T: any

		An OperationWithData is executing by RetryWithData() or RetryNotifyWithData().
		The operation will be retried using a backoff policy if it returns an error.

		
			
		
			func RetryNotifyWithData[T](operation OperationWithData[T], b BackOff, notify Notify) (T, error)
			func RetryNotifyWithTimerAndData[T](operation OperationWithData[T], b BackOff, notify Notify, t Timer) (T, error)
			func RetryWithData[T](o OperationWithData[T], b BackOff) (T, error)
			


	
		PermanentError signals that the operation should not be retried.

		
			Err error
		
			(*PermanentError) Error() string
			(*PermanentError) Is(target error) bool
			(*PermanentError) Unwrap() error
		
			*PermanentError : github.com/go-faster/errors.Wrapper
			*PermanentError : error


	
		StopBackOff is a fixed backoff policy that always returns backoff.Stop for
		NextBackOff(), meaning that the operation should never be retried.

		
			(*StopBackOff) NextBackOff() time.Duration
			(*StopBackOff) Reset()
		
			*StopBackOff : BackOff


	
		Ticker holds a channel that delivers `ticks' of a clock at times reported by a BackOff.
		
		Ticks will continue to arrive when the previous operation is still running,
		so operations that take a while to fail could run in quick succession.

		
			C <-chan time.Time
			
		
			
				Stop turns off a ticker. After Stop, no more ticks will be sent.

			
		
			func NewTicker(b BackOff) *Ticker
			func NewTickerWithTimer(b BackOff, timer Timer) *Ticker


	

		
			( Timer) C() <-chan time.Time
			( Timer) Start(duration time.Duration)
			( Timer) Stop()
		
			
		
			func NewTickerWithTimer(b BackOff, timer Timer) *Ticker
			func RetryNotifyWithTimer(operation Operation, b BackOff, notify Notify, t Timer) error
			func RetryNotifyWithTimerAndData[T](operation OperationWithData[T], b BackOff, notify Notify, t Timer) (T, error)
			


	
		ZeroBackOff is a fixed backoff policy whose backoff time is always zero,
		meaning that the operation is retried immediately without waiting, indefinitely.

		
			(*ZeroBackOff) NextBackOff() time.Duration
			(*ZeroBackOff) Reset()
		
			*ZeroBackOff : BackOff


	


Package-Level Functions (total 16, in which 13 are exported)


	
		NewExponentialBackOff creates an instance of ExponentialBackOff using default values.


	
		NewTicker returns a new Ticker containing a channel that will send
		the time at times specified by the BackOff argument. Ticker is
		guaranteed to tick at least once.  The channel is closed when Stop
		method is called or BackOff stops. It is not safe to manipulate the
		provided backoff policy (notably calling NextBackOff or Reset)
		while the ticker is running.


	
		NewTickerWithTimer returns a new Ticker with a custom timer.
		A default timer that uses system timer is used when nil is passed.


	
		Permanent wraps the given err in a *PermanentError.


	
		Retry the operation o until it does not return error or BackOff stops.
		o is guaranteed to be run at least once.
		
		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.


	
		RetryNotify calls notify function with the error and wait duration
		for each failed attempt before sleep.


	

		Type Parameters:
			T: any

		RetryNotifyWithData is like RetryNotify but returns data in the response too.


	
		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.


	

		Type Parameters:
			T: any

		RetryNotifyWithTimerAndData is like RetryNotifyWithTimer but returns data in the response too.


	

		Type Parameters:
			T: any

		RetryWithData is like Retry but returns data in the response too.


	
		WithContext returns a BackOffContext with context ctx
		
		ctx must not be nil


	
		WithMaxRetries creates a wrapper around another BackOff, which will
		return Stop if NextBackOff() has been called too many times since
		the last time Reset() was called
		
		Note: Implementation is not thread-safe.


	


Package-Level Variables (only one, which is exported)


	
		SystemClock implements Clock interface that uses time.Now().




Package-Level Constants (total 6, all are exported)


	
		Default values for ExponentialBackOff.


	
		Default values for ExponentialBackOff.


	
		Default values for ExponentialBackOff.


	
		Default values for ExponentialBackOff.


	
		Default values for ExponentialBackOff.


	
		Stop indicates that no more retries should be made for use in NextBackOff().