gobreaker

README

Close       闭路，可运行
HalfOpen    半开路，可运行少量请求
Open        开路，不可运行

Close当满足自定义开路条件时就Open
Open当过去一定时间时变成HalfOpen
HalfOpen满足自定义闭路条件时Close，否则Open

断路器分为统计和控制两部分
简单的使用断路器时两部分一起使用，例如服务降级？

当结合负载均衡器时，状态作为通知发送给负载均衡器
负载均衡器来决定配给的流量，当不配流量时就是开路了

所以Open=>HalfOpen的状态是go协程辅助的（可能作为一个选项）

TODO:
目前访问断路器锁粒度太大，可以只给状态加写锁

Documentation

Index

• Variables
• type CircuitBreaker
  • func NewCircuitBreaker(st Settings) *CircuitBreaker
  • func (cb *CircuitBreaker) Execute(req func() (interface{}, error)) (interface{}, error)
  • func (cb *CircuitBreaker) Name() string
  • func (cb *CircuitBreaker) State() State
• type Counts
• type Settings
• type State
  • func (s State) String() string

Variables

var (
	// ErrTooManyRequests is returned when the CB state is half open and the requests count is over the cb maxRequests
	ErrTooManyRequests = errors.New("too many requests")
	// ErrOpenState is returned when the CB state is open
	ErrOpenState = errors.New("circuit breaker is open")
)

Types

type CircuitBreaker

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

CircuitBreaker is a state machine to prevent sending requests that are likely to fail.

func NewCircuitBreaker

func NewCircuitBreaker(st Settings) *CircuitBreaker

NewCircuitBreaker returns a new CircuitBreaker configured with the given Settings.

func (*CircuitBreaker) Execute

func (cb *CircuitBreaker) Execute(req func() (interface{}, error)) (interface{}, error)

Execute runs the given request if the CircuitBreaker accepts it. Execute returns an error instantly if the CircuitBreaker rejects the request. Otherwise, Execute returns the result of the request. If a panic occurs in the request, the CircuitBreaker handles it as an error and causes the same panic again.

func (*CircuitBreaker) Name

func (cb *CircuitBreaker) Name() string

Name returns the name of the CircuitBreaker.

func (*CircuitBreaker) State

func (cb *CircuitBreaker) State() State

State returns the current state of the CircuitBreaker.

type Counts

type Counts struct {
	Requests             uint32
	TotalSuccesses       uint32
	TotalFailures        uint32
	ConsecutiveSuccesses uint32
	ConsecutiveFailures  uint32
}

Counts holds the numbers of requests and their successes/failures. CircuitBreaker clears the internal Counts either on the change of the state or at the closed-state intervals. Counts ignores the results of the requests sent before clearing.

type Settings

type Settings struct {
	Name          string
	MaxRequests   uint32
	Interval      time.Duration
	Timeout       time.Duration
	ReadyToTrip   func(counts Counts) bool
	OnStateChange func(name string, from State, to State)
}

Settings configures CircuitBreaker:

Name is the name of the CircuitBreaker.

MaxRequests is the maximum number of requests allowed to pass through when the CircuitBreaker is half-open. If MaxRequests is 0, the CircuitBreaker allows only 1 request.

Interval is the cyclic period of the closed state for the CircuitBreaker to clear the internal Counts. If Interval is 0, the CircuitBreaker doesn't clear internal Counts during the closed state.

Timeout is the period of the open state, after which the state of the CircuitBreaker becomes half-open. If Timeout is 0, the timeout value of the CircuitBreaker is set to 60 seconds.

ReadyToTrip is called with a copy of Counts whenever a request fails in the closed state. If ReadyToTrip returns true, the CircuitBreaker will be placed into the open state. If ReadyToTrip is nil, default ReadyToTrip is used. Default ReadyToTrip returns true when the number of consecutive failures is more than 5.

OnStateChange is called whenever the state of the CircuitBreaker changes.

type State

type State int

State is a type that represents a state of CircuitBreaker.

const (
	StateClosed State = iota
	StateHalfOpen
	StateOpen
)

These constants are states of CircuitBreaker.

func (State) String

func (s State) String() string

String implements stringer interface.