refactor: rename ManagementState to MaintenanceState across the module

Signed-off-by: Evsyukov Denis <[email protected]>

Author: juev

pkg/addon-operator/operator.go

@@ -1180,7 +1180,7 @@ func (op *AddonOperator) StartModuleManagerEventHandler() {
 							slog.Bool("globalSectionChanged", event.GlobalSectionChanged),
 							slog.Any("moduleValuesChanged", event.ModuleValuesChanged),
 							slog.Any("moduleEnabledStateChanged", event.ModuleEnabledStateChanged),
-							slog.Any("moduleManagementStateChanged", event.ModuleManagementStateChanged))
+							slog.Any("moduleMaintenanceStateChanged", event.ModuleMaintenanceStateChanged))
 						if !op.ModuleManager.GetKubeConfigValid() {
 							eventLogEntry.Info("KubeConfig become valid")
 						}
@@ -1192,16 +1192,16 @@ func (op *AddonOperator) StartModuleManagerEventHandler() {
 							convergeTask   sh_task.Task
 						)
 
-						if event.GlobalSectionChanged || len(event.ModuleValuesChanged)+len(event.ModuleManagementStateChanged) > 0 {
+						if event.GlobalSectionChanged || len(event.ModuleValuesChanged)+len(event.ModuleMaintenanceStateChanged) > 0 {
 							kubeConfigTask = converge.NewApplyKubeConfigValuesTask(
 								"Apply-Kube-Config-Values-Changes",
 								logLabels,
 								event.GlobalSectionChanged,
 							)
 						}
 
-						for module, state := range event.ModuleManagementStateChanged {
-							op.ModuleManager.SetModuleManagementState(module, state)
+						for module, state := range event.ModuleMaintenanceStateChanged {
+							op.ModuleManager.SetModuleMaintenanceState(module, state)
 						}
 
 						// if global hooks haven't been run yet, script enabled extender fails due to missing global values,
@@ -1254,14 +1254,14 @@ func (op *AddonOperator) StartModuleManagerEventHandler() {
 							op.ConvergeState.Phase = converge.StandBy
 							op.ConvergeState.PhaseLock.Unlock()
 						} else {
-							modulesToRerun := make([]string, 0, len(event.ModuleValuesChanged)+len(event.ModuleManagementStateChanged))
+							modulesToRerun := make([]string, 0, len(event.ModuleValuesChanged)+len(event.ModuleMaintenanceStateChanged))
 							for _, moduleName := range event.ModuleValuesChanged {
 								if op.ModuleManager.IsModuleEnabled(moduleName) {
 									modulesToRerun = append(modulesToRerun, moduleName)
 								}
 							}
 
-							for moduleName := range event.ModuleManagementStateChanged {
+							for moduleName := range event.ModuleMaintenanceStateChanged {
 								if !slices.Contains(modulesToRerun, moduleName) && op.ModuleManager.IsModuleEnabled(moduleName) {
 									modulesToRerun = append(modulesToRerun, moduleName)
 								}

pkg/kube_config_manager/backend/configmap/configmap.go

@@ -195,9 +195,9 @@ func getModulesNamesFromConfigData(configData map[string]string) (map[string]boo
 			continue
 		}
 
-		// Treat Enabled and ManagementState flags as module section.
+		// Treat Enabled and MaintenanceState flags as module section.
 		key = strings.TrimSuffix(key, utils.EnabledSuffix)
-		key = strings.TrimSuffix(key, utils.ManagementStateSuffix)
+		key = strings.TrimSuffix(key, utils.MaintenanceStateSuffix)
 
 		modName := utils.ModuleNameFromValuesKey(key)
 
@@ -272,20 +272,20 @@ func fromConfigMapData(moduleName string, configData map[string]string) (*utils.
 		configValues[mc.ModuleEnabledKey()] = enabled
 	}
 
-	managementStateString, hasKey := configData[mc.ModuleManagementStateKey()]
+	maintenanceStateString, hasKey := configData[mc.ModuleMaintenanceStateKey()]
 	if hasKey {
-		var state utils.ManagementState
+		var state utils.MaintenanceState
 
-		switch managementStateString {
+		switch maintenanceStateString {
 		case "Unmanaged", "unmanaged":
 			state = utils.Unmanaged
 		case "":
 			state = utils.Managed
 		default:
-			return nil, fmt.Errorf("module managementState key '%s' can only take 'Unmanaged', 'unmanaged' or '' values, got '%v'", mc.ModuleManagementStateKey(), managementStateString)
+			return nil, fmt.Errorf("module maintenanceState key '%s' can only take 'Unmanaged', 'unmanaged' or '' values, got '%v'", mc.ModuleMaintenanceStateKey(), maintenanceStateString)
 		}
 
-		configValues[mc.ModuleManagementStateKey()] = state
+		configValues[mc.ModuleMaintenanceStateKey()] = state
 	}
 
 	if len(configValues) == 0 {

pkg/kube_config_manager/config/config.go

@@ -47,11 +47,11 @@ func NewConfig() *KubeConfig {
 type (
 	KubeConfigType  string
 	KubeConfigEvent struct {
-		Type                         KubeConfigType
-		ModuleEnabledStateChanged    []string
-		ModuleValuesChanged          []string
-		GlobalSectionChanged         bool
-		ModuleManagementStateChanged map[string]utils.ManagementState
+		Type                          KubeConfigType
+		ModuleEnabledStateChanged     []string
+		ModuleValuesChanged           []string
+		GlobalSectionChanged          bool
+		ModuleMaintenanceStateChanged map[string]utils.MaintenanceState
 	}
 )
 

pkg/kube_config_manager/kube_config_manager.go

@@ -244,7 +244,7 @@ func (kcm *KubeConfigManager) handleConfigEvent(obj config.Event) {
 		// some module values
 		modulesChanged := []string{}
 		modulesStateChanged := []string{}
-		moduleManagementStateChanged := make(map[string]utils.ManagementState)
+		moduleMaintenanceChanged := make(map[string]utils.MaintenanceState)
 
 		// module update
 		kcm.m.Lock()
@@ -258,18 +258,18 @@ func (kcm *KubeConfigManager) handleConfigEvent(obj config.Event) {
 				modulesStateChanged = append(modulesStateChanged, moduleName)
 			}
 
-			if kcm.currentConfig.Modules[moduleName].GetManagementState() == utils.Unmanaged {
-				moduleManagementStateChanged[moduleName] = utils.Managed
+			if kcm.currentConfig.Modules[moduleName].GetMaintenanceState() == utils.Unmanaged {
+				moduleMaintenanceChanged[moduleName] = utils.Managed
 			}
 
 			moduleCfg.Reset()
 			moduleCfg.Checksum = moduleCfg.ModuleConfig.Checksum()
 			kcm.currentConfig.Modules[obj.Key] = moduleCfg
 			kcm.configEventCh <- config.KubeConfigEvent{
-				Type:                         config.KubeConfigChanged,
-				ModuleValuesChanged:          modulesChanged,
-				ModuleEnabledStateChanged:    modulesStateChanged,
-				ModuleManagementStateChanged: moduleManagementStateChanged,
+				Type:                          config.KubeConfigChanged,
+				ModuleValuesChanged:           modulesChanged,
+				ModuleEnabledStateChanged:     modulesStateChanged,
+				ModuleMaintenanceStateChanged: moduleMaintenanceChanged,
 			}
 			return
 		}
@@ -287,37 +287,37 @@ func (kcm *KubeConfigManager) handleConfigEvent(obj config.Event) {
 					modulesStateChanged = append(modulesStateChanged, moduleName)
 				}
 
-				if kcm.currentConfig.Modules[moduleName].GetManagementState() != moduleCfg.GetManagementState() {
-					moduleManagementStateChanged[moduleName] = moduleCfg.GetManagementState()
+				if kcm.currentConfig.Modules[moduleName].GetMaintenanceState() != moduleCfg.GetMaintenanceState() {
+					moduleMaintenanceChanged[moduleName] = moduleCfg.GetMaintenanceState()
 				}
 				kcm.logger.Info("Module section changed. Enabled flag transition.",
 					slog.String("moduleName", moduleName),
 					slog.String("previous", kcm.currentConfig.Modules[moduleName].GetEnabled()),
 					slog.String("current", moduleCfg.GetEnabled()),
-					slog.String("ManagementStateFlag", moduleCfg.GetManagementState().String()))
+					slog.String("MaintenanceStateFlag", moduleCfg.GetMaintenanceState().String()))
 			} else {
 				modulesChanged = append(modulesChanged, moduleName)
 				if moduleCfg.GetEnabled() != "" && moduleCfg.GetEnabled() != "n/d" {
 					modulesStateChanged = append(modulesStateChanged, moduleName)
 				}
 
-				if moduleCfg.GetManagementState() == utils.Unmanaged {
-					moduleManagementStateChanged[moduleName] = utils.Unmanaged
+				if moduleCfg.GetMaintenanceState() == utils.Unmanaged {
+					moduleMaintenanceChanged[moduleName] = utils.Unmanaged
 				}
 				kcm.logger.Info("Module section added",
 					slog.String("moduleName", moduleName),
 					slog.String("enabledFlag", moduleCfg.GetEnabled()),
-					slog.String("ManagementStateFlag", moduleCfg.GetManagementState().String()))
+					slog.String("MaintenanceStateFlag", moduleCfg.GetMaintenanceState().String()))
 			}
 		}
 
-		if len(modulesChanged)+len(modulesStateChanged)+len(moduleManagementStateChanged) > 0 {
+		if len(modulesChanged)+len(modulesStateChanged)+len(moduleMaintenanceChanged) > 0 {
 			kcm.currentConfig.Modules[obj.Key] = moduleCfg
 			kcm.configEventCh <- config.KubeConfigEvent{
-				Type:                         config.KubeConfigChanged,
-				ModuleValuesChanged:          modulesChanged,
-				ModuleEnabledStateChanged:    modulesStateChanged,
-				ModuleManagementStateChanged: moduleManagementStateChanged,
+				Type:                          config.KubeConfigChanged,
+				ModuleValuesChanged:           modulesChanged,
+				ModuleEnabledStateChanged:     modulesStateChanged,
+				ModuleMaintenanceStateChanged: moduleMaintenanceChanged,
 			}
 		}
 	}
@@ -354,7 +354,7 @@ func (kcm *KubeConfigManager) handleBatchConfigEvent(obj config.Event) {
 	currentModuleNames := kcm.currentModuleNames()
 	modulesChanged := []string{}
 	modulesStateChanged := []string{}
-	moduleManagementStateChanged := make(map[string]utils.ManagementState)
+	moduleMaintenanceStateChanged := make(map[string]utils.MaintenanceState)
 
 	for moduleName, moduleCfg := range newConfig.Modules {
 		// Remove module name from current names to detect deleted sections.
@@ -375,29 +375,29 @@ func (kcm *KubeConfigManager) handleBatchConfigEvent(obj config.Event) {
 					modulesStateChanged = append(modulesStateChanged, moduleName)
 				}
 
-				if kcm.currentConfig.Modules[moduleName].GetManagementState() != moduleCfg.GetManagementState() {
-					moduleManagementStateChanged[moduleName] = moduleCfg.GetManagementState()
+				if kcm.currentConfig.Modules[moduleName].GetMaintenanceState() != moduleCfg.GetMaintenanceState() {
+					moduleMaintenanceStateChanged[moduleName] = moduleCfg.GetMaintenanceState()
 				}
 
 				kcm.logger.Info("Module section changed. Enabled flag transition",
 					slog.String("moduleName", moduleName),
 					slog.String("previous", kcm.currentConfig.Modules[moduleName].GetEnabled()),
 					slog.String("current", moduleCfg.GetEnabled()),
-					slog.String("ManagementStateFlag", moduleCfg.GetManagementState().String()))
+					slog.String("MaintenanceStateFlag", moduleCfg.GetMaintenanceState().String()))
 			} else {
 				modulesChanged = append(modulesChanged, moduleName)
 				if moduleCfg.GetEnabled() != "" && moduleCfg.GetEnabled() != "n/d" {
 					modulesStateChanged = append(modulesStateChanged, moduleName)
 				}
 
-				if moduleCfg.GetManagementState() == utils.Unmanaged {
-					moduleManagementStateChanged[moduleName] = utils.Unmanaged
+				if moduleCfg.GetMaintenanceState() == utils.Unmanaged {
+					moduleMaintenanceStateChanged[moduleName] = utils.Unmanaged
 				}
 
 				kcm.logger.Info("Module section added",
 					slog.String("moduleName", moduleName),
 					slog.String("enabledFlag", moduleCfg.GetEnabled()),
-					slog.String("ManagementStateFlag", moduleCfg.GetManagementState().String()))
+					slog.String("MaintenanceStateFlag", moduleCfg.GetMaintenanceState().String()))
 			}
 		}
 	}
@@ -419,13 +419,13 @@ func (kcm *KubeConfigManager) handleBatchConfigEvent(obj config.Event) {
 	kcm.m.Unlock()
 
 	// Fire event if ConfigMap has changes.
-	if globalChanged || len(modulesChanged)+len(moduleManagementStateChanged) > 0 {
+	if globalChanged || len(modulesChanged)+len(moduleMaintenanceStateChanged) > 0 {
 		kcm.configEventCh <- config.KubeConfigEvent{
-			Type:                         config.KubeConfigChanged,
-			GlobalSectionChanged:         globalChanged,
-			ModuleValuesChanged:          modulesChanged,
-			ModuleEnabledStateChanged:    modulesStateChanged,
-			ModuleManagementStateChanged: moduleManagementStateChanged,
+			Type:                          config.KubeConfigChanged,
+			GlobalSectionChanged:          globalChanged,
+			ModuleValuesChanged:           modulesChanged,
+			ModuleEnabledStateChanged:     modulesStateChanged,
+			ModuleMaintenanceStateChanged: moduleMaintenanceStateChanged,
 		}
 	}
 }

pkg/kube_config_manager/kube_config_manager_test.go

@@ -77,7 +77,7 @@ kubeDns: |
   config:
     resolver: "192.168.0.1"
 kubeDnsEnabled: "true"
-kubeDnsManagementState: "Unmanaged"
+kubeDnsMaintenanceState: "Unmanaged"
 `
 
 	kubeClient := klient.NewFake(nil)
@@ -87,9 +87,9 @@ kubeDnsManagementState: "Unmanaged"
 	defer kcm.Stop()
 
 	tests := map[string]struct {
-		isEnabled       *bool
-		managementState utils.ManagementState
-		values          utils.Values
+		isEnabled        *bool
+		maintenanceState utils.MaintenanceState
+		values           utils.Values
 	}{
 		"global": {
 			nil,
@@ -165,7 +165,7 @@ kubeDnsManagementState: "Unmanaged"
 					moduleConfig, hasConfig := config.Modules[name]
 					assert.True(t, hasConfig)
 					assert.Equal(t, expect.isEnabled, moduleConfig.IsEnabled)
-					assert.Equal(t, expect.managementState, moduleConfig.ManagementState)
+					assert.Equal(t, expect.maintenanceState, moduleConfig.MaintenanceState)
 					assert.Equal(t, expect.values, moduleConfig.GetValuesWithModuleName()) //nolint: staticcheck,nolintlint
 				})
 			}
@@ -437,7 +437,7 @@ func Test_KubeConfigManager_error_on_Init(t *testing.T) {
 "path": "/data/validModuleName",
 "value": "modParam1: val1\nmodParam2: val2"},
 {"op": "add", 
-"path": "/data/validModuleNameManagementState",
+"path": "/data/validModuleNameMaintenance",
 "value": "Unmanaged"},
 {"op": "remove", 
 "path": "/data/InvalidName-module"}]`
@@ -458,7 +458,7 @@ func Test_KubeConfigManager_error_on_Init(t *testing.T) {
 		ModuleEnabledStateChanged: []string{},
 		ModuleValuesChanged:       []string{"valid-module-name"},
 		GlobalSectionChanged:      false,
-		ModuleManagementStateChanged: map[string]utils.ManagementState{
+		ModuleMaintenanceStateChanged: map[string]utils.MaintenanceState{
 			"valid-module-name": "Unmanaged",
 		},
 	}), "Valid section patch should generate 'changed' event")

pkg/module_manager/models/modules/basic.go

@@ -188,17 +188,17 @@ func (bm *BasicModule) SetHooksControllersReady() {
 // ResetState drops the module state
 func (bm *BasicModule) ResetState() {
 	bm.l.Lock()
-	var managementState ManagementState
+	var maintenanceState MaintenanceState
 
-	if bm.state.managementState == UnmanagedEnforced {
-		managementState = UnmanagedEnabled
+	if bm.state.maintenanceState == UnmanagedEnforced {
+		maintenanceState = UnmanagedEnabled
 	}
 
 	bm.state = &moduleState{
 		Phase:                Startup,
 		hookErrors:           make(map[string]error),
 		synchronizationState: NewSynchronizationState(),
-		managementState:      managementState,
+		maintenanceState:     maintenanceState,
 	}
 	bm.l.Unlock()
 }
@@ -544,34 +544,34 @@ func (bm *BasicModule) SaveHookError(hookName string, err error) {
 	bm.l.Unlock()
 }
 
-func (bm *BasicModule) SetManagementState(state utils.ManagementState) {
+func (bm *BasicModule) SetMaintenanceState(state utils.MaintenanceState) {
 	bm.l.Lock()
 	switch state {
 	case utils.Unmanaged:
-		if bm.state.managementState == Managed {
-			bm.state.managementState = UnmanagedEnabled
+		if bm.state.maintenanceState == Managed {
+			bm.state.maintenanceState = UnmanagedEnabled
 		}
 	case utils.Managed:
-		if bm.state.managementState != Managed {
-			bm.state.managementState = Managed
+		if bm.state.maintenanceState != Managed {
+			bm.state.maintenanceState = Managed
 		}
 	}
 	bm.l.Unlock()
 }
 
 func (bm *BasicModule) SetUnmanagedEnforced() {
 	bm.l.Lock()
-	if bm.state.managementState == UnmanagedEnabled {
-		bm.state.managementState = UnmanagedEnforced
+	if bm.state.maintenanceState == UnmanagedEnabled {
+		bm.state.maintenanceState = UnmanagedEnforced
 	}
 	bm.l.Unlock()
 }
 
-func (bm *BasicModule) GetManagementState() ManagementState {
+func (bm *BasicModule) GetMaintenanceState() MaintenanceState {
 	bm.l.RLock()
 	defer bm.l.RUnlock()
 
-	return bm.state.managementState
+	return bm.state.maintenanceState
 }
 
 // RunHooksByBinding gets all hooks for binding, for each hook it creates a BindingContext,
@@ -1278,11 +1278,11 @@ const (
 	HooksDisabled ModuleRunPhase = "HooksDisabled"
 )
 
-type ManagementState int
+type MaintenanceState int
 
 const (
 	// Module runs in a normal mode
-	Managed ManagementState = iota
+	Managed MaintenanceState = iota
 	// Next helm run will enforce Unmanaged mode (removes heritage labels and stops resource informer)
 	UnmanagedEnabled
 	// All consequent helm runs are inhibited
@@ -1291,7 +1291,7 @@ const (
 
 type moduleState struct {
 	Enabled              bool
-	managementState      ManagementState
+	maintenanceState     MaintenanceState
 	Phase                ModuleRunPhase
 	lastModuleErr        error
 	hookErrors           map[string]error

pkg/module_manager/models/modules/helm.go

@@ -76,8 +76,8 @@ func NewHelmModule(bm *BasicModule, namespace string, tmpDir string, deps *HelmM
 	}
 
 	additionalLabels := make(map[string]string)
-	if bm.GetManagementState() != Managed {
-		additionalLabels["managementState"] = utils.Unmanaged.String()
+	if bm.GetMaintenanceState() != Managed {
+		additionalLabels["maintenanceState"] = utils.Unmanaged.String()
 	}
 
 	hm := &HelmModule{