gentle

type BackOff interface {
	// Next() should immediately return
	Next() time.Duration
}

type BackOffFactory interface {
	NewBackOff() BackOff
}

type BulkheadHandlerOpts struct {
	MaxConcurrency int
	// contains filtered or unexported fields
}

type BulkheadStreamOpts struct {
	MaxConcurrency int
	// contains filtered or unexported fields
}

type CircuitBreakerConf struct {
	// Timeout is how long to wait for command to complete
	Timeout time.Duration
	// MaxConcurrent is how many commands of the same type can run
	// at the same time
	MaxConcurrent int
	// VolumeThreshold is the minimum number of requests needed
	// before a circuit can be tripped due to health
	VolumeThreshold int
	// ErrorPercentThreshold causes circuits to open once the
	// rolling measure of errors exceeds this percent of requests
	ErrorPercentThreshold int
	// SleepWindow is how long to wait after a circuit opens before testing
	// for recovery is allowed
	SleepWindow time.Duration
}

type CircuitBreakerHandlerOpts struct {
	MetricCbErr Metric
	Circuit     string
	// contains filtered or unexported fields
}

type CircuitBreakerStreamOpts struct {
	MetricCbErr Metric
	Circuit     string
	// contains filtered or unexported fields
}

type Clock interface {
	Now() time.Time
	Sleep(d time.Duration)
}

type ConstantBackOffFactory struct {
	// contains filtered or unexported fields
}

type ConstantBackOffFactoryOpts struct {
	Interval time.Duration

	// After MaxElapsedTime or MaxNumBackOffs(whichever comes first) the BackOff
	// stops.
	// If both are 0, it never stops backing off.
	// If only one of them is 0, then the other is checked.
	MaxElapsedTime time.Duration
	MaxNumBackOffs int64
	Clock          Clock
}

type ExponentialBackOffFactory struct {
	// contains filtered or unexported fields
}

type ExponentialBackOffFactoryOpts struct {
	// Next() returns a randomizedInterval which is:
	// currentInterval * rand(range [1-RandomizationFactor, 1+RandomizationFactor])
	InitialInterval     time.Duration
	RandomizationFactor float64
	Multiplier          float64

	// If currentInterval * Multiplier >= MaxInterval, then currentInterval = b.MaxInterval
	// Otherwise, currentInterval *= Multiplier
	MaxInterval time.Duration

	// After MaxElapsedTime or MaxNumBackOffs(whichever comes first) the BackOff
	// stops.
	// If both are 0, it never stops backing off.
	// If only one of them is 0, then the other is checked.
	MaxElapsedTime time.Duration
	MaxNumBackOffs int64
	Clock          Clock
}

type Handler interface {
	// Handle() takes a Message as input and then returns either a Message or
	// an error exclusively.
	Handle(msg Message) (Message, error)
}

type HandlerFallback func(Message, error) (Message, error)

type Identity interface {
	GetNames() *Names
}

type Logger interface {
	// Log a message at the given level with key/value pairs. The number of ctx
	// must be a multiple of two(for a key/value pair).
	Debug(msg string, ctx ...interface{})
	Info(msg string, ctx ...interface{})
	Warn(msg string, ctx ...interface{})
	Error(msg string, ctx ...interface{})
	Crit(msg string, ctx ...interface{})
}

type Message interface {
	// ID() returns a unique string that identifies this Message.
	ID() string
}

type Metric interface {
	Observe(value float64, labels map[string]string)
}

type Names struct {
	Namespace  string
	Resilience string
	Name       string
}

type Observation interface {
	//Metric
	Observe(value float64, labels map[string]string)
}

type RateLimit interface {
	// Wait for $count tokens to be granted(return true) or timeout(return
	// false). If $timeout == 0, it would block as long as it needs.
	Wait(count int, timeout time.Duration) bool
}

type RateLimitedHandlerOpts struct {
	Limiter RateLimit
	// contains filtered or unexported fields
}

type RateLimitedStreamOpts struct {
	Limiter RateLimit
	// contains filtered or unexported fields
}

type RegistryKey struct {
	Namespace, Resilience, Name, Mx string
}

type RetryHandlerOpts struct {
	MetricTryNum   Metric
	Clock          Clock
	BackOffFactory BackOffFactory
	// contains filtered or unexported fields
}

type RetryStreamOpts struct {
	MetricTryNum   Metric
	Clock          Clock
	BackOffFactory BackOffFactory
	// contains filtered or unexported fields
}

type SimpleHandler func(Message) (Message, error)

type SimpleStream func() (Message, error)

type Stream interface {
	// Get() returns either a Message or an error exclusively.
	Get() (Message, error)
}

type StreamFallback func(error) (Message, error)

type TokenBucketRateLimit struct {
	// contains filtered or unexported fields
}