backoff.go raw

   1  // Package backoff implements backoff algorithms for retrying operations.
   2  //
   3  // Use Retry function for retrying operations that may fail.
   4  // If Retry does not meet your needs,
   5  // copy/paste the function into your project and modify as you wish.
   6  //
   7  // There is also Ticker type similar to time.Ticker.
   8  // You can use it if you need to work with channels.
   9  //
  10  // See Examples section below for usage examples.
  11  package backoff
  12  
  13  import "time"
  14  
  15  // BackOff is a backoff policy for retrying an operation.
  16  type BackOff interface {
  17  	// NextBackOff returns the duration to wait before retrying the operation,
  18  	// backoff.Stop to indicate that no more retries should be made.
  19  	//
  20  	// Example usage:
  21  	//
  22  	//     duration := backoff.NextBackOff()
  23  	//     if duration == backoff.Stop {
  24  	//         // Do not retry operation.
  25  	//     } else {
  26  	//         // Sleep for duration and retry operation.
  27  	//     }
  28  	//
  29  	NextBackOff() time.Duration
  30  
  31  	// Reset to initial state.
  32  	Reset()
  33  }
  34  
  35  // Stop indicates that no more retries should be made for use in NextBackOff().
  36  const Stop time.Duration = -1
  37  
  38  // ZeroBackOff is a fixed backoff policy whose backoff time is always zero,
  39  // meaning that the operation is retried immediately without waiting, indefinitely.
  40  type ZeroBackOff struct{}
  41  
  42  func (b *ZeroBackOff) Reset() {}
  43  
  44  func (b *ZeroBackOff) NextBackOff() time.Duration { return 0 }
  45  
  46  // StopBackOff is a fixed backoff policy that always returns backoff.Stop for
  47  // NextBackOff(), meaning that the operation should never be retried.
  48  type StopBackOff struct{}
  49  
  50  func (b *StopBackOff) Reset() {}
  51  
  52  func (b *StopBackOff) NextBackOff() time.Duration { return Stop }
  53  
  54  // ConstantBackOff is a backoff policy that always returns the same backoff delay.
  55  // This is in contrast to an exponential backoff policy,
  56  // which returns a delay that grows longer as you call NextBackOff() over and over again.
  57  type ConstantBackOff struct {
  58  	Interval time.Duration
  59  }
  60  
  61  func (b *ConstantBackOff) Reset()                     {}
  62  func (b *ConstantBackOff) NextBackOff() time.Duration { return b.Interval }
  63  
  64  func NewConstantBackOff(d time.Duration) *ConstantBackOff {
  65  	return &ConstantBackOff{Interval: d}
  66  }
  67