Refine naming of core slots (#231)

louyuting · web-flow · commit bd07b4b1e48a · 2020-09-09T00:24:28.000+08:00
diff --git a/api/slot_chain.go b/api/slot_chain.go
@@ -27,13 +27,13 @@ func GlobalSlotChain() *base.SlotChain {
 
 func BuildDefaultSlotChain() *base.SlotChain {
 	sc := base.NewSlotChain()
-	sc.AddStatPrepareSlotLast(&stat.StatNodePrepareSlot{})
-	sc.AddRuleCheckSlotLast(&system.SystemAdaptiveSlot{})
-	sc.AddRuleCheckSlotLast(&flow.FlowSlot{})
+	sc.AddStatPrepareSlotLast(&stat.ResourceNodePrepareSlot{})
+	sc.AddRuleCheckSlotLast(&system.AdaptiveSlot{})
+	sc.AddRuleCheckSlotLast(&flow.Slot{})
 	sc.AddRuleCheckSlotLast(&circuitbreaker.Slot{})
 	sc.AddRuleCheckSlotLast(&hotspot.Slot{})
-	sc.AddStatSlotLast(&stat.StatisticSlot{})
-	sc.AddStatSlotLast(&log.LogSlot{})
+	sc.AddStatSlotLast(&stat.Slot{})
+	sc.AddStatSlotLast(&log.Slot{})
 	sc.AddStatSlotLast(&circuitbreaker.MetricStatSlot{})
 	sc.AddStatSlotLast(&hotspot.ConcurrencyStatSlot{})
 	return sc
diff --git a/core/flow/slot.go b/core/flow/slot.go
@@ -8,11 +8,10 @@ import (
 	"github.com/alibaba/sentinel-golang/logging"
 )
 
-// FlowSlot
-type FlowSlot struct {
+type Slot struct {
 }
 
-func (s *FlowSlot) Check(ctx *base.EntryContext) *base.TokenResult {
+func (s *Slot) Check(ctx *base.EntryContext) *base.TokenResult {
 	res := ctx.Resource.Name()
 	tcs := getTrafficControllerListFor(res)
 	result := ctx.RuleCheckResult
diff --git a/core/log/slot.go b/core/log/slot.go
@@ -4,17 +4,17 @@ import (
 	"github.com/alibaba/sentinel-golang/core/base"
 )
 
-type LogSlot struct {
+type Slot struct {
 }
 
-func (s *LogSlot) OnEntryPassed(_ *base.EntryContext) {
+func (s *Slot) OnEntryPassed(_ *base.EntryContext) {
 
 }
 
-func (s *LogSlot) OnEntryBlocked(ctx *base.EntryContext, blockError *base.BlockError) {
+func (s *Slot) OnEntryBlocked(ctx *base.EntryContext, blockError *base.BlockError) {
 	// TODO: write sentinel-block.log here
 }
 
-func (s *LogSlot) OnCompleted(_ *base.EntryContext) {
+func (s *Slot) OnCompleted(_ *base.EntryContext) {
 
 }
diff --git a/core/stat/resource_node.go b/core/stat/resource_node.go
@@ -1,31 +1,23 @@
 package stat
 
 import (
-	"fmt"
-	"sync"
-
 	"github.com/alibaba/sentinel-golang/core/base"
-	sbase "github.com/alibaba/sentinel-golang/core/stat/base"
 )
 
 type ResourceNode struct {
 	BaseStatNode
 
 	resourceName string
 	resourceType base.ResourceType
-	// key is "sampleCount/intervalInMs"
-	readOnlyStats map[string]*sbase.SlidingWindowMetric
-	updateLock    sync.RWMutex
 }
 
 // NewResourceNode creates a new resource node with given name and classification.
 func NewResourceNode(resourceName string, resourceType base.ResourceType) *ResourceNode {
 	return &ResourceNode{
 		// TODO: make this configurable
-		BaseStatNode:  *NewBaseStatNode(base.DefaultSampleCount, base.DefaultIntervalMs),
-		resourceName:  resourceName,
-		resourceType:  resourceType,
-		readOnlyStats: make(map[string]*sbase.SlidingWindowMetric),
+		BaseStatNode: *NewBaseStatNode(base.DefaultSampleCount, base.DefaultIntervalMs),
+		resourceName: resourceName,
+		resourceType: resourceType,
 	}
 }
 
@@ -36,30 +28,3 @@ func (n *ResourceNode) ResourceType() base.ResourceType {
 func (n *ResourceNode) ResourceName() string {
 	return n.resourceName
 }
-
-func (n *ResourceNode) GetSlidingWindowMetric(key string) *sbase.SlidingWindowMetric {
-	n.updateLock.RLock()
-	defer n.updateLock.RUnlock()
-	return n.readOnlyStats[key]
-}
-
-func (n *ResourceNode) GetOrCreateSlidingWindowMetric(sampleCount, intervalInMs uint32) *sbase.SlidingWindowMetric {
-	key := fmt.Sprintf("%d/%d", sampleCount, intervalInMs)
-	fastVal := n.GetSlidingWindowMetric(key)
-	if fastVal != nil {
-		return fastVal
-	}
-
-	n.updateLock.Lock()
-	defer n.updateLock.Unlock()
-
-	v, exist := n.readOnlyStats[key]
-	if exist {
-		return v
-	}
-
-	newSlidingWindow := sbase.NewSlidingWindowMetric(sampleCount, intervalInMs, n.arr)
-	n.readOnlyStats[key] = newSlidingWindow
-	// TODO clean unused entity in readOnlyStats.
-	return newSlidingWindow
-}
diff --git a/core/stat/resource_node_test.go b/core/stat/resource_node_test.go
diff --git a/core/stat/stat_prepare_slot.go b/core/stat/stat_prepare_slot.go
@@ -4,10 +4,10 @@ import (
 	"github.com/alibaba/sentinel-golang/core/base"
 )
 
-type StatNodePrepareSlot struct {
+type ResourceNodePrepareSlot struct {
 }
 
-func (s *StatNodePrepareSlot) Prepare(ctx *base.EntryContext) {
+func (s *ResourceNodePrepareSlot) Prepare(ctx *base.EntryContext) {
 	node := GetOrCreateResourceNode(ctx.Resource.Name(), ctx.Resource.Classification())
 	// Set the resource node to the context.
 	ctx.StatNode = node
diff --git a/core/stat/stat_slot.go b/core/stat/stat_slot.go
@@ -5,30 +5,24 @@ import (
 	"github.com/alibaba/sentinel-golang/util"
 )
 
-const SlotName = "StatisticSlot"
-
-type StatisticSlot struct {
-}
-
-func (s *StatisticSlot) String() string {
-	return SlotName
+type Slot struct {
 }
 
-func (s *StatisticSlot) OnEntryPassed(ctx *base.EntryContext) {
+func (s *Slot) OnEntryPassed(ctx *base.EntryContext) {
 	s.recordPassFor(ctx.StatNode, ctx.Input.AcquireCount)
 	if ctx.Resource.FlowType() == base.Inbound {
 		s.recordPassFor(InboundNode(), ctx.Input.AcquireCount)
 	}
 }
 
-func (s *StatisticSlot) OnEntryBlocked(ctx *base.EntryContext, blockError *base.BlockError) {
+func (s *Slot) OnEntryBlocked(ctx *base.EntryContext, blockError *base.BlockError) {
 	s.recordBlockFor(ctx.StatNode, ctx.Input.AcquireCount)
 	if ctx.Resource.FlowType() == base.Inbound {
 		s.recordBlockFor(InboundNode(), ctx.Input.AcquireCount)
 	}
 }
 
-func (s *StatisticSlot) OnCompleted(ctx *base.EntryContext) {
+func (s *Slot) OnCompleted(ctx *base.EntryContext) {
 	rt := util.CurrentTimeMillis() - ctx.StartTime()
 	ctx.PutRt(rt)
 	s.recordCompleteFor(ctx.StatNode, ctx.Input.AcquireCount, rt, ctx.Err())
@@ -37,22 +31,22 @@ func (s *StatisticSlot) OnCompleted(ctx *base.EntryContext) {
 	}
 }
 
-func (s *StatisticSlot) recordPassFor(sn base.StatNode, count uint32) {
+func (s *Slot) recordPassFor(sn base.StatNode, count uint32) {
 	if sn == nil {
 		return
 	}
 	sn.IncreaseGoroutineNum()
 	sn.AddMetric(base.MetricEventPass, uint64(count))
 }
 
-func (s *StatisticSlot) recordBlockFor(sn base.StatNode, count uint32) {
+func (s *Slot) recordBlockFor(sn base.StatNode, count uint32) {
 	if sn == nil {
 		return
 	}
 	sn.AddMetric(base.MetricEventBlock, uint64(count))
 }
 
-func (s *StatisticSlot) recordCompleteFor(sn base.StatNode, count uint32, rt uint64, err error) {
+func (s *Slot) recordCompleteFor(sn base.StatNode, count uint32, rt uint64, err error) {
 	if sn == nil {
 		return
 	}
diff --git a/core/system/slot.go b/core/system/slot.go
@@ -5,10 +5,10 @@ import (
 	"github.com/alibaba/sentinel-golang/core/stat"
 )
 
-type SystemAdaptiveSlot struct {
+type AdaptiveSlot struct {
 }
 
-func (s *SystemAdaptiveSlot) Check(ctx *base.EntryContext) *base.TokenResult {
+func (s *AdaptiveSlot) Check(ctx *base.EntryContext) *base.TokenResult {
 	if ctx == nil || ctx.Resource == nil || ctx.Resource.FlowType() != base.Inbound {
 		return nil
 	}
@@ -29,7 +29,7 @@ func (s *SystemAdaptiveSlot) Check(ctx *base.EntryContext) *base.TokenResult {
 	return result
 }
 
-func (s *SystemAdaptiveSlot) doCheckRule(rule *Rule) (bool, float64) {
+func (s *AdaptiveSlot) 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
@@ -9,7 +9,7 @@ import (
 )
 
 func TestCheckNilInput(t *testing.T) {
-	var sas *SystemAdaptiveSlot
+	var sas *AdaptiveSlot
 
 	t.Run("NilInput", func(t *testing.T) {
 		r := sas.Check(nil)
@@ -29,7 +29,7 @@ func TestCheckNilInput(t *testing.T) {
 }
 
 func TestCheckEmptyRule(t *testing.T) {
-	var sas *SystemAdaptiveSlot
+	var sas *AdaptiveSlot
 	rw := base.NewResourceWrapper("test", base.ResTypeCommon, base.Inbound)
 	r := sas.Check(&base.EntryContext{
 		Resource:        rw,
@@ -39,7 +39,7 @@ func TestCheckEmptyRule(t *testing.T) {
 }
 
 func TestDoCheckRuleConcurrency(t *testing.T) {
-	var sas *SystemAdaptiveSlot
+	var sas *AdaptiveSlot
 	rule := &Rule{MetricType: Concurrency,
 		TriggerCount: 0.5}
 
@@ -59,7 +59,7 @@ func TestDoCheckRuleConcurrency(t *testing.T) {
 }
 
 func TestDoCheckRuleLoad(t *testing.T) {
-	var sas *SystemAdaptiveSlot
+	var sas *AdaptiveSlot
 	rule := &Rule{MetricType: Load,
 		TriggerCount: 0.5}
 
@@ -80,7 +80,7 @@ func TestDoCheckRuleLoad(t *testing.T) {
 }
 
 func TestDoCheckRuleCpuUsage(t *testing.T) {
-	var sas *SystemAdaptiveSlot
+	var sas *AdaptiveSlot
 	rule := &Rule{MetricType: CpuUsage,
 		TriggerCount: 0.5}
 
@@ -101,7 +101,7 @@ func TestDoCheckRuleCpuUsage(t *testing.T) {
 }
 
 func TestDoCheckRuleDefault(t *testing.T) {
-	var sas *SystemAdaptiveSlot
+	var sas *AdaptiveSlot
 	rule := &Rule{MetricType: MetricTypeSize,
 		TriggerCount: 0.5}
 

Original file line number	Diff line number	Diff line change
`@@ -8,11 +8,10 @@ import (`
`8`	`8`	`"github.com/alibaba/sentinel-golang/logging"`
`9`	`9`	`)`
`10`	`10`
`11`		`-// FlowSlot`
`12`		`-type FlowSlot struct {`
	`11`	`+type Slot struct {`
`13`	`12`	`}`
`14`	`13`
`15`		`-func (s FlowSlot) Check(ctx base.EntryContext) *base.TokenResult {`
	`14`	`+func (s Slot) Check(ctx base.EntryContext) *base.TokenResult {`
`16`	`15`	`res := ctx.Resource.Name()`
`17`	`16`	`tcs := getTrafficControllerListFor(res)`
`18`	`17`	`result := ctx.RuleCheckResult`
Original file line number	Diff line number	Diff line change
`@@ -4,17 +4,17 @@ import (`
`4`	`4`	`"github.com/alibaba/sentinel-golang/core/base"`
`5`	`5`	`)`
`6`	`6`
`7`		`-type LogSlot struct {`
	`7`	`+type Slot struct {`
`8`	`8`	`}`
`9`	`9`
`10`		`-func (s LogSlot) OnEntryPassed(_ base.EntryContext) {`
	`10`	`+func (s Slot) OnEntryPassed(_ base.EntryContext) {`
`11`	`11`
`12`	`12`	`}`
`13`	`13`
`14`		`-func (s LogSlot) OnEntryBlocked(ctx base.EntryContext, blockError *base.BlockError) {`
	`14`	`+func (s Slot) OnEntryBlocked(ctx base.EntryContext, blockError *base.BlockError) {`
`15`	`15`	`// TODO: write sentinel-block.log here`
`16`	`16`	`}`
`17`	`17`
`18`		`-func (s LogSlot) OnCompleted(_ base.EntryContext) {`
	`18`	`+func (s Slot) OnCompleted(_ base.EntryContext) {`
`19`	`19`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,10 @@ import (`
`4`	`4`	`"github.com/alibaba/sentinel-golang/core/base"`
`5`	`5`	`)`
`6`	`6`
`7`		`-type StatNodePrepareSlot struct {`
	`7`	`+type ResourceNodePrepareSlot struct {`
`8`	`8`	`}`
`9`	`9`
`10`		`-func (s StatNodePrepareSlot) Prepare(ctx base.EntryContext) {`
	`10`	`+func (s ResourceNodePrepareSlot) Prepare(ctx base.EntryContext) {`
`11`	`11`	`node := GetOrCreateResourceNode(ctx.Resource.Name(), ctx.Resource.Classification())`
`12`	`12`	`// Set the resource node to the context.`
`13`	`13`	`ctx.StatNode = node`
Original file line number	Diff line number	Diff line change
`@@ -5,30 +5,24 @@ import (`
`5`	`5`	`"github.com/alibaba/sentinel-golang/util"`
`6`	`6`	`)`
`7`	`7`
`8`		`-const SlotName = "StatisticSlot"`
`9`		`-`
`10`		`-type StatisticSlot struct {`
`11`		`-}`
`12`		`-`
`13`		`-func (s *StatisticSlot) String() string {`
`14`		`- return SlotName`
	`8`	`+type Slot struct {`
`15`	`9`	`}`
`16`	`10`
`17`		`-func (s StatisticSlot) OnEntryPassed(ctx base.EntryContext) {`
	`11`	`+func (s Slot) OnEntryPassed(ctx base.EntryContext) {`
`18`	`12`	`s.recordPassFor(ctx.StatNode, ctx.Input.AcquireCount)`
`19`	`13`	`if ctx.Resource.FlowType() == base.Inbound {`
`20`	`14`	`s.recordPassFor(InboundNode(), ctx.Input.AcquireCount)`
`21`	`15`	`}`
`22`	`16`	`}`
`23`	`17`
`24`		`-func (s StatisticSlot) OnEntryBlocked(ctx base.EntryContext, blockError *base.BlockError) {`
	`18`	`+func (s Slot) OnEntryBlocked(ctx base.EntryContext, blockError *base.BlockError) {`
`25`	`19`	`s.recordBlockFor(ctx.StatNode, ctx.Input.AcquireCount)`
`26`	`20`	`if ctx.Resource.FlowType() == base.Inbound {`
`27`	`21`	`s.recordBlockFor(InboundNode(), ctx.Input.AcquireCount)`
`28`	`22`	`}`
`29`	`23`	`}`
`30`	`24`
`31`		`-func (s StatisticSlot) OnCompleted(ctx base.EntryContext) {`
	`25`	`+func (s Slot) OnCompleted(ctx base.EntryContext) {`
`32`	`26`	`rt := util.CurrentTimeMillis() - ctx.StartTime()`
`33`	`27`	`ctx.PutRt(rt)`
`34`	`28`	`s.recordCompleteFor(ctx.StatNode, ctx.Input.AcquireCount, rt, ctx.Err())`
`@@ -37,22 +31,22 @@ func (s StatisticSlot) OnCompleted(ctx base.EntryContext) {`
`37`	`31`	`}`
`38`	`32`	`}`
`39`	`33`
`40`		`-func (s *StatisticSlot) recordPassFor(sn base.StatNode, count uint32) {`
	`34`	`+func (s *Slot) recordPassFor(sn base.StatNode, count uint32) {`
`41`	`35`	`if sn == nil {`
`42`	`36`	`return`
`43`	`37`	`}`
`44`	`38`	`sn.IncreaseGoroutineNum()`
`45`	`39`	`sn.AddMetric(base.MetricEventPass, uint64(count))`
`46`	`40`	`}`
`47`	`41`
`48`		`-func (s *StatisticSlot) recordBlockFor(sn base.StatNode, count uint32) {`
	`42`	`+func (s *Slot) recordBlockFor(sn base.StatNode, count uint32) {`
`49`	`43`	`if sn == nil {`
`50`	`44`	`return`
`51`	`45`	`}`
`52`	`46`	`sn.AddMetric(base.MetricEventBlock, uint64(count))`
`53`	`47`	`}`
`54`	`48`
`55`		`-func (s *StatisticSlot) recordCompleteFor(sn base.StatNode, count uint32, rt uint64, err error) {`
	`49`	`+func (s *Slot) recordCompleteFor(sn base.StatNode, count uint32, rt uint64, err error) {`
`56`	`50`	`if sn == nil {`
`57`	`51`	`return`
`58`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,10 +5,10 @@ import (`
`5`	`5`	`"github.com/alibaba/sentinel-golang/core/stat"`
`6`	`6`	`)`
`7`	`7`
`8`		`-type SystemAdaptiveSlot struct {`
	`8`	`+type AdaptiveSlot struct {`
`9`	`9`	`}`
`10`	`10`
`11`		`-func (s SystemAdaptiveSlot) Check(ctx base.EntryContext) *base.TokenResult {`
	`11`	`+func (s AdaptiveSlot) Check(ctx base.EntryContext) *base.TokenResult {`
`12`	`12`	`if ctx == nil \|\| ctx.Resource == nil \|\| ctx.Resource.FlowType() != base.Inbound {`
`13`	`13`	`return nil`
`14`	`14`	`}`
`@@ -29,7 +29,7 @@ func (s SystemAdaptiveSlot) Check(ctx base.EntryContext) *base.TokenResult {`
`29`	`29`	`return result`
`30`	`30`	`}`
`31`	`31`
`32`		`-func (s SystemAdaptiveSlot) doCheckRule(rule Rule) (bool, float64) {`
	`32`	`+func (s AdaptiveSlot) doCheckRule(rule Rule) (bool, float64) {`
`33`	`33`	`threshold := rule.TriggerCount`
`34`	`34`	`switch rule.MetricType {`
`35`	`35`	`case InboundQPS:`