circuitbreaker

Documentation

Index

• func ClearRules() error
• func LoadRules(rules []Rule) (bool, error)
• func RegisterStateChangeListeners(listeners ...StateChangeListener)
• func RemoveCircuitBreakerGenerator(s Strategy) error
• func SetCircuitBreakerGenerator(s Strategy, generator CircuitBreakerGenFunc) error
• type CircuitBreaker
• type CircuitBreakerGenFunc
• type MetricStatSlot
  • func (c *MetricStatSlot) OnCompleted(ctx *base.EntryContext)
  • func (c *MetricStatSlot) OnEntryBlocked(_ *base.EntryContext, _ *base.BlockError)
  • func (c *MetricStatSlot) OnEntryPassed(_ *base.EntryContext)
• type Rule
  • func GetResRules(resource string) []Rule
  • func NewRule(resource string, strategy Strategy, opts ...RuleOption) Rule
• type RuleBase
  • func (b *RuleBase) BreakerStatIntervalMs() uint32
  • func (b *RuleBase) BreakerStrategy() Strategy
  • func (b *RuleBase) IsApplicable() error
  • func (b *RuleBase) IsStatReusable(r Rule) bool
  • func (b *RuleBase) ResourceName() string
  • func (b *RuleBase) String() string
• type RuleOption
  • func WithErrorCountThreshold(errorCountThreshold uint64) RuleOption
  • func WithErrorRatioThreshold(errorRatioThreshold float64) RuleOption
  • func WithMaxAllowedRtMs(maxAllowedRtMs uint64) RuleOption
  • func WithMaxSlowRequestRatio(maxSlowRequestRatio float64) RuleOption
  • func WithMinRequestAmount(minRequestAmount uint64) RuleOption
  • func WithRetryTimeoutMs(retryTimeoutMs uint32) RuleOption
  • func WithStatIntervalMs(statIntervalMs uint32) RuleOption
• type RuleOptions
• type Slot
  • func (b *Slot) Check(ctx *base.EntryContext) *base.TokenResult
• type State
  • func (s *State) String() string
• type StateChangeListener
• type Strategy
  • func (s Strategy) String() string

Functions

func ClearRules

func ClearRules() error

ClearRules clear all the previous rules.

func LoadRules

func LoadRules(rules []Rule) (bool, error)

LoadRules replaces old rules with the given circuit breaking rules.

return value:

bool: was designed to indicate whether the internal map has been changed error: was designed to indicate whether occurs the error.

func RegisterStateChangeListeners

func RegisterStateChangeListeners(listeners ...StateChangeListener)

func RemoveCircuitBreakerGenerator

func RemoveCircuitBreakerGenerator(s Strategy) error

func SetCircuitBreakerGenerator

func SetCircuitBreakerGenerator(s Strategy, generator CircuitBreakerGenFunc) error

SetCircuitBreakerGenerator sets the circuit breaker generator for the given strategy. Note that modifying the generator of default strategies is not allowed.

Types

type CircuitBreaker

type CircuitBreaker interface {
	// BoundRule returns the associated circuit breaking rule.
	BoundRule() Rule
	// BoundStat returns the associated statistic data structure.
	BoundStat() interface{}
	// TryPass acquires permission of an invocation only if it is available at the time of invocation.
	TryPass(ctx *base.EntryContext) bool
	// CurrentState returns current state of the circuit breaker.
	CurrentState() State
	// OnRequestComplete record a completed request with the given response time as well as error (if present),
	// and handle state transformation of the circuit breaker.
	OnRequestComplete(rtt uint64, err error)
}

CircuitBreaker is the basic interface of circuit breaker

type CircuitBreakerGenFunc

type CircuitBreakerGenFunc func(r Rule, reuseStat interface{}) CircuitBreaker

type MetricStatSlot

type MetricStatSlot struct {
}

MetricStatSlot records metrics for circuit breaker on invocation completed. MetricStatSlot must be filled into slot chain if circuit breaker is alive.

func (*MetricStatSlot) OnCompleted

func (c *MetricStatSlot) OnCompleted(ctx *base.EntryContext)

func (*MetricStatSlot) OnEntryBlocked

func (c *MetricStatSlot) OnEntryBlocked(_ *base.EntryContext, _ *base.BlockError)

func (*MetricStatSlot) OnEntryPassed

func (c *MetricStatSlot) OnEntryPassed(_ *base.EntryContext)

type Rule

type Rule interface {
	base.SentinelRule
	// BreakerStrategy returns the circuit breaker strategy.
	BreakerStrategy() Strategy
	// IsApplicable checks whether the rule is valid and could be converted to a corresponding circuit breaker.
	IsApplicable() error
	// BreakerStatIntervalMs returns the statistic interval of circuit breaker (in milliseconds).
	BreakerStatIntervalMs() uint32
	// IsEqualsTo checks whether current rule is equal to the given rule.
	IsEqualsTo(r Rule) bool
	// IsStatReusable checks whether current rule is "statistically" equal to the given rule.
	IsStatReusable(r Rule) bool
}

Rule is the base interface of the circuit breaker rule.

func GetResRules

func GetResRules(resource string) []Rule

func NewRule

func NewRule(resource string, strategy Strategy, opts ...RuleOption) Rule

type RuleBase

type RuleBase struct {
	// unique id
	Id string
	// resource name
	Resource string
	Strategy Strategy
	// RetryTimeoutMs represents recovery timeout (in milliseconds) before the circuit breaker opens.
	// During the open period, no requests are permitted until the timeout has elapsed.
	// After that, the circuit breaker will transform to half-open state for trying a few "trial" requests.
	RetryTimeoutMs uint32
	// MinRequestAmount represents the minimum number of requests (in an active statistic time span)
	// that can trigger circuit breaking.
	MinRequestAmount uint64
	// StatIntervalMs represents statistic time interval of the internal circuit breaker (in ms).
	StatIntervalMs uint32
}

RuleBase encompasses the common fields of circuit breaking rule.

func (*RuleBase) BreakerStatIntervalMs

func (b *RuleBase) BreakerStatIntervalMs() uint32

func (*RuleBase) BreakerStrategy

func (b *RuleBase) BreakerStrategy() Strategy

func (*RuleBase) IsApplicable

func (b *RuleBase) IsApplicable() error

func (*RuleBase) IsStatReusable

func (b *RuleBase) IsStatReusable(r Rule) bool

func (*RuleBase) ResourceName

func (b *RuleBase) ResourceName() string

func (*RuleBase) String

func (b *RuleBase) String() string

type RuleOption

type RuleOption func(opts *RuleOptions)

func WithErrorCountThreshold

func WithErrorCountThreshold(errorCountThreshold uint64) RuleOption

WithErrorCountThreshold sets the errorCountThreshold This function only takes effect for errorCountRule

func WithErrorRatioThreshold

func WithErrorRatioThreshold(errorRatioThreshold float64) RuleOption

WithErrorRatioThreshold sets the errorRatioThreshold This function only takes effect for errorRatioRule

func WithMaxAllowedRtMs

func WithMaxAllowedRtMs(maxAllowedRtMs uint64) RuleOption

WithMaxAllowedRtMs sets the maxAllowedRtMs This function only takes effect for slowRtRule

func WithMaxSlowRequestRatio

func WithMaxSlowRequestRatio(maxSlowRequestRatio float64) RuleOption

WithMaxSlowRequestRatio sets the maxSlowRequestRatio This function only takes effect for slowRtRule

func WithMinRequestAmount

func WithMinRequestAmount(minRequestAmount uint64) RuleOption

WithMinRequestAmount sets the minRequestAmount This function takes effect for all circuit breaker rule

func WithRetryTimeoutMs

func WithRetryTimeoutMs(retryTimeoutMs uint32) RuleOption

WithRetryTimeoutMs sets the retryTimeoutMs This function takes effect for all circuit breaker rule

func WithStatIntervalMs

func WithStatIntervalMs(statIntervalMs uint32) RuleOption

WithStatIntervalMs sets the statIntervalMs This function takes effect for all circuit breaker rule

type RuleOptions

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

type Slot

type Slot struct {
}

func (*Slot) Check

func (b *Slot) Check(ctx *base.EntryContext) *base.TokenResult

type State

type State int32

*

Circuit Breaker State Machine:

                               switch to open based on rule
       +-----------------------------------------------------------------------+
       |                                                                       |
       |                                                                       v

+----------------+ +----------------+ Probe +----------------+ | | | |<----------------| | | | Probe succeed | | | | | Closed |<------------------| HalfOpen | | Open | | | | | Probe failed | | | | | +---------------->| | +----------------+ +----------------+ +----------------+

const (
	Closed State = iota
	HalfOpen
	Open
)

func (*State) String

func (s *State) String() string

type StateChangeListener

type StateChangeListener interface {
	// OnTransformToClosed is triggered when circuit breaker state transformed to Closed.
	OnTransformToClosed(prev State, rule Rule)

	// OnTransformToOpen is triggered when circuit breaker state transformed to Open.
	// The "snapshot" indicates the triggered value when the transformation occurs.
	OnTransformToOpen(prev State, rule Rule, snapshot interface{})

	// OnTransformToHalfOpen is triggered when circuit breaker state transformed to HalfOpen.
	OnTransformToHalfOpen(prev State, rule Rule)
}

StateChangeListener listens on the circuit breaker state change event

type Strategy

type Strategy int8

Strategy represents the strategy of circuit breaker. Each strategy is associated with one rule type.

const (
	// SlowRequestRatio strategy changes the circuit breaker state based on slow request ratio
	SlowRequestRatio Strategy = iota
	// ErrorRatio strategy changes the circuit breaker state based on error request ratio
	ErrorRatio
	// ErrorCount strategy changes the circuit breaker state based on error amount
	ErrorCount
)

func (Strategy) String

func (s Strategy) String() string