Rename system.SystemRule to system.Rule (#222)

louyuting · web-flow · commit 8b17e248b023 · 2020-09-03T20:31:09.000+08:00
diff --git a/core/system/rule.go b/core/system/rule.go
@@ -56,24 +56,24 @@ func (t AdaptiveStrategy) String() string {
 	}
 }
 
-type SystemRule struct {
+type Rule struct {
 	ID uint64 `json:"id,omitempty"`
 
 	MetricType   MetricType       `json:"metricType"`
 	TriggerCount float64          `json:"triggerCount"`
 	Strategy     AdaptiveStrategy `json:"strategy"`
 }
 
-func (r *SystemRule) String() string {
+func (r *Rule) String() string {
 	b, err := json.Marshal(r)
 	if err != nil {
 		// Return the fallback string
-		return fmt.Sprintf("SystemRule{metricType=%s, triggerCount=%.2f, adaptiveStrategy=%s}",
+		return fmt.Sprintf("Rule{metricType=%s, triggerCount=%.2f, adaptiveStrategy=%s}",
 			r.MetricType, r.TriggerCount, r.Strategy)
 	}
 	return string(b)
 }
 
-func (r *SystemRule) ResourceName() string {
+func (r *Rule) ResourceName() string {
 	return r.MetricType.String()
 }
diff --git a/core/system/rule_manager.go b/core/system/rule_manager.go
@@ -8,7 +8,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-type RuleMap map[MetricType][]*SystemRule
+type RuleMap map[MetricType][]*Rule
 
 // const
 var (
@@ -17,19 +17,19 @@ var (
 )
 
 // GetRules return all the rules
-func GetRules() []*SystemRule {
+func GetRules() []*Rule {
 	ruleMapMux.RLock()
 	defer ruleMapMux.RUnlock()
 
-	rules := make([]*SystemRule, 0)
+	rules := make([]*Rule, 0)
 	for _, rs := range ruleMap {
 		rules = append(rules, rs...)
 	}
 	return rules
 }
 
 // LoadRules loads given system rules to the rule manager, while all previous rules will be replaced.
-func LoadRules(rules []*SystemRule) (bool, error) {
+func LoadRules(rules []*Rule) (bool, error) {
 	m := buildRuleMap(rules)
 
 	if err := onRuleUpdate(m); err != nil {
@@ -62,7 +62,7 @@ func onRuleUpdate(r RuleMap) error {
 	return nil
 }
 
-func buildRuleMap(rules []*SystemRule) RuleMap {
+func buildRuleMap(rules []*Rule) RuleMap {
 	m := make(RuleMap)
 
 	if len(rules) == 0 {
@@ -76,7 +76,7 @@ func buildRuleMap(rules []*SystemRule) RuleMap {
 		}
 		rulesOfRes, exists := m[rule.MetricType]
 		if !exists {
-			m[rule.MetricType] = []*SystemRule{rule}
+			m[rule.MetricType] = []*Rule{rule}
 		} else {
 			m[rule.MetricType] = append(rulesOfRes, rule)
 		}
@@ -85,9 +85,9 @@ func buildRuleMap(rules []*SystemRule) RuleMap {
 }
 
 // IsValidSystemRule determine the system rule is valid or not
-func IsValidSystemRule(rule *SystemRule) error {
+func IsValidSystemRule(rule *Rule) error {
 	if rule == nil {
-		return errors.New("nil SystemRule")
+		return errors.New("nil Rule")
 	}
 	if rule.TriggerCount < 0 {
 		return errors.New("negative threshold")
diff --git a/core/system/rule_manager_test.go b/core/system/rule_manager_test.go
@@ -15,15 +15,15 @@ func TestGetRules(t *testing.T) {
 	t.Run("GetUpdatedRules", func(t *testing.T) {
 		defer func() { ruleMap = make(RuleMap) }()
 
-		r := map[MetricType][]*SystemRule{
-			InboundQPS:  {&SystemRule{MetricType: InboundQPS, TriggerCount: 1}},
-			Concurrency: {&SystemRule{MetricType: Concurrency, TriggerCount: 2}},
+		r := map[MetricType][]*Rule{
+			InboundQPS:  {&Rule{MetricType: InboundQPS, TriggerCount: 1}},
+			Concurrency: {&Rule{MetricType: Concurrency, TriggerCount: 2}},
 		}
 		ruleMap = r
 		rules := GetRules()
 		assert.Equal(t, 2, len(rules))
 
-		r[InboundQPS] = append(r[InboundQPS], &SystemRule{MetricType: InboundQPS, TriggerCount: 2})
+		r[InboundQPS] = append(r[InboundQPS], &Rule{MetricType: InboundQPS, TriggerCount: 2})
 		ruleMap = r
 		rules = GetRules()
 		assert.Equal(t, 3, len(rules))
@@ -40,7 +40,7 @@ func TestLoadRules(t *testing.T) {
 
 	t.Run("ValidSystemRule", func(t *testing.T) {
 		defer func() { ruleMap = make(RuleMap) }()
-		sRule := []*SystemRule{
+		sRule := []*Rule{
 			{MetricType: InboundQPS, TriggerCount: 1},
 			{MetricType: Concurrency, TriggerCount: 2},
 		}
@@ -59,9 +59,9 @@ func TestClearRules(t *testing.T) {
 	})
 
 	t.Run("NoEmptyOriginRuleMap", func(t *testing.T) {
-		r := map[MetricType][]*SystemRule{
-			InboundQPS:  {&SystemRule{MetricType: InboundQPS, TriggerCount: 1}},
-			Concurrency: {&SystemRule{MetricType: Concurrency, TriggerCount: 2}},
+		r := map[MetricType][]*Rule{
+			InboundQPS:  {&Rule{MetricType: InboundQPS, TriggerCount: 1}},
+			Concurrency: {&Rule{MetricType: Concurrency, TriggerCount: 2}},
 		}
 		ruleMap = r
 		err := ClearRules()
@@ -80,10 +80,10 @@ func TestOnRuleUpdate(t *testing.T) {
 	t.Run("ValidSystemRule", func(t *testing.T) {
 		defer func() { ruleMap = make(RuleMap) }()
 		rMap := RuleMap{
-			InboundQPS: []*SystemRule{
+			InboundQPS: []*Rule{
 				{MetricType: InboundQPS, TriggerCount: 1},
 			},
-			Concurrency: []*SystemRule{
+			Concurrency: []*Rule{
 				{MetricType: Concurrency, TriggerCount: 2},
 			},
 		}
@@ -100,15 +100,15 @@ func TestBuildRuleMap(t *testing.T) {
 	})
 
 	t.Run("InvalidSystemRule", func(t *testing.T) {
-		sRule := []*SystemRule{
+		sRule := []*Rule{
 			{MetricType: InboundQPS, TriggerCount: -1},
 		}
 		r := buildRuleMap(sRule)
 		assert.Equal(t, 0, len(r))
 	})
 
 	t.Run("ValidSystemRule", func(t *testing.T) {
-		sRule := []*SystemRule{
+		sRule := []*Rule{
 			{MetricType: InboundQPS, TriggerCount: 1},
 			{MetricType: Concurrency, TriggerCount: 2},
 		}
@@ -117,7 +117,7 @@ func TestBuildRuleMap(t *testing.T) {
 	})
 
 	t.Run("MultiRuleOneTypeValidSystemRule", func(t *testing.T) {
-		sRule := []*SystemRule{
+		sRule := []*Rule{
 			{MetricType: InboundQPS, TriggerCount: 1},
 			{MetricType: InboundQPS, TriggerCount: 2},
 		}
@@ -129,29 +129,29 @@ func TestBuildRuleMap(t *testing.T) {
 func TestIsValidSystemRule(t *testing.T) {
 	t.Run("NilSystemRule", func(t *testing.T) {
 		err := IsValidSystemRule(nil)
-		assert.EqualError(t, err, "nil SystemRule")
+		assert.EqualError(t, err, "nil Rule")
 	})
 
 	t.Run("NegativeThreshold", func(t *testing.T) {
-		sRule := &SystemRule{MetricType: InboundQPS, TriggerCount: -1}
+		sRule := &Rule{MetricType: InboundQPS, TriggerCount: -1}
 		err := IsValidSystemRule(sRule)
 		assert.EqualError(t, err, "negative threshold")
 	})
 
 	t.Run("InvalidMetricType", func(t *testing.T) {
-		sRule := &SystemRule{MetricType: MetricTypeSize}
+		sRule := &Rule{MetricType: MetricTypeSize}
 		err := IsValidSystemRule(sRule)
 		assert.EqualError(t, err, "invalid metric type")
 	})
 
 	t.Run("InvalidCPUUsage", func(t *testing.T) {
-		sRule := &SystemRule{MetricType: CpuUsage, TriggerCount: 75}
+		sRule := &Rule{MetricType: CpuUsage, TriggerCount: 75}
 		err := IsValidSystemRule(sRule)
 		assert.EqualError(t, err, "invalid CPU usage, valid range is [0.0, 1.0]")
 	})
 
 	t.Run("ValidSystemRule", func(t *testing.T) {
-		sRule := &SystemRule{MetricType: Load, TriggerCount: 12, Strategy: BBR}
+		sRule := &Rule{MetricType: Load, TriggerCount: 12, Strategy: BBR}
 		err := IsValidSystemRule(sRule)
 		assert.NoError(t, err)
 	})
diff --git a/core/system/rule_test.go b/core/system/rule_test.go
@@ -57,14 +57,14 @@ func TestAdaptiveStrategyString(t *testing.T) {
 
 func TestSystemRuleResourceName(t *testing.T) {
 	t.Run("ValidResourceName", func(t *testing.T) {
-		sr := &SystemRule{MetricType: Concurrency}
+		sr := &Rule{MetricType: Concurrency}
 		assert.Equal(t, "concurrency", sr.ResourceName())
 	})
 }
 
 func TestSystemRuleString(t *testing.T) {
 	t.Run("ValidSystemRuleString", func(t *testing.T) {
-		sr := &SystemRule{MetricType: Concurrency}
-		assert.NotContains(t, sr.String(), "SystemRule")
+		sr := &Rule{MetricType: Concurrency}
+		assert.NotContains(t, sr.String(), "Rule")
 	})
 }
diff --git a/core/system/slot.go b/core/system/slot.go
@@ -31,7 +31,7 @@ func (s *SystemAdaptiveSlot) Check(ctx *base.EntryContext) *base.TokenResult {
 	return result
 }
 
-func (s *SystemAdaptiveSlot) doCheckRule(rule *SystemRule) (bool, float64) {
+func (s *SystemAdaptiveSlot) doCheckRule(rule *Rule) (bool, float64) {
 	threshold := rule.TriggerCount
 	switch rule.MetricType {
 	case InboundQPS:
diff --git a/core/system/slot_test.go b/core/system/slot_test.go
@@ -40,7 +40,7 @@ func TestCheckEmptyRule(t *testing.T) {
 
 func TestDoCheckRuleConcurrency(t *testing.T) {
 	var sas *SystemAdaptiveSlot
-	rule := &SystemRule{MetricType: Concurrency,
+	rule := &Rule{MetricType: Concurrency,
 		TriggerCount: 0.5}
 
 	t.Run("TrueConcurrency", func(t *testing.T) {
@@ -60,7 +60,7 @@ func TestDoCheckRuleConcurrency(t *testing.T) {
 
 func TestDoCheckRuleLoad(t *testing.T) {
 	var sas *SystemAdaptiveSlot
-	rule := &SystemRule{MetricType: Load,
+	rule := &Rule{MetricType: Load,
 		TriggerCount: 0.5}
 
 	t.Run("TrueLoad", func(t *testing.T) {
@@ -81,7 +81,7 @@ func TestDoCheckRuleLoad(t *testing.T) {
 
 func TestDoCheckRuleCpuUsage(t *testing.T) {
 	var sas *SystemAdaptiveSlot
-	rule := &SystemRule{MetricType: CpuUsage,
+	rule := &Rule{MetricType: CpuUsage,
 		TriggerCount: 0.5}
 
 	t.Run("TrueCpuUsage", func(t *testing.T) {
@@ -102,7 +102,7 @@ func TestDoCheckRuleCpuUsage(t *testing.T) {
 
 func TestDoCheckRuleDefault(t *testing.T) {
 	var sas *SystemAdaptiveSlot
-	rule := &SystemRule{MetricType: MetricTypeSize,
+	rule := &Rule{MetricType: MetricTypeSize,
 		TriggerCount: 0.5}
 
 	isOK, v := sas.doCheckRule(rule)
diff --git a/ext/datasource/consul/consul_test.go b/ext/datasource/consul/consul_test.go
@@ -33,7 +33,7 @@ const (
 )
 
 var (
-	SystemRules = []*system.SystemRule{
+	SystemRules = []*system.Rule{
 		{MetricType: 0, Strategy: 0},
 		{MetricType: 0, Strategy: 0},
 		{MetricType: 0, Strategy: 0},
diff --git a/ext/datasource/helper.go b/ext/datasource/helper.go
@@ -61,34 +61,34 @@ func NewFlowRulesHandler(converter PropertyConverter) PropertyHandler {
 	return NewDefaultPropertyHandler(converter, FlowRulesUpdater)
 }
 
-// SystemRuleJsonArrayParser provide JSON  as the default serialization for list of system.SystemRule
+// SystemRuleJsonArrayParser provide JSON  as the default serialization for list of system.Rule
 func SystemRuleJsonArrayParser(src []byte) (interface{}, error) {
 	if valid, err := checkSrcComplianceJson(src); !valid {
 		return nil, err
 	}
 
-	rules := make([]*system.SystemRule, 0)
+	rules := make([]*system.Rule, 0)
 	err := json.Unmarshal(src, &rules)
 	return rules, err
 }
 
-// SystemRulesUpdater load the newest []system.SystemRule to downstream system component.
+// SystemRulesUpdater load the newest []system.Rule to downstream system component.
 func SystemRulesUpdater(data interface{}) error {
 	if data == nil {
 		return system.ClearRules()
 	}
 
-	rules := make([]*system.SystemRule, 0)
-	if val, ok := data.([]system.SystemRule); ok {
+	rules := make([]*system.Rule, 0)
+	if val, ok := data.([]system.Rule); ok {
 		for _, v := range val {
 			rules = append(rules, &v)
 		}
-	} else if val, ok := data.([]*system.SystemRule); ok {
+	} else if val, ok := data.([]*system.Rule); ok {
 		rules = val
 	} else {
 		return Error{
 			code: UpdatePropertyError,
-			desc: fmt.Sprintf("Fail to type assert data to []system.SystemRule or []*system.SystemRule, in fact, data: %+v", data),
+			desc: fmt.Sprintf("Fail to type assert data to []system.Rule or []*system.Rule, in fact, data: %+v", data),
 		}
 	}
 	succ, err := system.LoadRules(rules)
diff --git a/ext/datasource/helper_test.go b/ext/datasource/helper_test.go
@@ -155,25 +155,25 @@ func TestSystemRulesJsonConvert(t *testing.T) {
 	}
 
 	got, err := SystemRuleJsonArrayParser(normalSrc)
-	systemRules := got.([]*system.SystemRule)
+	systemRules := got.([]*system.Rule)
 	assert.True(t, err == nil && len(systemRules) == 4)
 
-	r0 := &system.SystemRule{
+	r0 := &system.Rule{
 		MetricType:   system.Load,
 		TriggerCount: 0.5,
 		Strategy:     system.BBR,
 	}
-	r1 := &system.SystemRule{
+	r1 := &system.Rule{
 		MetricType:   system.AvgRT,
 		TriggerCount: 0.6,
 		Strategy:     system.BBR,
 	}
-	r2 := &system.SystemRule{
+	r2 := &system.Rule{
 		MetricType:   system.Concurrency,
 		TriggerCount: 0.7,
 		Strategy:     system.BBR,
 	}
-	r3 := &system.SystemRule{
+	r3 := &system.Rule{
 		MetricType:   system.InboundQPS,
 		TriggerCount: 0.8,
 		Strategy:     system.BBR,
@@ -188,7 +188,7 @@ func TestSystemRulesJsonConvert(t *testing.T) {
 func TestSystemRulesUpdater(t *testing.T) {
 	t.Run("TestSystemRulesUpdater_Nil", func(t *testing.T) {
 		system.ClearRules()
-		system.LoadRules([]*system.SystemRule{
+		system.LoadRules([]*system.Rule{
 			{
 				ID:           0,
 				MetricType:   0,
@@ -204,20 +204,20 @@ func TestSystemRulesUpdater(t *testing.T) {
 	t.Run("TestSystemRulesUpdater_Assert_Failed", func(t *testing.T) {
 		system.ClearRules()
 		err := SystemRulesUpdater("xxxxxxxx")
-		assert.True(t, err != nil && strings.Contains(err.Error(), "Fail to type assert data to []system.SystemRule"))
+		assert.True(t, err != nil && strings.Contains(err.Error(), "Fail to type assert data to []system.Rule"))
 	})
 
 	t.Run("TestSystemRulesUpdater_Empty_Rules", func(t *testing.T) {
 		system.ClearRules()
-		p := make([]system.SystemRule, 0)
+		p := make([]system.Rule, 0)
 		err := SystemRulesUpdater(p)
 		assert.True(t, err == nil && len(system.GetRules()) == 0)
 	})
 
 	t.Run("TestSystemRulesUpdater_Normal", func(t *testing.T) {
 		system.ClearRules()
-		p := make([]system.SystemRule, 0)
-		sr := system.SystemRule{
+		p := make([]system.Rule, 0)
+		sr := system.Rule{
 			ID:           0,
 			MetricType:   0,
 			TriggerCount: 0,
diff --git a/ext/datasource/property_test.go b/ext/datasource/property_test.go

Original file line number	Diff line number	Diff line change
`@@ -56,24 +56,24 @@ func (t AdaptiveStrategy) String() string {`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`-type SystemRule struct {`
	`59`	`+type Rule struct {`
`60`	`60`	ID uint64 `json:"id,omitempty"`
`61`	`61`
`62`	`62`	MetricType MetricType `json:"metricType"`
`63`	`63`	TriggerCount float64 `json:"triggerCount"`
`64`	`64`	Strategy AdaptiveStrategy `json:"strategy"`
`65`	`65`	`}`
`66`	`66`
`67`		`-func (r *SystemRule) String() string {`
	`67`	`+func (r *Rule) String() string {`
`68`	`68`	`b, err := json.Marshal(r)`
`69`	`69`	`if err != nil {`
`70`	`70`	`// Return the fallback string`
`71`		`- return fmt.Sprintf("SystemRule{metricType=%s, triggerCount=%.2f, adaptiveStrategy=%s}",`
	`71`	`+ return fmt.Sprintf("Rule{metricType=%s, triggerCount=%.2f, adaptiveStrategy=%s}",`
`72`	`72`	`r.MetricType, r.TriggerCount, r.Strategy)`
`73`	`73`	`}`
`74`	`74`	`return string(b)`
`75`	`75`	`}`
`76`	`76`
`77`		`-func (r *SystemRule) ResourceName() string {`
	`77`	`+func (r *Rule) ResourceName() string {`
`78`	`78`	`return r.MetricType.String()`
`79`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ import (`
`8`	`8`	`"github.com/pkg/errors"`
`9`	`9`	`)`
`10`	`10`
`11`		`-type RuleMap map[MetricType][]*SystemRule`
	`11`	`+type RuleMap map[MetricType][]*Rule`
`12`	`12`
`13`	`13`	`// const`
`14`	`14`	`var (`
`@@ -17,19 +17,19 @@ var (`
`17`	`17`	`)`
`18`	`18`
`19`	`19`	`// GetRules return all the rules`
`20`		`-func GetRules() []*SystemRule {`
	`20`	`+func GetRules() []*Rule {`
`21`	`21`	`ruleMapMux.RLock()`
`22`	`22`	`defer ruleMapMux.RUnlock()`
`23`	`23`
`24`		`- rules := make([]*SystemRule, 0)`
	`24`	`+ rules := make([]*Rule, 0)`
`25`	`25`	`for _, rs := range ruleMap {`
`26`	`26`	`rules = append(rules, rs...)`
`27`	`27`	`}`
`28`	`28`	`return rules`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`// LoadRules loads given system rules to the rule manager, while all previous rules will be replaced.`
`32`		`-func LoadRules(rules []*SystemRule) (bool, error) {`
	`32`	`+func LoadRules(rules []*Rule) (bool, error) {`
`33`	`33`	`m := buildRuleMap(rules)`
`34`	`34`
`35`	`35`	`if err := onRuleUpdate(m); err != nil {`
`@@ -62,7 +62,7 @@ func onRuleUpdate(r RuleMap) error {`
`62`	`62`	`return nil`
`63`	`63`	`}`
`64`	`64`
`65`		`-func buildRuleMap(rules []*SystemRule) RuleMap {`
	`65`	`+func buildRuleMap(rules []*Rule) RuleMap {`
`66`	`66`	`m := make(RuleMap)`
`67`	`67`
`68`	`68`	`if len(rules) == 0 {`
`@@ -76,7 +76,7 @@ func buildRuleMap(rules []*SystemRule) RuleMap {`
`76`	`76`	`}`
`77`	`77`	`rulesOfRes, exists := m[rule.MetricType]`
`78`	`78`	`if !exists {`
`79`		`- m[rule.MetricType] = []*SystemRule{rule}`
	`79`	`+ m[rule.MetricType] = []*Rule{rule}`
`80`	`80`	`} else {`
`81`	`81`	`m[rule.MetricType] = append(rulesOfRes, rule)`
`82`	`82`	`}`
`@@ -85,9 +85,9 @@ func buildRuleMap(rules []*SystemRule) RuleMap {`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`// IsValidSystemRule determine the system rule is valid or not`
`88`		`-func IsValidSystemRule(rule *SystemRule) error {`
	`88`	`+func IsValidSystemRule(rule *Rule) error {`
`89`	`89`	`if rule == nil {`
`90`		`- return errors.New("nil SystemRule")`
	`90`	`+ return errors.New("nil Rule")`
`91`	`91`	`}`
`92`	`92`	`if rule.TriggerCount < 0 {`
`93`	`93`	`return errors.New("negative threshold")`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ func (s SystemAdaptiveSlot) Check(ctx base.EntryContext) *base.TokenResult {`
`31`	`31`	`return result`
`32`	`32`	`}`
`33`	`33`
`34`		`-func (s SystemAdaptiveSlot) doCheckRule(rule SystemRule) (bool, float64) {`
	`34`	`+func (s SystemAdaptiveSlot) doCheckRule(rule Rule) (bool, float64) {`
`35`	`35`	`threshold := rule.TriggerCount`
`36`	`36`	`switch rule.MetricType {`
`37`	`37`	`case InboundQPS:`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ const (`
`33`	`33`	`)`
`34`	`34`
`35`	`35`	`var (`
`36`		`- SystemRules = []*system.SystemRule{`
	`36`	`+ SystemRules = []*system.Rule{`
`37`	`37`	`{MetricType: 0, Strategy: 0},`
`38`	`38`	`{MetricType: 0, Strategy: 0},`
`39`	`39`	`{MetricType: 0, Strategy: 0},`
Original file line number	Diff line number	Diff line change
`@@ -61,34 +61,34 @@ func NewFlowRulesHandler(converter PropertyConverter) PropertyHandler {`
`61`	`61`	`return NewDefaultPropertyHandler(converter, FlowRulesUpdater)`
`62`	`62`	`}`
`63`	`63`
`64`		`-// SystemRuleJsonArrayParser provide JSON as the default serialization for list of system.SystemRule`
	`64`	`+// SystemRuleJsonArrayParser provide JSON as the default serialization for list of system.Rule`
`65`	`65`	`func SystemRuleJsonArrayParser(src []byte) (interface{}, error) {`
`66`	`66`	`if valid, err := checkSrcComplianceJson(src); !valid {`
`67`	`67`	`return nil, err`
`68`	`68`	`}`
`69`	`69`
`70`		`- rules := make([]*system.SystemRule, 0)`
	`70`	`+ rules := make([]*system.Rule, 0)`
`71`	`71`	`err := json.Unmarshal(src, &rules)`
`72`	`72`	`return rules, err`
`73`	`73`	`}`
`74`	`74`
`75`		`-// SystemRulesUpdater load the newest []system.SystemRule to downstream system component.`
	`75`	`+// SystemRulesUpdater load the newest []system.Rule to downstream system component.`
`76`	`76`	`func SystemRulesUpdater(data interface{}) error {`
`77`	`77`	`if data == nil {`
`78`	`78`	`return system.ClearRules()`
`79`	`79`	`}`
`80`	`80`
`81`		`- rules := make([]*system.SystemRule, 0)`
`82`		`- if val, ok := data.([]system.SystemRule); ok {`
	`81`	`+ rules := make([]*system.Rule, 0)`
	`82`	`+ if val, ok := data.([]system.Rule); ok {`
`83`	`83`	`for _, v := range val {`
`84`	`84`	`rules = append(rules, &v)`
`85`	`85`	`}`
`86`		`- } else if val, ok := data.([]*system.SystemRule); ok {`
	`86`	`+ } else if val, ok := data.([]*system.Rule); ok {`
`87`	`87`	`rules = val`
`88`	`88`	`} else {`
`89`	`89`	`return Error{`
`90`	`90`	`code: UpdatePropertyError,`
`91`		`- desc: fmt.Sprintf("Fail to type assert data to []system.SystemRule or []*system.SystemRule, in fact, data: %+v", data),`
	`91`	`+ desc: fmt.Sprintf("Fail to type assert data to []system.Rule or []*system.Rule, in fact, data: %+v", data),`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`	`succ, err := system.LoadRules(rules)`