Rename flow.FlowRule to flow.Rule and remove unused fields (#221)

louyuting · web-flow · commit a9fa3001c12f · 2020-09-03T20:19:16.000+08:00
* Rename flow.FlowRule to flow.Rule
* Remove cluster flow control code related.
diff --git a/adapter/echo/middleware_test.go b/adapter/echo/middleware_test.go
@@ -18,7 +18,7 @@ func initSentinel(t *testing.T) {
 		t.Fatalf("Unexpected error: %+v", err)
 	}
 
-	_, err = flow.LoadRules([]*flow.FlowRule{
+	_, err = flow.LoadRules([]*flow.Rule{
 		{
 			Resource:        "GET:/ping",
 			MetricType:      flow.QPS,
diff --git a/adapter/gin/middleware_test.go b/adapter/gin/middleware_test.go
@@ -18,7 +18,7 @@ func initSentinel(t *testing.T) {
 		t.Fatalf("Unexpected error: %+v", err)
 	}
 
-	_, err = flow.LoadRules([]*flow.FlowRule{
+	_, err = flow.LoadRules([]*flow.Rule{
 		{
 			Resource:        "GET:/ping",
 			MetricType:      flow.QPS,
diff --git a/adapter/grpc/client_test.go b/adapter/grpc/client_test.go
@@ -23,7 +23,7 @@ func TestUnaryClientIntercept(t *testing.T) {
 	}
 	method := "/grpc.testing.TestService/UnaryCall"
 	t.Run("success", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        "client:" + method,
 				MetricType:      flow.QPS,
@@ -41,7 +41,7 @@ func TestUnaryClientIntercept(t *testing.T) {
 	})
 
 	t.Run("fail", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        "client:" + method,
 				MetricType:      flow.QPS,
@@ -67,7 +67,7 @@ func TestStreamClientIntercept(t *testing.T) {
 	}
 	method := "/grpc.testing.TestService/StreamingOutputCall"
 	t.Run("success", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        "client:/grpc.testing.TestService/StreamingOutputCall",
 				MetricType:      flow.QPS,
@@ -87,7 +87,7 @@ func TestStreamClientIntercept(t *testing.T) {
 	})
 
 	t.Run("fail", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        "client:/grpc.testing.TestService/StreamingOutputCall",
 				MetricType:      flow.QPS,
diff --git a/adapter/grpc/server_test.go b/adapter/grpc/server_test.go
@@ -29,7 +29,7 @@ func TestStreamServerIntercept(t *testing.T) {
 	}
 
 	t.Run("success", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        "/grpc.testing.TestService/StreamingInputCall",
 				MetricType:      flow.QPS,
@@ -47,7 +47,7 @@ func TestStreamServerIntercept(t *testing.T) {
 	})
 
 	t.Run("fail", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        "/grpc.testing.TestService/StreamingInputCall",
 				MetricType:      flow.QPS,
@@ -71,7 +71,7 @@ func TestUnaryServerIntercept(t *testing.T) {
 		FullMethod: "/grpc.testing.TestService/UnaryCall",
 	}
 	t.Run("success", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        "/grpc.testing.TestService/UnaryCall",
 				MetricType:      flow.QPS,
@@ -99,7 +99,7 @@ func TestUnaryServerIntercept(t *testing.T) {
 		return "abc", nil
 	}
 	t.Run("fail", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        "/grpc.testing.TestService/UnaryCall",
 				MetricType:      flow.QPS,
diff --git a/adapter/micro/client_test.go b/adapter/micro/client_test.go
@@ -45,7 +45,7 @@ func TestClientLimiter(t *testing.T) {
 	rsp := &proto.Response{}
 
 	t.Run("success", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        req.Method(),
 				MetricType:      flow.QPS,
diff --git a/adapter/micro/server_test.go b/adapter/micro/server_test.go
@@ -55,7 +55,7 @@ func TestServerLimiter(t *testing.T) {
 		log.Fatal(err)
 	}
 
-	_, err = flow.LoadRules([]*flow.FlowRule{
+	_, err = flow.LoadRules([]*flow.Rule{
 		{
 			Resource:        req.Method(),
 			MetricType:      flow.QPS,
@@ -69,7 +69,7 @@ func TestServerLimiter(t *testing.T) {
 	var rsp = &proto.Response{}
 
 	t.Run("success", func(t *testing.T) {
-		var _, err = flow.LoadRules([]*flow.FlowRule{
+		var _, err = flow.LoadRules([]*flow.Rule{
 			{
 				Resource:        req.Method(),
 				MetricType:      flow.QPS,
diff --git a/core/flow/rule.go b/core/flow/rule.go
@@ -44,19 +44,8 @@ const (
 	WarmUpThrottling
 )
 
-type ClusterThresholdMode uint32
-
-const (
-	AvgLocalThreshold ClusterThresholdMode = iota
-	GlobalThreshold
-)
-
-type ClusterRuleConfig struct {
-	ThresholdType ClusterThresholdMode `json:"thresholdType"`
-}
-
-// FlowRule describes the strategy of flow control.
-type FlowRule struct {
+// Rule describes the strategy of flow control.
+type Rule struct {
 	// ID represents the unique ID of the rule (optional).
 	ID uint64 `json:"id,omitempty"`
 
@@ -71,24 +60,21 @@ type FlowRule struct {
 	ControlBehavior  ControlBehavior  `json:"controlBehavior"`
 
 	RefResource       string `json:"refResource"`
-	WarmUpPeriodSec   uint32 `json:"warmUpPeriodSec"`
 	MaxQueueingTimeMs uint32 `json:"maxQueueingTimeMs"`
-	// ClusterMode indicates whether the rule is for cluster flow control or local.
-	ClusterMode      bool              `json:"clusterMode"`
-	ClusterConfig    ClusterRuleConfig `json:"clusterConfig"`
-	WarmUpColdFactor uint32            `json:"warmUpColdFactor"`
+	WarmUpPeriodSec   uint32 `json:"warmUpPeriodSec"`
+	WarmUpColdFactor  uint32 `json:"warmUpColdFactor"`
 }
 
-func (f *FlowRule) String() string {
+func (f *Rule) String() string {
 	b, err := json.Marshal(f)
 	if err != nil {
 		// Return the fallback string
-		return fmt.Sprintf("FlowRule{resource=%s, id=%d, metricType=%d, threshold=%.2f}",
+		return fmt.Sprintf("Rule{resource=%s, id=%d, metricType=%d, threshold=%.2f}",
 			f.Resource, f.ID, f.MetricType, f.Count)
 	}
 	return string(b)
 }
 
-func (f *FlowRule) ResourceName() string {
+func (f *Rule) ResourceName() string {
 	return f.Resource
 }
diff --git a/core/flow/rule_manager.go b/core/flow/rule_manager.go
@@ -11,7 +11,7 @@ import (
 )
 
 // TrafficControllerGenFunc represents the TrafficShapingController generator function of a specific control behavior.
-type TrafficControllerGenFunc func(*FlowRule) *TrafficShapingController
+type TrafficControllerGenFunc func(*Rule) *TrafficShapingController
 
 // TrafficControllerMap represents the map storage for TrafficShapingController.
 type TrafficControllerMap map[string][]*TrafficShapingController
@@ -24,13 +24,13 @@ var (
 
 func init() {
 	// Initialize the traffic shaping controller generator map for existing control behaviors.
-	tcGenFuncMap[Reject] = func(rule *FlowRule) *TrafficShapingController {
+	tcGenFuncMap[Reject] = func(rule *Rule) *TrafficShapingController {
 		return NewTrafficShapingController(NewDefaultTrafficShapingCalculator(rule.Count), NewDefaultTrafficShapingChecker(rule), rule)
 	}
-	tcGenFuncMap[Throttling] = func(rule *FlowRule) *TrafficShapingController {
+	tcGenFuncMap[Throttling] = func(rule *Rule) *TrafficShapingController {
 		return NewTrafficShapingController(NewDefaultTrafficShapingCalculator(rule.Count), NewThrottlingChecker(rule.MaxQueueingTimeMs), rule)
 	}
-	tcGenFuncMap[WarmUp] = func(rule *FlowRule) *TrafficShapingController {
+	tcGenFuncMap[WarmUp] = func(rule *Rule) *TrafficShapingController {
 		return NewTrafficShapingController(NewWarmUpTrafficShapingCalculator(rule), NewDefaultTrafficShapingChecker(rule), rule)
 	}
 }
@@ -44,7 +44,7 @@ func logRuleUpdate(m TrafficControllerMap) {
 	}
 }
 
-func onRuleUpdate(rules []*FlowRule) (err error) {
+func onRuleUpdate(rules []*Rule) (err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			var ok bool
@@ -73,13 +73,13 @@ func onRuleUpdate(rules []*FlowRule) (err error) {
 }
 
 // LoadRules loads the given flow rules to the rule manager, while all previous rules will be replaced.
-func LoadRules(rules []*FlowRule) (bool, error) {
+func LoadRules(rules []*Rule) (bool, error) {
 	// TODO: rethink the design
 	err := onRuleUpdate(rules)
 	return true, err
 }
 
-func GetRules() []*FlowRule {
+func GetRules() []*Rule {
 	tcMux.RLock()
 	defer tcMux.RUnlock()
 
@@ -91,8 +91,8 @@ func ClearRules() error {
 	return err
 }
 
-func rulesFrom(m TrafficControllerMap) []*FlowRule {
-	rules := make([]*FlowRule, 0)
+func rulesFrom(m TrafficControllerMap) []*Rule {
+	rules := make([]*Rule, 0)
 	if len(m) == 0 {
 		return rules
 	}
@@ -144,7 +144,7 @@ func getTrafficControllerListFor(name string) []*TrafficShapingController {
 }
 
 // NotThreadSafe (should be guarded by the lock)
-func buildFlowMap(rules []*FlowRule) TrafficControllerMap {
+func buildFlowMap(rules []*Rule) TrafficControllerMap {
 	m := make(TrafficControllerMap)
 	if len(rules) == 0 {
 		return m
@@ -179,10 +179,10 @@ func buildFlowMap(rules []*FlowRule) TrafficControllerMap {
 	return m
 }
 
-// IsValidFlowRule checks whether the given FlowRule is valid.
-func IsValidFlowRule(rule *FlowRule) error {
+// IsValidFlowRule checks whether the given Rule is valid.
+func IsValidFlowRule(rule *Rule) error {
 	if rule == nil {
-		return errors.New("nil FlowRule")
+		return errors.New("nil Rule")
 	}
 	if rule.Resource == "" {
 		return errors.New("empty resource name")
@@ -203,21 +203,11 @@ func IsValidFlowRule(rule *FlowRule) error {
 	if rule.RelationStrategy == AssociatedResource && rule.RefResource == "" {
 		return errors.New("Bad flow rule: invalid control behavior")
 	}
-	if err := checkClusterField(rule); err != nil {
-		return err
-	}
 
 	return checkControlBehaviorField(rule)
 }
 
-func checkClusterField(rule *FlowRule) error {
-	if rule.ClusterMode && rule.ID <= 0 {
-		return errors.New("invalid cluster rule ID")
-	}
-	return nil
-}
-
-func checkControlBehaviorField(rule *FlowRule) error {
+func checkControlBehaviorField(rule *Rule) error {
 	switch rule.ControlBehavior {
 	case WarmUp:
 		if rule.WarmUpPeriodSec <= 0 {
diff --git a/core/flow/rule_manager_test.go b/core/flow/rule_manager_test.go
@@ -9,21 +9,21 @@ import (
 func TestSetAndRemoveTrafficShapingGenerator(t *testing.T) {
 	tsc := NewTrafficShapingController(nil, nil, nil)
 
-	err := SetTrafficShapingGenerator(Reject, func(_ *FlowRule) *TrafficShapingController {
+	err := SetTrafficShapingGenerator(Reject, func(_ *Rule) *TrafficShapingController {
 		return tsc
 	})
 	assert.Error(t, err, "default control behaviors are not allowed to be modified")
 	err = RemoveTrafficShapingGenerator(Reject)
 	assert.Error(t, err, "default control behaviors are not allowed to be removed")
 
 	cb := ControlBehavior(9999)
-	err = SetTrafficShapingGenerator(cb, func(_ *FlowRule) *TrafficShapingController {
+	err = SetTrafficShapingGenerator(cb, func(_ *Rule) *TrafficShapingController {
 		return tsc
 	})
 	assert.NoError(t, err)
 
 	resource := "test-customized-tc"
-	_, err = LoadRules([]*FlowRule{
+	_, err = LoadRules([]*Rule{
 		{
 			ID:              10,
 			Count:           20,
@@ -41,19 +41,17 @@ func TestSetAndRemoveTrafficShapingGenerator(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotContains(t, tcGenFuncMap, cb)
 
-	_, _ = LoadRules([]*FlowRule{})
+	_, _ = LoadRules([]*Rule{})
 }
 
 func TestIsValidFlowRule(t *testing.T) {
-	badRule1 := &FlowRule{ID: 1, Count: 1, MetricType: QPS, Resource: ""}
-	badRule2 := &FlowRule{ID: 1, Count: -1.9, MetricType: QPS, Resource: "test"}
-	badRule3 := &FlowRule{Count: 5, MetricType: QPS, Resource: "test", ClusterMode: true}
-	badRule4 := &FlowRule{Count: 5, MetricType: QPS, Resource: "test", ControlBehavior: WarmUp}
-	goodRule1 := &FlowRule{Count: 10, MetricType: QPS, Resource: "test", ControlBehavior: Throttling}
+	badRule1 := &Rule{ID: 1, Count: 1, MetricType: QPS, Resource: ""}
+	badRule2 := &Rule{ID: 1, Count: -1.9, MetricType: QPS, Resource: "test"}
+	badRule3 := &Rule{Count: 5, MetricType: QPS, Resource: "test", ControlBehavior: WarmUp}
+	goodRule1 := &Rule{Count: 10, MetricType: QPS, Resource: "test", ControlBehavior: Throttling}
 
 	assert.Error(t, IsValidFlowRule(badRule1))
 	assert.Error(t, IsValidFlowRule(badRule2))
 	assert.Error(t, IsValidFlowRule(badRule3))
-	assert.Error(t, IsValidFlowRule(badRule4))
 	assert.NoError(t, IsValidFlowRule(goodRule1))
 }
diff --git a/core/flow/slot.go b/core/flow/slot.go
@@ -50,13 +50,10 @@ func canPassCheck(tc *TrafficShapingController, node base.StatNode, acquireCount
 }
 
 func canPassCheckWithFlag(tc *TrafficShapingController, node base.StatNode, acquireCount uint32, flag int32) *base.TokenResult {
-	if tc.rule.ClusterMode {
-		// TODO: support cluster mode
-	}
 	return checkInLocal(tc, node, acquireCount, flag)
 }
 
-func selectNodeByRelStrategy(rule *FlowRule, node base.StatNode) base.StatNode {
+func selectNodeByRelStrategy(rule *Rule, node base.StatNode) base.StatNode {
 	if rule.RelationStrategy == AssociatedResource {
 		return stat.GetResourceNode(rule.RefResource)
 	}
diff --git a/core/flow/tc_default.go b/core/flow/tc_default.go
@@ -17,10 +17,10 @@ func (d *DefaultTrafficShapingCalculator) CalculateAllowedTokens(base.StatNode,
 }
 
 type DefaultTrafficShapingChecker struct {
-	rule *FlowRule
+	rule *Rule
 }
 
-func NewDefaultTrafficShapingChecker(rule *FlowRule) *DefaultTrafficShapingChecker {
+func NewDefaultTrafficShapingChecker(rule *Rule) *DefaultTrafficShapingChecker {
 	return &DefaultTrafficShapingChecker{rule: rule}
 }
 
diff --git a/core/flow/tc_warm_up.go b/core/flow/tc_warm_up.go
@@ -22,7 +22,7 @@ type WarmUpTrafficShapingCalculator struct {
 	lastFilledTime    uint64
 }
 
-func NewWarmUpTrafficShapingCalculator(rule *FlowRule) *WarmUpTrafficShapingCalculator {
+func NewWarmUpTrafficShapingCalculator(rule *Rule) *WarmUpTrafficShapingCalculator {
 	if rule.WarmUpColdFactor <= 1 {
 		rule.WarmUpColdFactor = config.DefaultWarmUpColdFactor
 		logging.Warnf("[NewWarmUpTrafficShapingCalculator] invalid WarmUpColdFactor,use default values: %d", config.DefaultWarmUpColdFactor)
diff --git a/core/flow/traffic_shaping.go b/core/flow/traffic_shaping.go
@@ -20,15 +20,15 @@ type TrafficShapingController struct {
 	flowCalculator TrafficShapingCalculator
 	flowChecker    TrafficShapingChecker
 
-	rule *FlowRule
+	rule *Rule
 }
 
 // NewTrafficShapingController creates a TrafficShapingController wrapped with the given checker and flow rule.
-func NewTrafficShapingController(flowCalculator TrafficShapingCalculator, flowChecker TrafficShapingChecker, rule *FlowRule) *TrafficShapingController {
+func NewTrafficShapingController(flowCalculator TrafficShapingCalculator, flowChecker TrafficShapingChecker, rule *Rule) *TrafficShapingController {
 	return &TrafficShapingController{flowCalculator: flowCalculator, flowChecker: flowChecker, rule: rule}
 }
 
-func (t *TrafficShapingController) Rule() *FlowRule {
+func (t *TrafficShapingController) Rule() *Rule {
 	return t.rule
 }
 
diff --git a/example/qps/qps_limit_example.go b/example/qps/qps_limit_example.go
@@ -19,7 +19,7 @@ func main() {
 		log.Fatalf("Unexpected error: %+v", err)
 	}
 
-	_, err = flow.LoadRules([]*flow.FlowRule{
+	_, err = flow.LoadRules([]*flow.Rule{
 		{
 			Resource:        "some-test",
 			MetricType:      flow.QPS,
diff --git a/example/qps/qps_limit_example_test.go b/example/qps/qps_limit_example_test.go
diff --git a/example/warm_up/qps_warm_up_example.go b/example/warm_up/qps_warm_up_example.go
diff --git a/example/warm_up/qps_warm_up_example_test.go b/example/warm_up/qps_warm_up_example_test.go
diff --git a/ext/datasource/helper.go b/ext/datasource/helper.go
diff --git a/ext/datasource/helper_test.go b/ext/datasource/helper_test.go
diff --git a/tests/testdata/extension/helper/FlowRule.json b/tests/testdata/extension/helper/FlowRule.json

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ func initSentinel(t *testing.T) {`
`18`	`18`	`t.Fatalf("Unexpected error: %+v", err)`
`19`	`19`	`}`
`20`	`20`
`21`		`- _, err = flow.LoadRules([]*flow.FlowRule{`
	`21`	`+ _, err = flow.LoadRules([]*flow.Rule{`
`22`	`22`	`{`
`23`	`23`	`Resource: "GET:/ping",`
`24`	`24`	`MetricType: flow.QPS,`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ func TestUnaryClientIntercept(t *testing.T) {`
`23`	`23`	`}`
`24`	`24`	`method := "/grpc.testing.TestService/UnaryCall"`
`25`	`25`	`t.Run("success", func(t *testing.T) {`
`26`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`26`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`27`	`27`	`{`
`28`	`28`	`Resource: "client:" + method,`
`29`	`29`	`MetricType: flow.QPS,`
`@@ -41,7 +41,7 @@ func TestUnaryClientIntercept(t *testing.T) {`
`41`	`41`	`})`
`42`	`42`
`43`	`43`	`t.Run("fail", func(t *testing.T) {`
`44`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`44`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`45`	`45`	`{`
`46`	`46`	`Resource: "client:" + method,`
`47`	`47`	`MetricType: flow.QPS,`
`@@ -67,7 +67,7 @@ func TestStreamClientIntercept(t *testing.T) {`
`67`	`67`	`}`
`68`	`68`	`method := "/grpc.testing.TestService/StreamingOutputCall"`
`69`	`69`	`t.Run("success", func(t *testing.T) {`
`70`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`70`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`71`	`71`	`{`
`72`	`72`	`Resource: "client:/grpc.testing.TestService/StreamingOutputCall",`
`73`	`73`	`MetricType: flow.QPS,`
`@@ -87,7 +87,7 @@ func TestStreamClientIntercept(t *testing.T) {`
`87`	`87`	`})`
`88`	`88`
`89`	`89`	`t.Run("fail", func(t *testing.T) {`
`90`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`90`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`91`	`91`	`{`
`92`	`92`	`Resource: "client:/grpc.testing.TestService/StreamingOutputCall",`
`93`	`93`	`MetricType: flow.QPS,`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ func TestStreamServerIntercept(t *testing.T) {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`t.Run("success", func(t *testing.T) {`
`32`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`32`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`33`	`33`	`{`
`34`	`34`	`Resource: "/grpc.testing.TestService/StreamingInputCall",`
`35`	`35`	`MetricType: flow.QPS,`
`@@ -47,7 +47,7 @@ func TestStreamServerIntercept(t *testing.T) {`
`47`	`47`	`})`
`48`	`48`
`49`	`49`	`t.Run("fail", func(t *testing.T) {`
`50`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`50`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`51`	`51`	`{`
`52`	`52`	`Resource: "/grpc.testing.TestService/StreamingInputCall",`
`53`	`53`	`MetricType: flow.QPS,`
`@@ -71,7 +71,7 @@ func TestUnaryServerIntercept(t *testing.T) {`
`71`	`71`	`FullMethod: "/grpc.testing.TestService/UnaryCall",`
`72`	`72`	`}`
`73`	`73`	`t.Run("success", func(t *testing.T) {`
`74`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`74`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`75`	`75`	`{`
`76`	`76`	`Resource: "/grpc.testing.TestService/UnaryCall",`
`77`	`77`	`MetricType: flow.QPS,`
`@@ -99,7 +99,7 @@ func TestUnaryServerIntercept(t *testing.T) {`
`99`	`99`	`return "abc", nil`
`100`	`100`	`}`
`101`	`101`	`t.Run("fail", func(t *testing.T) {`
`102`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`102`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`103`	`103`	`{`
`104`	`104`	`Resource: "/grpc.testing.TestService/UnaryCall",`
`105`	`105`	`MetricType: flow.QPS,`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ func TestClientLimiter(t *testing.T) {`
`45`	`45`	`rsp := &proto.Response{}`
`46`	`46`
`47`	`47`	`t.Run("success", func(t *testing.T) {`
`48`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`48`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`49`	`49`	`{`
`50`	`50`	`Resource: req.Method(),`
`51`	`51`	`MetricType: flow.QPS,`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ func TestServerLimiter(t *testing.T) {`
`55`	`55`	`log.Fatal(err)`
`56`	`56`	`}`
`57`	`57`
`58`		`- _, err = flow.LoadRules([]*flow.FlowRule{`
	`58`	`+ _, err = flow.LoadRules([]*flow.Rule{`
`59`	`59`	`{`
`60`	`60`	`Resource: req.Method(),`
`61`	`61`	`MetricType: flow.QPS,`
`@@ -69,7 +69,7 @@ func TestServerLimiter(t *testing.T) {`
`69`	`69`	`var rsp = &proto.Response{}`
`70`	`70`
`71`	`71`	`t.Run("success", func(t *testing.T) {`
`72`		`- var _, err = flow.LoadRules([]*flow.FlowRule{`
	`72`	`+ var _, err = flow.LoadRules([]*flow.Rule{`
`73`	`73`	`{`
`74`	`74`	`Resource: req.Method(),`
`75`	`75`	`MetricType: flow.QPS,`
Original file line number	Diff line number	Diff line change
`@@ -50,13 +50,10 @@ func canPassCheck(tc *TrafficShapingController, node base.StatNode, acquireCount`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`func canPassCheckWithFlag(tc TrafficShapingController, node base.StatNode, acquireCount uint32, flag int32) base.TokenResult {`
`53`		`- if tc.rule.ClusterMode {`
`54`		`- // TODO: support cluster mode`
`55`		`- }`
`56`	`53`	`return checkInLocal(tc, node, acquireCount, flag)`
`57`	`54`	`}`
`58`	`55`
`59`		`-func selectNodeByRelStrategy(rule *FlowRule, node base.StatNode) base.StatNode {`
	`56`	`+func selectNodeByRelStrategy(rule *Rule, node base.StatNode) base.StatNode {`
`60`	`57`	`if rule.RelationStrategy == AssociatedResource {`
`61`	`58`	`return stat.GetResourceNode(rule.RefResource)`
`62`	`59`	`}`