From 3a6a4e03a197ccb0f16cb51594a3d7994bee580c Mon Sep 17 00:00:00 2001 From: husharp Date: Fri, 14 Jul 2023 11:34:01 +0800 Subject: [PATCH] update config name Signed-off-by: husharp --- client/resource_group/controller/config.go | 28 +++++----- .../resource_group/controller/controller.go | 54 +++++++++---------- .../controller/controller_test.go | 2 +- client/resource_group/controller/model.go | 12 ++--- .../resourcemanager/resource_manager_test.go | 6 +-- 5 files changed, 51 insertions(+), 51 deletions(-) diff --git a/client/resource_group/controller/config.go b/client/resource_group/controller/config.go index cbf0be54c8d..2095bc60601 100644 --- a/client/resource_group/controller/config.go +++ b/client/resource_group/controller/config.go @@ -77,8 +77,8 @@ const ( defaultAvgBatchProportion = 0.7 ) -// ControllerConfig is the configuration of the resource manager controller which includes some option for client needed. -type ControllerConfig struct { +// Config is the configuration of the resource manager controller which includes some option for client needed. +type Config struct { // EnableDegradedMode is to control whether resource control client enable degraded mode when server is disconnect. DegradedModeWaitDuration string `toml:"degraded-mode-wait-duration" json:"degraded-mode-wait-duration"` @@ -87,9 +87,9 @@ type ControllerConfig struct { RequestUnit RequestUnitConfig `toml:"request-unit" json:"request-unit"` } -// DefaultControllerConfig returns the default resource manager controller configuration. -func DefaultControllerConfig() *ControllerConfig { - return &ControllerConfig{ +// DefaultConfig returns the default resource manager controller configuration. +func DefaultConfig() *Config { + return &Config{ DegradedModeWaitDuration: defaultDegradedModeWaitDuration, RequestUnit: DefaultRequestUnitConfig(), } @@ -130,10 +130,10 @@ func DefaultRequestUnitConfig() RequestUnitConfig { } } -// Config is the configuration of the resource units, which gives the read/write request +// RUConfig is the configuration of the resource units, which gives the read/write request // units or request resource cost standards. It should be calculated by a given `RequestUnitConfig` // or `RequestResourceConfig`. -type Config struct { +type RUConfig struct { // RU model config ReadBaseCost RequestUnit ReadPerBatchBaseCost RequestUnit @@ -148,16 +148,16 @@ type Config struct { DegradedModeWaitDuration time.Duration } -// DefaultConfig returns the default configuration. -func DefaultConfig() *Config { - return GenerateConfig( - DefaultControllerConfig(), +// DefaultRUConfig returns the default configuration. +func DefaultRUConfig() *RUConfig { + return GenerateRUConfig( + DefaultConfig(), ) } -// GenerateConfig generates the configuration by the given request unit configuration. -func GenerateConfig(config *ControllerConfig) *Config { - cfg := &Config{ +// GenerateRUConfig generates the configuration by the given request unit configuration. +func GenerateRUConfig(config *Config) *RUConfig { + cfg := &RUConfig{ ReadBaseCost: RequestUnit(config.RequestUnit.ReadBaseCost), ReadPerBatchBaseCost: RequestUnit(config.RequestUnit.ReadPerBatchBaseCost), ReadBytesCost: RequestUnit(config.RequestUnit.ReadCostPerByte), diff --git a/client/resource_group/controller/controller.go b/client/resource_group/controller/controller.go index 460a148e510..7eb985af1ba 100755 --- a/client/resource_group/controller/controller.go +++ b/client/resource_group/controller/controller.go @@ -78,25 +78,25 @@ type ResourceControlCreateOption func(controller *ResourceGroupsController) // EnableSingleGroupByKeyspace is the option to enable single group by keyspace feature. func EnableSingleGroupByKeyspace() ResourceControlCreateOption { return func(controller *ResourceGroupsController) { - controller.config.isSingleGroupByKeyspace = true + controller.ruConfig.isSingleGroupByKeyspace = true } } // WithMaxWaitDuration is the option to set the max wait duration for acquiring token buckets. func WithMaxWaitDuration(d time.Duration) ResourceControlCreateOption { return func(controller *ResourceGroupsController) { - controller.config.maxWaitDuration = d + controller.ruConfig.maxWaitDuration = d } } var _ ResourceGroupKVInterceptor = (*ResourceGroupsController)(nil) -// ResourceGroupsController impls ResourceGroupKVInterceptor. +// ResourceGroupsController implements ResourceGroupKVInterceptor. type ResourceGroupsController struct { clientUniqueID uint64 provider ResourceGroupProvider groupsController sync.Map - config *Config + ruConfig *RUConfig loopCtx context.Context loopCancel func() @@ -128,19 +128,19 @@ func NewResourceGroupController( requestUnitConfig *RequestUnitConfig, opts ...ResourceControlCreateOption, ) (*ResourceGroupsController, error) { - controllerConfig, err := loadServerConfig(ctx, provider) + config, err := loadServerConfig(ctx, provider) if err != nil { return nil, err } if requestUnitConfig != nil { - controllerConfig.RequestUnit = *requestUnitConfig + config.RequestUnit = *requestUnitConfig } - log.Info("load resource controller config", zap.Reflect("config", controllerConfig)) - config := GenerateConfig(controllerConfig) + log.Info("load resource controller config", zap.Reflect("config", config)) + ruConfig := GenerateRUConfig(config) controller := &ResourceGroupsController{ clientUniqueID: clientUniqueID, provider: provider, - config: config, + ruConfig: ruConfig, lowTokenNotifyChan: make(chan struct{}, 1), tokenResponseChan: make(chan []*rmpb.TokenBucketResponse, 1), tokenBucketUpdateChan: make(chan *groupCostController, maxNotificationChanLen), @@ -148,30 +148,30 @@ func NewResourceGroupController( for _, opt := range opts { opt(controller) } - controller.calculators = []ResourceCalculator{newKVCalculator(controller.config), newSQLCalculator(controller.config)} + controller.calculators = []ResourceCalculator{newKVCalculator(controller.ruConfig), newSQLCalculator(controller.ruConfig)} return controller, nil } -func loadServerConfig(ctx context.Context, provider ResourceGroupProvider) (*ControllerConfig, error) { +func loadServerConfig(ctx context.Context, provider ResourceGroupProvider) (*Config, error) { items, _, err := provider.LoadGlobalConfig(ctx, nil, controllerConfigPath) if err != nil { return nil, err } if len(items) == 0 { log.Warn("[resource group controller] server does not save config, load config failed") - return DefaultControllerConfig(), nil + return DefaultConfig(), nil } - controllerConfig := &ControllerConfig{} - err = json.Unmarshal(items[0].PayLoad, controllerConfig) + config := &Config{} + err = json.Unmarshal(items[0].PayLoad, config) if err != nil { return nil, err } - return controllerConfig, nil + return config, nil } // GetConfig returns the config of controller. It's only used for test. -func (c *ResourceGroupsController) GetConfig() *Config { - return c.config +func (c *ResourceGroupsController) GetConfig() *RUConfig { + return c.ruConfig } // Source List @@ -184,8 +184,8 @@ const ( func (c *ResourceGroupsController) Start(ctx context.Context) { c.loopCtx, c.loopCancel = context.WithCancel(ctx) go func() { - if c.config.DegradedModeWaitDuration > 0 { - c.run.responseDeadline = time.NewTimer(c.config.DegradedModeWaitDuration) + if c.ruConfig.DegradedModeWaitDuration > 0 { + c.run.responseDeadline = time.NewTimer(c.ruConfig.DegradedModeWaitDuration) c.run.responseDeadline.Stop() defer c.run.responseDeadline.Stop() } @@ -214,11 +214,11 @@ func (c *ResourceGroupsController) Start(ctx context.Context) { log.Warn("load resource group revision failed", zap.Error(err)) } var watchChannel chan []*meta_storagepb.Event - if !c.config.isSingleGroupByKeyspace { + if !c.ruConfig.isSingleGroupByKeyspace { watchChannel, err = c.provider.Watch(ctx, pd.GroupSettingsPathPrefixBytes, pd.WithRev(revision), pd.WithPrefix()) } watchRetryTimer := time.NewTimer(watchRetryInterval) - if err == nil || c.config.isSingleGroupByKeyspace { + if err == nil || c.ruConfig.isSingleGroupByKeyspace { watchRetryTimer.Stop() } defer watchRetryTimer.Stop() @@ -259,7 +259,7 @@ func (c *ResourceGroupsController) Start(ctx context.Context) { c.executeOnAllGroups((*groupCostController).resetEmergencyTokenAcquisition) case resp, ok := <-watchChannel: failpoint.Inject("disableWatch", func() { - if c.config.isSingleGroupByKeyspace { + if c.ruConfig.isSingleGroupByKeyspace { panic("disableWatch") } }) @@ -335,7 +335,7 @@ func (c *ResourceGroupsController) tryGetResourceGroup(ctx context.Context, name return gc, nil } // Initialize the resource group controller. - gc, err := newGroupCostController(group, c.config, c.lowTokenNotifyChan, c.tokenBucketUpdateChan) + gc, err := newGroupCostController(group, c.ruConfig, c.lowTokenNotifyChan, c.tokenBucketUpdateChan) if err != nil { return nil, err } @@ -425,8 +425,8 @@ func (c *ResourceGroupsController) sendTokenBucketRequests(ctx context.Context, TargetRequestPeriodMs: uint64(defaultTargetPeriod / time.Millisecond), ClientUniqueId: c.clientUniqueID, } - if c.config.DegradedModeWaitDuration > 0 && c.responseDeadlineCh == nil { - c.run.responseDeadline.Reset(c.config.DegradedModeWaitDuration) + if c.ruConfig.DegradedModeWaitDuration > 0 && c.responseDeadlineCh == nil { + c.run.responseDeadline.Reset(c.ruConfig.DegradedModeWaitDuration) c.responseDeadlineCh = c.run.responseDeadline.C } go func() { @@ -485,7 +485,7 @@ type groupCostController struct { // invariant attributes name string mode rmpb.GroupMode - mainCfg *Config + mainCfg *RUConfig // meta info meta *rmpb.ResourceGroup metaLock sync.RWMutex @@ -574,7 +574,7 @@ type tokenCounter struct { func newGroupCostController( group *rmpb.ResourceGroup, - mainCfg *Config, + mainCfg *RUConfig, lowRUNotifyChan chan struct{}, tokenBucketUpdateChan chan *groupCostController, ) (*groupCostController, error) { diff --git a/client/resource_group/controller/controller_test.go b/client/resource_group/controller/controller_test.go index d3b2a29c211..165d501ddb1 100644 --- a/client/resource_group/controller/controller_test.go +++ b/client/resource_group/controller/controller_test.go @@ -42,7 +42,7 @@ func createTestGroupCostController(re *require.Assertions) *groupCostController } ch1 := make(chan struct{}) ch2 := make(chan *groupCostController) - gc, err := newGroupCostController(group, DefaultConfig(), ch1, ch2) + gc, err := newGroupCostController(group, DefaultRUConfig(), ch1, ch2) re.NoError(err) return gc } diff --git a/client/resource_group/controller/model.go b/client/resource_group/controller/model.go index 55a6f9ec939..81f7e52716e 100644 --- a/client/resource_group/controller/model.go +++ b/client/resource_group/controller/model.go @@ -65,13 +65,13 @@ type ResourceCalculator interface { // KVCalculator is used to calculate the KV-side consumption. type KVCalculator struct { - *Config + *RUConfig } var _ ResourceCalculator = (*KVCalculator)(nil) -func newKVCalculator(cfg *Config) *KVCalculator { - return &KVCalculator{Config: cfg} +func newKVCalculator(cfg *RUConfig) *KVCalculator { + return &KVCalculator{RUConfig: cfg} } // Trickle ... @@ -146,13 +146,13 @@ func (kc *KVCalculator) payBackWriteCost(consumption *rmpb.Consumption, req Requ // SQLCalculator is used to calculate the SQL-side consumption. type SQLCalculator struct { - *Config + *RUConfig } var _ ResourceCalculator = (*SQLCalculator)(nil) -func newSQLCalculator(cfg *Config) *SQLCalculator { - return &SQLCalculator{Config: cfg} +func newSQLCalculator(cfg *RUConfig) *SQLCalculator { + return &SQLCalculator{RUConfig: cfg} } // Trickle update sql layer CPU consumption. diff --git a/tests/integrations/mcs/resourcemanager/resource_manager_test.go b/tests/integrations/mcs/resourcemanager/resource_manager_test.go index 4bdefefbb81..d393dfe03ad 100644 --- a/tests/integrations/mcs/resourcemanager/resource_manager_test.go +++ b/tests/integrations/mcs/resourcemanager/resource_manager_test.go @@ -1081,7 +1081,7 @@ func (suite *resourceManagerClientTestSuite) TestLoadRequestUnitConfig() { re.NoError(err) config := ctr.GetConfig() re.NotNil(config) - expectedConfig := controller.DefaultConfig() + expectedConfig := controller.DefaultRUConfig() re.Equal(expectedConfig.ReadBaseCost, config.ReadBaseCost) re.Equal(expectedConfig.ReadBytesCost, config.ReadBytesCost) re.Equal(expectedConfig.WriteBaseCost, config.WriteBaseCost) @@ -1099,9 +1099,9 @@ func (suite *resourceManagerClientTestSuite) TestLoadRequestUnitConfig() { re.NoError(err) config = ctr.GetConfig() re.NotNil(config) - controllerConfig := controller.DefaultControllerConfig() + controllerConfig := controller.DefaultConfig() controllerConfig.RequestUnit = *ruConfig - expectedConfig = controller.GenerateConfig(controllerConfig) + expectedConfig = controller.GenerateRUConfig(controllerConfig) re.Equal(expectedConfig.ReadBaseCost, config.ReadBaseCost) re.Equal(expectedConfig.ReadBytesCost, config.ReadBytesCost) re.Equal(expectedConfig.WriteBaseCost, config.WriteBaseCost)