alibaba
diff --git a/‎core/circuitbreaker/circuit_breaker.go
Copy file name to clipboard
+36-31Lines changed: 36 additions & 31 deletions b/‎core/circuitbreaker/circuit_breaker.go
Copy file name to clipboard
+36-31Lines changed: 36 additions & 31 deletions
diff --git a/‎core/circuitbreaker/circuit_breaker_test.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎core/circuitbreaker/circuit_breaker_test.go
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
@@ -10,21 +10,20 @@ import (
 	"github.com/alibaba/sentinel-golang/util"
 )
 
-/**
-  Circuit Breaker State Machine:
-
-                                 switch to open based on rule
-         +-----------------------------------------------------------------------+
-         |                                                                       |
-         |                                                                       v
-+----------------+                   +----------------+      Probe      +----------------+
-|                |                   |                |<----------------|                |
-|                |   Probe succeed   |                |                 |                |
-|     Closed     |<------------------|    HalfOpen    |                 |      Open      |
-|                |                   |                |   Probe failed  |                |
-|                |                   |                +---------------->|                |
-+----------------+                   +----------------+                 +----------------+
-*/
+//
+//  Circuit Breaker State Machine:
+//
+//                                 switch to open based on rule
+//				+-----------------------------------------------------------------------+
+//				|                                                                       |
+//				|                                                                       v
+//		+----------------+                   +----------------+      Probe      +----------------+
+//		|                |                   |                |<----------------|                |
+//		|                |   Probe succeed   |                |                 |                |
+//		|     Closed     |<------------------|    HalfOpen    |                 |      Open      |
+//		|                |                   |                |   Probe failed  |                |
+//		|                |                   |                +---------------->|                |
+//		+----------------+                   +----------------+                 +----------------+
 type State int32
 
 const (
@@ -67,20 +66,26 @@ func (s *State) casState(expect State, update State) bool {
 // StateChangeListener listens on the circuit breaker state change event
 type StateChangeListener interface {
 	// OnTransformToClosed is triggered when circuit breaker state transformed to Closed.
+	// Argument rule is copy from circuit breaker's rule, any changes of rule don't take effect for circuit breaker
+	// Copying rule has a performance penalty and avoids invalid listeners as much as possible
 	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.
+	// Argument rule is copy from circuit breaker's rule, any changes of rule don't take effect for circuit breaker
+	// Copying rule has a performance penalty and avoids invalid listeners as much as possible
 	OnTransformToOpen(prev State, rule Rule, snapshot interface{})
 
 	// OnTransformToHalfOpen is triggered when circuit breaker state transformed to HalfOpen.
+	// Argument rule is copy from circuit breaker's rule, any changes of rule don't take effect for circuit breaker
+	// Copying rule has a performance penalty and avoids invalid listeners as much as possible
 	OnTransformToHalfOpen(prev State, rule Rule)
 }
 
 // CircuitBreaker is the basic interface of circuit breaker
 type CircuitBreaker interface {
 	// BoundRule returns the associated circuit breaking rule.
-	BoundRule() 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.
@@ -96,7 +101,7 @@ type CircuitBreaker interface {
 //================================= circuitBreakerBase ====================================
 // circuitBreakerBase encompasses the common fields of circuit breaker.
 type circuitBreakerBase struct {
-	rule Rule
+	rule *Rule
 	// 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.
@@ -107,7 +112,7 @@ type circuitBreakerBase struct {
 	state *State
 }
 
-func (b *circuitBreakerBase) BoundRule() Rule {
+func (b *circuitBreakerBase) BoundRule() *Rule {
 	return b.rule
 }
 
@@ -129,7 +134,7 @@ func (b *circuitBreakerBase) fromClosedToOpen(snapshot interface{}) bool {
 	if b.state.casState(Closed, Open) {
 		b.updateNextRetryTimestamp()
 		for _, listener := range stateChangeListeners {
-			listener.OnTransformToOpen(Closed, b.rule, snapshot)
+			listener.OnTransformToOpen(Closed, *b.rule, snapshot)
 		}
 		return true
 	}
@@ -141,7 +146,7 @@ func (b *circuitBreakerBase) fromClosedToOpen(snapshot interface{}) bool {
 func (b *circuitBreakerBase) fromOpenToHalfOpen(ctx *base.EntryContext) bool {
 	if b.state.casState(Open, HalfOpen) {
 		for _, listener := range stateChangeListeners {
-			listener.OnTransformToHalfOpen(Open, b.rule)
+			listener.OnTransformToHalfOpen(Open, *b.rule)
 		}
 
 		entry := ctx.Entry()
@@ -154,7 +159,7 @@ func (b *circuitBreakerBase) fromOpenToHalfOpen(ctx *base.EntryContext) bool {
 			entry.WhenExit(func(entry *base.SentinelEntry, ctx *base.EntryContext) error {
 				if ctx.IsBlocked() && b.state.casState(HalfOpen, Open) {
 					for _, listener := range stateChangeListeners {
-						listener.OnTransformToOpen(HalfOpen, b.rule, 1.0)
+						listener.OnTransformToOpen(HalfOpen, *b.rule, 1.0)
 					}
 				}
 				return nil
@@ -171,7 +176,7 @@ func (b *circuitBreakerBase) fromHalfOpenToOpen(snapshot interface{}) bool {
 	if b.state.casState(HalfOpen, Open) {
 		b.updateNextRetryTimestamp()
 		for _, listener := range stateChangeListeners {
-			listener.OnTransformToOpen(HalfOpen, b.rule, snapshot)
+			listener.OnTransformToOpen(HalfOpen, *b.rule, snapshot)
 		}
 		return true
 	}
@@ -183,7 +188,7 @@ func (b *circuitBreakerBase) fromHalfOpenToOpen(snapshot interface{}) bool {
 func (b *circuitBreakerBase) fromHalfOpenToClosed() bool {
 	if b.state.casState(HalfOpen, Closed) {
 		for _, listener := range stateChangeListeners {
-			listener.OnTransformToClosed(HalfOpen, b.rule)
+			listener.OnTransformToClosed(HalfOpen, *b.rule)
 		}
 		return true
 	}
@@ -199,7 +204,7 @@ type slowRtCircuitBreaker struct {
 	minRequestAmount    uint64
 }
 
-func newSlowRtCircuitBreakerWithStat(r *slowRtRule, stat *slowRequestLeapArray) *slowRtCircuitBreaker {
+func newSlowRtCircuitBreakerWithStat(r *Rule, stat *slowRequestLeapArray) *slowRtCircuitBreaker {
 	status := new(State)
 	status.set(Closed)
 	return &slowRtCircuitBreaker{
@@ -211,12 +216,12 @@ func newSlowRtCircuitBreakerWithStat(r *slowRtRule, stat *slowRequestLeapArray)
 		},
 		stat:                stat,
 		maxAllowedRt:        r.MaxAllowedRtMs,
-		maxSlowRequestRatio: r.MaxSlowRequestRatio,
+		maxSlowRequestRatio: r.Threshold,
 		minRequestAmount:    r.MinRequestAmount,
 	}
 }
 
-func newSlowRtCircuitBreaker(r *slowRtRule) (*slowRtCircuitBreaker, error) {
+func newSlowRtCircuitBreaker(r *Rule) (*slowRtCircuitBreaker, error) {
 	interval := r.StatIntervalMs
 	stat := &slowRequestLeapArray{}
 	leapArray, err := sbase.NewLeapArray(1, interval, stat)
@@ -385,7 +390,7 @@ type errorRatioCircuitBreaker struct {
 	stat *errorCounterLeapArray
 }
 
-func newErrorRatioCircuitBreakerWithStat(r *errorRatioRule, stat *errorCounterLeapArray) *errorRatioCircuitBreaker {
+func newErrorRatioCircuitBreakerWithStat(r *Rule, stat *errorCounterLeapArray) *errorRatioCircuitBreaker {
 	status := new(State)
 	status.set(Closed)
 
@@ -402,7 +407,7 @@ func newErrorRatioCircuitBreakerWithStat(r *errorRatioRule, stat *errorCounterLe
 	}
 }
 
-func newErrorRatioCircuitBreaker(r *errorRatioRule) (*errorRatioCircuitBreaker, error) {
+func newErrorRatioCircuitBreaker(r *Rule) (*errorRatioCircuitBreaker, error) {
 	interval := r.StatIntervalMs
 	stat := &errorCounterLeapArray{}
 	leapArray, err := sbase.NewLeapArray(1, interval, stat)
@@ -565,7 +570,7 @@ type errorCountCircuitBreaker struct {
 	stat *errorCounterLeapArray
 }
 
-func newErrorCountCircuitBreakerWithStat(r *errorCountRule, stat *errorCounterLeapArray) *errorCountCircuitBreaker {
+func newErrorCountCircuitBreakerWithStat(r *Rule, stat *errorCounterLeapArray) *errorCountCircuitBreaker {
 	status := new(State)
 	status.set(Closed)
 
@@ -577,12 +582,12 @@ func newErrorCountCircuitBreakerWithStat(r *errorCountRule, stat *errorCounterLe
 			state:                status,
 		},
 		minRequestAmount:    r.MinRequestAmount,
-		errorCountThreshold: r.Threshold,
+		errorCountThreshold: uint64(r.Threshold),
 		stat:                stat,
 	}
 }
 
-func newErrorCountCircuitBreaker(r *errorCountRule) (*errorCountCircuitBreaker, error) {
+func newErrorCountCircuitBreaker(r *Rule) (*errorCountCircuitBreaker, error) {
 	interval := r.StatIntervalMs
 	stat := &errorCounterLeapArray{}
 	leapArray, err := sbase.NewLeapArray(1, interval, stat)
 
@@ -12,9 +12,9 @@ type CircuitBreakerMock struct {
 	mock.Mock
 }
 
-func (m *CircuitBreakerMock) BoundRule() Rule {
+func (m *CircuitBreakerMock) BoundRule() *Rule {
 	args := m.Called()
-	return args.Get(0).(Rule)
+	return args.Get(0).(*Rule)
 }
 
 func (m *CircuitBreakerMock) BoundStat() interface{} {
Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,9 @@ type CircuitBreakerMock struct {`
`12`	`12`	`mock.Mock`
`13`	`13`	`}`
`14`	`14`
`15`		`-func (m *CircuitBreakerMock) BoundRule() Rule {`
	`15`	`+func (m CircuitBreakerMock) BoundRule() Rule {`
`16`	`16`	`args := m.Called()`
`17`		`- return args.Get(0).(Rule)`
	`17`	`+ return args.Get(0).(*Rule)`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`func (m *CircuitBreakerMock) BoundStat() interface{} {`