127 lines
3.8 KiB
Go
127 lines
3.8 KiB
Go
package backoff
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/lestrrat-go/option"
|
|
)
|
|
|
|
type identInterval struct{}
|
|
type identJitterFactor struct{}
|
|
type identMaxInterval struct{}
|
|
type identMaxRetries struct{}
|
|
type identMinInterval struct{}
|
|
type identMultiplier struct{}
|
|
type identRNG struct{}
|
|
|
|
// ControllerOption is an option that may be passed to Policy objects,
|
|
// but are ultimately passed down to the Controller objects.
|
|
// (Normally you do not have to care about the distinction)
|
|
type ControllerOption interface {
|
|
ConstantOption
|
|
ExponentialOption
|
|
CommonOption
|
|
controllerOption()
|
|
}
|
|
|
|
type controllerOption struct {
|
|
Option
|
|
}
|
|
|
|
func (*controllerOption) exponentialOption() {}
|
|
func (*controllerOption) controllerOption() {}
|
|
func (*controllerOption) constantOption() {}
|
|
|
|
// ConstantOption is an option that is used by the Constant policy.
|
|
type ConstantOption interface {
|
|
Option
|
|
constantOption()
|
|
}
|
|
|
|
type constantOption struct {
|
|
Option
|
|
}
|
|
|
|
func (*constantOption) constantOption() {}
|
|
|
|
// ExponentialOption is an option that is used by the Exponential policy.
|
|
type ExponentialOption interface {
|
|
Option
|
|
exponentialOption()
|
|
}
|
|
|
|
type exponentialOption struct {
|
|
Option
|
|
}
|
|
|
|
func (*exponentialOption) exponentialOption() {}
|
|
|
|
// CommonOption is an option that can be passed to any of the backoff policies.
|
|
type CommonOption interface {
|
|
ExponentialOption
|
|
ConstantOption
|
|
}
|
|
|
|
type commonOption struct {
|
|
Option
|
|
}
|
|
|
|
func (*commonOption) constantOption() {}
|
|
func (*commonOption) exponentialOption() {}
|
|
|
|
// WithMaxRetries specifies the maximum number of attempts that can be made
|
|
// by the backoff policies. By default each policy tries up to 10 times.
|
|
//
|
|
// If you would like to retry forever, specify "0" and pass to the constructor
|
|
// of each policy.
|
|
//
|
|
// This option can be passed to all policy constructors except for NullPolicy
|
|
func WithMaxRetries(v int) ControllerOption {
|
|
return &controllerOption{option.New(identMaxRetries{}, v)}
|
|
}
|
|
|
|
// WithInterval specifies the constant interval used in ConstantPolicy and
|
|
// ConstantInterval.
|
|
// The default value is 1 minute.
|
|
func WithInterval(v time.Duration) ConstantOption {
|
|
return &constantOption{option.New(identInterval{}, v)}
|
|
}
|
|
|
|
// WithMaxInterval specifies the maximum duration used in exponential backoff
|
|
// The default value is 1 minute.
|
|
func WithMaxInterval(v time.Duration) ExponentialOption {
|
|
return &exponentialOption{option.New(identMaxInterval{}, v)}
|
|
}
|
|
|
|
// WithMinInterval specifies the minimum duration used in exponential backoff.
|
|
// The default value is 500ms.
|
|
func WithMinInterval(v time.Duration) ExponentialOption {
|
|
return &exponentialOption{option.New(identMinInterval{}, v)}
|
|
}
|
|
|
|
// WithMultiplier specifies the factor in which the backoff intervals are
|
|
// increased. By default this value is set to 1.5, which means that for
|
|
// every iteration a 50% increase in the interval for every iteration
|
|
// (up to the value specified by WithMaxInterval). this value must be greater
|
|
// than 1.0. If the value is less than equal to 1.0, the default value
|
|
// of 1.5 is used.
|
|
func WithMultiplier(v float64) ExponentialOption {
|
|
return &exponentialOption{option.New(identMultiplier{}, v)}
|
|
}
|
|
|
|
// WithJitterFactor enables some randomness (jittering) in the computation of
|
|
// the backoff intervals. This value must be between 0.0 < v < 1.0. If a
|
|
// value outside of this range is specified, the value will be silently
|
|
// ignored and jittering is disabled.
|
|
//
|
|
// This option can be passed to ExponentialPolicy or ConstantPolicy constructor
|
|
func WithJitterFactor(v float64) CommonOption {
|
|
return &commonOption{option.New(identJitterFactor{}, v)}
|
|
}
|
|
|
|
// WithRNG specifies the random number generator used for jittering.
|
|
// If not provided one will be created, but if you want a truly random
|
|
// jittering, make sure to provide one that you explicitly initialized
|
|
func WithRNG(v Random) CommonOption {
|
|
return &commonOption{option.New(identRNG{}, v)}
|
|
}
|