go-sample-webpage/vendor/github.com/lestrrat-go/backoff/v2/options.go
2021-11-04 02:14:51 +01:00

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