alibaba
diff --git a/‎core/flow/rule.go
Copy file name to clipboard
+12-12Lines changed: 12 additions & 12 deletions b/‎core/flow/rule.go
Copy file name to clipboard
+12-12Lines changed: 12 additions & 12 deletions
diff --git a/‎core/hotspot/rule.go
Copy file name to clipboard
+31-30Lines changed: 31 additions & 30 deletions b/‎core/hotspot/rule.go
Copy file name to clipboard
+31-30Lines changed: 31 additions & 30 deletions
diff --git a/‎core/hotspot/rule_manager_test.go
Copy file name to clipboard
+69-69Lines changed: 69 additions & 69 deletions b/‎core/hotspot/rule_manager_test.go
Copy file name to clipboard
+69-69Lines changed: 69 additions & 69 deletions
@@ -58,24 +58,24 @@ type ClusterRuleConfig struct {
 // FlowRule describes the strategy of flow control.
 type FlowRule struct {
 	// ID represents the unique ID of the rule (optional).
-	ID uint64
+	ID uint64 `json:"id,omitempty"`
 
 	// Resource represents the resource name.
-	Resource string
+	Resource string `json:"resource"`
 	// LimitOrigin represents the target origin (reserved field).
-	LimitOrigin string
-	MetricType  MetricType
+	LimitOrigin string     `json:"limitOrigin"`
+	MetricType  MetricType `json:"metricType"`
 	// Count represents the threshold.
-	Count            float64
-	RelationStrategy RelationStrategy
-	ControlBehavior  ControlBehavior
+	Count            float64          `json:"count"`
+	RelationStrategy RelationStrategy `json:"relationStrategy"`
+	ControlBehavior  ControlBehavior  `json:"controlBehavior"`
 
-	RefResource       string
-	WarmUpPeriodSec   uint32
-	MaxQueueingTimeMs uint32
+	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
-	ClusterConfig ClusterRuleConfig
+	ClusterMode   bool              `json:"clusterMode"`
+	ClusterConfig ClusterRuleConfig `json:"clusterConfig"`
 }
 
 func (f *FlowRule) String() string {
 
@@ -74,8 +74,9 @@ func (t ParamKind) String() string {
 
 // SpecificValue indicates the specific param, contain the supported param kind and concrete value.
 type SpecificValue struct {
-	ValKind ParamKind
-	ValStr  string
+	ValKind   ParamKind `json:"valKind"`
+	ValStr    string    `json:"valStr"`
+	Threshold int64     `json:"threshold"`
 }
 
 func (s *SpecificValue) String() string {
@@ -84,32 +85,32 @@ func (s *SpecificValue) String() string {
 
 // Rule represents the hotspot(frequent) parameter flow control rule
 type Rule struct {
-	// Id is the unique id
-	Id string
+	// ID is the unique id
+	ID string `json:"id,omitempty"`
 	// Resource is the resource name
-	Resource        string
-	MetricType      MetricType
-	ControlBehavior ControlBehavior
+	Resource        string          `json:"resource"`
+	MetricType      MetricType      `json:"metricType"`
+	ControlBehavior ControlBehavior `json:"controlBehavior"`
 	// ParamIndex is the index in context arguments slice.
-	ParamIndex int
-	Threshold  float64
+	ParamIndex int     `json:"paramIndex"`
+	Threshold  float64 `json:"threshold"`
 	// MaxQueueingTimeMs only take effect in both Throttling ControlBehavior and QPS MetricType
-	MaxQueueingTimeMs int64
+	MaxQueueingTimeMs int64 `json:"maxQueueingTimeMs"`
 	// BurstCount is the silent count
 	// Only take effect in both Reject ControlBehavior and QPS MetricType
-	BurstCount int64
+	BurstCount int64 `json:"burstCount"`
 	// DurationInSec is the time interval in statistic
 	// Only take effect in QPS MetricType
-	DurationInSec int64
+	DurationInSec int64 `json:"durationInSec"`
 	// ParamsMaxCapacity is the max capacity of cache statistic
-	ParamsMaxCapacity int64
+	ParamsMaxCapacity int64 `json:"paramsMaxCapacity"`
 	// SpecificItems indicates the special threshold for specific value
-	SpecificItems map[SpecificValue]int64
+	SpecificItems []SpecificValue `json:"specificItems"`
 }
 
 func (r *Rule) String() string {
 	return fmt.Sprintf("{Id:%s, Resource:%s, MetricType:%+v, ControlBehavior:%+v, ParamIndex:%d, Threshold:%f, MaxQueueingTimeMs:%d, BurstCount:%d, DurationInSec:%d, ParamsMaxCapacity:%d, SpecificItems:%+v}",
-		r.Id, r.Resource, r.MetricType, r.ControlBehavior, r.ParamIndex, r.Threshold, r.MaxQueueingTimeMs, r.BurstCount, r.DurationInSec, r.ParamsMaxCapacity, r.SpecificItems)
+		r.ID, r.Resource, r.MetricType, r.ControlBehavior, r.ParamIndex, r.Threshold, r.MaxQueueingTimeMs, r.BurstCount, r.DurationInSec, r.ParamsMaxCapacity, r.SpecificItems)
 }
 func (r *Rule) ResourceName() string {
 	return r.Resource
@@ -136,46 +137,46 @@ func (r *Rule) Equals(newRule *Rule) bool {
 }
 
 // parseSpecificItems parses the SpecificValue as real value.
-func parseSpecificItems(source map[SpecificValue]int64) map[interface{}]int64 {
+func parseSpecificItems(source []SpecificValue) map[interface{}]int64 {
 	ret := make(map[interface{}]int64)
 	if len(source) == 0 {
 		return ret
 	}
-	for k, v := range source {
-		switch k.ValKind {
+	for _, item := range source {
+		switch item.ValKind {
 		case KindInt:
-			realVal, err := strconv.Atoi(k.ValStr)
+			realVal, err := strconv.Atoi(item.ValStr)
 			if err != nil {
-				logger.Errorf("Failed to parse value for int specific item. paramKind: %+v, value: %s, err: %+v", k.ValKind, k.ValStr, err)
+				logger.Errorf("Failed to parse value for int specific item. paramKind: %+v, value: %s, err: %+v", item.ValKind, item.ValStr, err)
 				continue
 			}
-			ret[realVal] = v
+			ret[realVal] = item.Threshold
 
 		case KindString:
-			ret[k.ValStr] = v
+			ret[item.ValStr] = item.Threshold
 
 		case KindBool:
-			realVal, err := strconv.ParseBool(k.ValStr)
+			realVal, err := strconv.ParseBool(item.ValStr)
 			if err != nil {
-				logger.Errorf("Failed to parse value for bool specific item. value: %s, err: %+v", k.ValStr, err)
+				logger.Errorf("Failed to parse value for bool specific item. value: %s, err: %+v", item.ValStr, err)
 				continue
 			}
-			ret[realVal] = v
+			ret[realVal] = item.Threshold
 
 		case KindFloat64:
-			realVal, err := strconv.ParseFloat(k.ValStr, 64)
+			realVal, err := strconv.ParseFloat(item.ValStr, 64)
 			if err != nil {
-				logger.Errorf("Failed to parse value for float specific item. value: %s, err: %+v", k.ValStr, err)
+				logger.Errorf("Failed to parse value for float specific item. value: %s, err: %+v", item.ValStr, err)
 				continue
 			}
 			realVal, err = strconv.ParseFloat(fmt.Sprintf("%.5f", realVal), 64)
 			if err != nil {
-				logger.Errorf("Failed to parse value for float specific item. value: %s, err: %+v", k.ValStr, err)
+				logger.Errorf("Failed to parse value for float specific item. value: %s, err: %+v", item.ValStr, err)
 				continue
 			}
-			ret[realVal] = v
+			ret[realVal] = item.Threshold
 		default:
-			logger.Errorf("Unsupported kind for specific item: %d", k.ValKind)
+			logger.Errorf("Unsupported kind for specific item: %d", item.ValKind)
 		}
 	}
 	return ret
 
@@ -11,16 +11,14 @@ import (
 
 func Test_tcGenFuncMap(t *testing.T) {
 	t.Run("Test_tcGenFuncMap_withoutMetric", func(t *testing.T) {
-		m := make(map[SpecificValue]int64)
-		m[SpecificValue{
-			ValKind: KindInt,
-			ValStr:  "100",
-		}] = 100
-
-		parsedM := make(map[interface{}]int64)
-		parsedM[100] = 100
+		m := make([]SpecificValue, 1)
+		m[0] = SpecificValue{
+			ValKind:   KindInt,
+			ValStr:    "100",
+			Threshold: 100,
+		}
 		r1 := &Rule{
-			Id:                "abc",
+			ID:                "abc",
 			Resource:          "abc",
 			MetricType:        Concurrency,
 			ControlBehavior:   Reject,
@@ -42,16 +40,15 @@ func Test_tcGenFuncMap(t *testing.T) {
 	})
 
 	t.Run("Test_tcGenFuncMap_withMetric", func(t *testing.T) {
-		m := make(map[SpecificValue]int64)
-		m[SpecificValue{
-			ValKind: KindInt,
-			ValStr:  "100",
-		}] = 100
+		m := make([]SpecificValue, 1)
+		m[0] = SpecificValue{
+			ValKind:   KindInt,
+			ValStr:    "100",
+			Threshold: 100,
+		}
 
-		parsedM := make(map[interface{}]int64)
-		parsedM[100] = 100
 		r1 := &Rule{
-			Id:                "abc",
+			ID:                "abc",
 			Resource:          "abc",
 			MetricType:        Concurrency,
 			ControlBehavior:   Reject,
@@ -88,16 +85,14 @@ func Test_tcGenFuncMap(t *testing.T) {
 
 func Test_IsValidRule(t *testing.T) {
 	t.Run("Test_IsValidRule", func(t *testing.T) {
-		m := make(map[SpecificValue]int64)
-		m[SpecificValue{
-			ValKind: KindInt,
-			ValStr:  "100",
-		}] = 100
-
-		parsedM := make(map[interface{}]int64)
-		parsedM[100] = 100
+		m := make([]SpecificValue, 1)
+		m[0] = SpecificValue{
+			ValKind:   KindInt,
+			ValStr:    "100",
+			Threshold: 100,
+		}
 		r1 := &Rule{
-			Id:                "abc",
+			ID:                "abc",
 			Resource:          "abc",
 			MetricType:        Concurrency,
 			ControlBehavior:   Reject,
@@ -112,16 +107,14 @@ func Test_IsValidRule(t *testing.T) {
 	})
 
 	t.Run("Test_InValidRule", func(t *testing.T) {
-		m := make(map[SpecificValue]int64)
-		m[SpecificValue{
-			ValKind: KindInt,
-			ValStr:  "100",
-		}] = 100
-
-		parsedM := make(map[interface{}]int64)
-		parsedM[100] = 100
+		m := make([]SpecificValue, 1)
+		m[0] = SpecificValue{
+			ValKind:   KindInt,
+			ValStr:    "100",
+			Threshold: 100,
+		}
 		r1 := &Rule{
-			Id:                "",
+			ID:                "",
 			Resource:          "",
 			MetricType:        Concurrency,
 			ControlBehavior:   Reject,
@@ -139,17 +132,20 @@ func Test_IsValidRule(t *testing.T) {
 func Test_onRuleUpdate(t *testing.T) {
 	tcMap = make(trafficControllerMap)
 
-	m := make(map[SpecificValue]int64)
-	m[SpecificValue{
-		ValKind: KindString,
-		ValStr:  "sss",
-	}] = 1
-	m[SpecificValue{
-		ValKind: KindFloat64,
-		ValStr:  "1.123",
-	}] = 3
+	m := make([]SpecificValue, 2)
+	m[0] = SpecificValue{
+		ValKind:   KindString,
+		ValStr:    "sss",
+		Threshold: 1,
+	}
+	m[1] = SpecificValue{
+		ValKind:   KindFloat64,
+		ValStr:    "1.123",
+		Threshold: 3,
+	}
+
 	r1 := &Rule{
-		Id:                "1",
+		ID:                "1",
 		Resource:          "abc",
 		MetricType:        Concurrency,
 		ControlBehavior:   Reject,
@@ -161,17 +157,19 @@ func Test_onRuleUpdate(t *testing.T) {
 		SpecificItems:     m,
 	}
 
-	m2 := make(map[SpecificValue]int64)
-	m2[SpecificValue{
-		ValKind: KindString,
-		ValStr:  "sss",
-	}] = 1
-	m2[SpecificValue{
-		ValKind: KindFloat64,
-		ValStr:  "1.123",
-	}] = 3
+	m2 := make([]SpecificValue, 2)
+	m2[0] = SpecificValue{
+		ValKind:   KindString,
+		ValStr:    "sss",
+		Threshold: 1,
+	}
+	m2[1] = SpecificValue{
+		ValKind:   KindFloat64,
+		ValStr:    "1.123",
+		Threshold: 3,
+	}
 	r2 := &Rule{
-		Id:                "2",
+		ID:                "2",
 		Resource:          "abc",
 		MetricType:        QPS,
 		ControlBehavior:   Throttling,
@@ -183,17 +181,19 @@ func Test_onRuleUpdate(t *testing.T) {
 		SpecificItems:     m2,
 	}
 
-	m3 := make(map[SpecificValue]int64)
-	m3[SpecificValue{
-		ValKind: KindString,
-		ValStr:  "sss",
-	}] = 1
-	m3[SpecificValue{
-		ValKind: KindFloat64,
-		ValStr:  "1.123",
-	}] = 3
+	m3 := make([]SpecificValue, 2)
+	m3[0] = SpecificValue{
+		ValKind:   KindString,
+		ValStr:    "sss",
+		Threshold: 1,
+	}
+	m3[1] = SpecificValue{
+		ValKind:   KindFloat64,
+		ValStr:    "1.123",
+		Threshold: 3,
+	}
 	r3 := &Rule{
-		Id:                "3",
+		ID:                "3",
 		Resource:          "abc",
 		MetricType:        Concurrency,
 		ControlBehavior:   Throttling,
@@ -206,7 +206,7 @@ func Test_onRuleUpdate(t *testing.T) {
 	}
 
 	r4 := &Rule{
-		Id:                "4",
+		ID:                "4",
 		Resource:          "abc",
 		MetricType:        Concurrency,
 		ControlBehavior:   Throttling,
@@ -225,7 +225,7 @@ func Test_onRuleUpdate(t *testing.T) {
 	assert.True(t, len(tcMap["abc"]) == 4)
 
 	r21 := &Rule{
-		Id:                "21",
+		ID:                "21",
 		Resource:          "abc",
 		MetricType:        Concurrency,
 		ControlBehavior:   Reject,
@@ -237,7 +237,7 @@ func Test_onRuleUpdate(t *testing.T) {
 		SpecificItems:     m,
 	}
 	r22 := &Rule{
-		Id:                "22",
+		ID:                "22",
 		Resource:          "abc",
 		MetricType:        QPS,
 		ControlBehavior:   Throttling,
@@ -249,7 +249,7 @@ func Test_onRuleUpdate(t *testing.T) {
 		SpecificItems:     m2,
 	}
 	r23 := &Rule{
-		Id:                "23",
+		ID:                "23",
 		Resource:          "abc",
 		MetricType:        Concurrency,
 		ControlBehavior:   Throttling,