fix: rename MaintenanceState to Maintenance

juev · juev · commit 2c72aabe6602 · 2025-04-15T13:05:04.000+03:00
Signed-off-by: Evsyukov Denis &lt;denis.evsyukov@flant.com&gt;
diff --git a/pkg/addon-operator/operator.go b/pkg/addon-operator/operator.go
@@ -1201,7 +1201,7 @@ func (op *AddonOperator) StartModuleManagerEventHandler() {
 						}
 
 						for module, state := range event.ModuleMaintenanceChanged {
-							op.ModuleManager.SetModuleMaintenanceState(module, state)
+							op.ModuleManager.SetModuleMaintenance(module, state)
 						}
 
 						// if global hooks haven't been run yet, script enabled extender fails due to missing global values,
diff --git a/pkg/kube_config_manager/backend/configmap/configmap.go b/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 MaintenanceState flags as module section.
+		// Treat Enabled and Maintenance flags as module section.
 		key = strings.TrimSuffix(key, utils.EnabledSuffix)
-		key = strings.TrimSuffix(key, utils.MaintenanceStateSuffix)
+		key = strings.TrimSuffix(key, utils.MaintenanceSuffix)
 
 		modName := utils.ModuleNameFromValuesKey(key)
 
@@ -272,20 +272,20 @@ func fromConfigMapData(moduleName string, configData map[string]string) (*utils.
 		configValues[mc.ModuleEnabledKey()] = enabled
 	}
 
-	maintenanceStateString, hasKey := configData[mc.ModuleMaintenanceStateKey()]
+	maintenanceString, hasKey := configData[mc.ModuleMaintenanceKey()]
 	if hasKey {
 		var state utils.Maintenance
 
-		switch maintenanceStateString {
+		switch maintenanceString {
 		case "NoResourceReconciliation", "noresourcereconciliation":
 			state = utils.NoResourceReconciliation
 		case "":
 			state = utils.Managed
 		default:
-			return nil, fmt.Errorf("module maintenanceState key '%s' can only take 'NoResourceReconciliation', 'noresourcereconciliation' or '' values, got '%v'", mc.ModuleMaintenanceStateKey(), maintenanceStateString)
+			return nil, fmt.Errorf("module maintenance key '%s' can only take 'NoResourceReconciliation', 'noresourcereconciliation' or '' values, got '%v'", mc.ModuleMaintenanceKey(), maintenanceString)
 		}
 
-		configValues[mc.ModuleMaintenanceStateKey()] = state
+		configValues[mc.ModuleMaintenanceKey()] = state
 	}
 
 	if len(configValues) == 0 {
diff --git a/pkg/kube_config_manager/kube_config_manager.go b/pkg/kube_config_manager/kube_config_manager.go
@@ -258,7 +258,7 @@ func (kcm *KubeConfigManager) handleConfigEvent(obj config.Event) {
 				modulesStateChanged = append(modulesStateChanged, moduleName)
 			}
 
-			if kcm.currentConfig.Modules[moduleName].GetMaintenanceState() == utils.NoResourceReconciliation {
+			if kcm.currentConfig.Modules[moduleName].GetMaintenance() == utils.NoResourceReconciliation {
 				moduleMaintenanceChanged[moduleName] = utils.Managed
 			}
 
@@ -287,27 +287,27 @@ func (kcm *KubeConfigManager) handleConfigEvent(obj config.Event) {
 					modulesStateChanged = append(modulesStateChanged, moduleName)
 				}
 
-				if kcm.currentConfig.Modules[moduleName].GetMaintenanceState() != moduleCfg.GetMaintenanceState() {
-					moduleMaintenanceChanged[moduleName] = moduleCfg.GetMaintenanceState()
+				if kcm.currentConfig.Modules[moduleName].GetMaintenance() != moduleCfg.GetMaintenance() {
+					moduleMaintenanceChanged[moduleName] = moduleCfg.GetMaintenance()
 				}
 				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("maintenanceFlag", moduleCfg.GetMaintenanceState().String()))
+					slog.String("maintenanceFlag", moduleCfg.GetMaintenance().String()))
 			} else {
 				modulesChanged = append(modulesChanged, moduleName)
 				if moduleCfg.GetEnabled() != "" && moduleCfg.GetEnabled() != "n/d" {
 					modulesStateChanged = append(modulesStateChanged, moduleName)
 				}
 
-				if moduleCfg.GetMaintenanceState() == utils.NoResourceReconciliation {
+				if moduleCfg.GetMaintenance() == utils.NoResourceReconciliation {
 					moduleMaintenanceChanged[moduleName] = utils.NoResourceReconciliation
 				}
 				kcm.logger.Info("Module section added",
 					slog.String("moduleName", moduleName),
 					slog.String("enabledFlag", moduleCfg.GetEnabled()),
-					slog.String("maintenanceFlag", moduleCfg.GetMaintenanceState().String()))
+					slog.String("maintenanceFlag", moduleCfg.GetMaintenance().String()))
 			}
 		}
 
@@ -375,29 +375,29 @@ func (kcm *KubeConfigManager) handleBatchConfigEvent(obj config.Event) {
 					modulesStateChanged = append(modulesStateChanged, moduleName)
 				}
 
-				if kcm.currentConfig.Modules[moduleName].GetMaintenanceState() != moduleCfg.GetMaintenanceState() {
-					moduleMaintenanceChanged[moduleName] = moduleCfg.GetMaintenanceState()
+				if kcm.currentConfig.Modules[moduleName].GetMaintenance() != moduleCfg.GetMaintenance() {
+					moduleMaintenanceChanged[moduleName] = moduleCfg.GetMaintenance()
 				}
 
 				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("maintenanceFlag", moduleCfg.GetMaintenanceState().String()))
+					slog.String("maintenanceFlag", moduleCfg.GetMaintenance().String()))
 			} else {
 				modulesChanged = append(modulesChanged, moduleName)
 				if moduleCfg.GetEnabled() != "" && moduleCfg.GetEnabled() != "n/d" {
 					modulesStateChanged = append(modulesStateChanged, moduleName)
 				}
 
-				if moduleCfg.GetMaintenanceState() == utils.NoResourceReconciliation {
+				if moduleCfg.GetMaintenance() == utils.NoResourceReconciliation {
 					moduleMaintenanceChanged[moduleName] = utils.NoResourceReconciliation
 				}
 
 				kcm.logger.Info("Module section added",
 					slog.String("moduleName", moduleName),
 					slog.String("enabledFlag", moduleCfg.GetEnabled()),
-					slog.String("maintenanceFlag", moduleCfg.GetMaintenanceState().String()))
+					slog.String("maintenanceFlag", moduleCfg.GetMaintenance().String()))
 			}
 		}
 	}
diff --git a/pkg/module_manager/models/modules/basic.go b/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 maintenanceState MaintenanceState
+	var maintenance Maintenance
 
-	if bm.state.maintenanceState == UnmanagedEnforced {
-		maintenanceState = UnmanagedEnabled
+	if bm.state.maintenance == UnmanagedEnforced {
+		maintenance = UnmanagedEnabled
 	}
 
 	bm.state = &moduleState{
 		Phase:                Startup,
 		hookErrors:           make(map[string]error),
 		synchronizationState: NewSynchronizationState(),
-		maintenanceState:     maintenanceState,
+		maintenance:          maintenance,
 	}
 	bm.l.Unlock()
 }
@@ -544,34 +544,34 @@ func (bm *BasicModule) SaveHookError(hookName string, err error) {
 	bm.l.Unlock()
 }
 
-func (bm *BasicModule) SetMaintenanceState(state utils.Maintenance) {
+func (bm *BasicModule) SetMaintenance(state utils.Maintenance) {
 	bm.l.Lock()
 	switch state {
 	case utils.NoResourceReconciliation:
-		if bm.state.maintenanceState == Managed {
-			bm.state.maintenanceState = UnmanagedEnabled
+		if bm.state.maintenance == Managed {
+			bm.state.maintenance = UnmanagedEnabled
 		}
 	case utils.Managed:
-		if bm.state.maintenanceState != Managed {
-			bm.state.maintenanceState = Managed
+		if bm.state.maintenance != Managed {
+			bm.state.maintenance = Managed
 		}
 	}
 	bm.l.Unlock()
 }
 
 func (bm *BasicModule) SetUnmanagedEnforced() {
 	bm.l.Lock()
-	if bm.state.maintenanceState == UnmanagedEnabled {
-		bm.state.maintenanceState = UnmanagedEnforced
+	if bm.state.maintenance == UnmanagedEnabled {
+		bm.state.maintenance = UnmanagedEnforced
 	}
 	bm.l.Unlock()
 }
 
-func (bm *BasicModule) GetMaintenanceState() MaintenanceState {
+func (bm *BasicModule) GetMaintenance() Maintenance {
 	bm.l.RLock()
 	defer bm.l.RUnlock()
 
-	return bm.state.maintenanceState
+	return bm.state.maintenance
 }
 
 // RunHooksByBinding gets all hooks for binding, for each hook it creates a BindingContext,
@@ -1278,11 +1278,11 @@ const (
 	HooksDisabled ModuleRunPhase = "HooksDisabled"
 )
 
-type MaintenanceState int
+type Maintenance int
 
 const (
 	// Module runs in a normal mode
-	Managed MaintenanceState = iota
+	Managed Maintenance = iota
 	// Next helm run will enforce NoResourceReconciliation 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
-	maintenanceState     MaintenanceState
+	maintenance          Maintenance
 	Phase                ModuleRunPhase
 	lastModuleErr        error
 	hookErrors           map[string]error
diff --git a/pkg/module_manager/models/modules/helm.go b/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.GetMaintenanceState() != Managed {
-		additionalLabels["maintenanceState"] = utils.NoResourceReconciliation.String()
+	if bm.GetMaintenance() != Managed {
+		additionalLabels["maintenance"] = utils.NoResourceReconciliation.String()
 	}
 
 	hm := &HelmModule{
diff --git a/pkg/module_manager/module_manager.go b/pkg/module_manager/module_manager.go
@@ -284,9 +284,9 @@ func (mm *ModuleManager) validateNewKubeConfig(kubeConfig *config.KubeConfig, al
 			continue
 		}
 
-		if moduleConfig.GetMaintenanceState() == utils.NoResourceReconciliation {
+		if moduleConfig.GetMaintenance() == utils.NoResourceReconciliation {
 			mm.dependencies.MetricStorage.Grouped().GaugeSet(moduleMaintenanceMetricGroup, moduleMaintenanceMetricName, 1, map[string]string{"moduleName": moduleName, "state": utils.NoResourceReconciliation.String()})
-			mod.SetMaintenanceState(moduleConfig.GetMaintenanceState())
+			mod.SetMaintenance(moduleConfig.GetMaintenance())
 		}
 
 		validateConfig := false
@@ -498,9 +498,9 @@ func (mm *ModuleManager) UpdateModulesMetrics() {
 	}
 }
 
-func (mm *ModuleManager) SetModuleMaintenanceState(moduleName string, state utils.Maintenance) {
+func (mm *ModuleManager) SetModuleMaintenance(moduleName string, state utils.Maintenance) {
 	if bm := mm.GetModule(moduleName); bm != nil {
-		bm.SetMaintenanceState(state)
+		bm.SetMaintenance(state)
 		mm.logger.Info("set module management state",
 			slog.String("module", moduleName),
 			slog.String("state", state.String()))
@@ -742,12 +742,12 @@ func (mm *ModuleManager) RunModule(moduleName string, logLabels map[string]strin
 	}
 
 	if err == nil {
-		moduleMaintenanceState := bm.GetMaintenanceState()
-		if moduleMaintenanceState != modules.UnmanagedEnforced {
+		moduleMaintenance := bm.GetMaintenance()
+		if moduleMaintenance != modules.UnmanagedEnforced {
 			err = helmModule.RunHelmInstall(logLabels)
 		}
 
-		if moduleMaintenanceState == modules.UnmanagedEnabled {
+		if moduleMaintenance == modules.UnmanagedEnabled {
 			bm.SetUnmanagedEnforced()
 			mm.dependencies.HelmResourcesManager.StopMonitor(moduleName)
 		}
diff --git a/pkg/utils/module_config.go b/pkg/utils/module_config.go
@@ -14,8 +14,8 @@ var (
 	ModuleEnabled  = true
 	ModuleDisabled = false
 
-	EnabledSuffix          = "Enabled"
-	MaintenanceStateSuffix = "Maintenance"
+	EnabledSuffix     = "Enabled"
+	MaintenanceSuffix = "Maintenance"
 )
 
 type Maintenance string
@@ -39,7 +39,7 @@ type ModuleConfig struct {
 
 // String returns description of ModuleConfig values.
 func (mc *ModuleConfig) String() string {
-	return fmt.Sprintf("Module(Name=%s IsEnabled=%v MaintenanceState=%v Values:\n%s)", mc.ModuleName, mc.IsEnabled, mc.Maintenance, mc.values.DebugString())
+	return fmt.Sprintf("Module(Name=%s IsEnabled=%v Maintenance=%v Values:\n%s)", mc.ModuleName, mc.IsEnabled, mc.Maintenance, mc.values.DebugString())
 }
 
 // ModuleConfigKey transforms module kebab-case name to the config camelCase name
@@ -52,9 +52,9 @@ func (mc *ModuleConfig) ModuleEnabledKey() string {
 	return ModuleNameToValuesKey(mc.ModuleName) + EnabledSuffix
 }
 
-// ModuleMaintenanceStateKey transforms module kebab-case name to the config camelCase name with 'MaintenanceState' suffix
-func (mc *ModuleConfig) ModuleMaintenanceStateKey() string {
-	return ModuleNameToValuesKey(mc.ModuleName) + MaintenanceStateSuffix
+// ModuleMaintenanceKey transforms module kebab-case name to the config camelCase name with 'Maintenance' suffix
+func (mc *ModuleConfig) ModuleMaintenanceKey() string {
+	return ModuleNameToValuesKey(mc.ModuleName) + MaintenanceSuffix
 }
 
 // GetEnabled returns string description of enabled status.
@@ -72,7 +72,7 @@ func (mc *ModuleConfig) GetEnabled() string {
 	}
 }
 
-func (mc *ModuleConfig) GetMaintenanceState() Maintenance {
+func (mc *ModuleConfig) GetMaintenance() Maintenance {
 	if mc == nil {
 		return Managed
 	}
@@ -158,12 +158,12 @@ func (mc *ModuleConfig) LoadFromValues(values Values) (*ModuleConfig, error) {
 		}
 	}
 
-	if maintenanceState, hasMaintenanceState := values[mc.ModuleMaintenanceStateKey()]; hasMaintenanceState {
-		switch v := maintenanceState.(type) {
+	if maintenance, hasMaintenance := values[mc.ModuleMaintenanceKey()]; hasMaintenance {
+		switch v := maintenance.(type) {
 		case Maintenance:
 			mc.Maintenance = v
 		default:
-			return nil, fmt.Errorf("load '%s' MaintenanceState config: MaintenanceState value should be string. Got: %#v", mc.ModuleName, maintenanceState)
+			return nil, fmt.Errorf("load '%s' Maintenance config: Maintenance value should be string. Got: %#v", mc.ModuleName, maintenance)
 		}
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -1201,7 +1201,7 @@ func (op *AddonOperator) StartModuleManagerEventHandler() {`
`1201`	`1201`	`}`
`1202`	`1202`
`1203`	`1203`	`for module, state := range event.ModuleMaintenanceChanged {`
`1204`		`- op.ModuleManager.SetModuleMaintenanceState(module, state)`
	`1204`	`+ op.ModuleManager.SetModuleMaintenance(module, state)`
`1205`	`1205`	`}`
`1206`	`1206`
`1207`	`1207`	`// if global hooks haven't been run yet, script enabled extender fails due to missing global values,`
Original file line number	Diff line number	Diff line change
`@@ -258,7 +258,7 @@ func (kcm *KubeConfigManager) handleConfigEvent(obj config.Event) {`
`258`	`258`	`modulesStateChanged = append(modulesStateChanged, moduleName)`
`259`	`259`	`}`
`260`	`260`
`261`		`- if kcm.currentConfig.Modules[moduleName].GetMaintenanceState() == utils.NoResourceReconciliation {`
	`261`	`+ if kcm.currentConfig.Modules[moduleName].GetMaintenance() == utils.NoResourceReconciliation {`
`262`	`262`	`moduleMaintenanceChanged[moduleName] = utils.Managed`
`263`	`263`	`}`
`264`	`264`
`@@ -287,27 +287,27 @@ func (kcm *KubeConfigManager) handleConfigEvent(obj config.Event) {`
`287`	`287`	`modulesStateChanged = append(modulesStateChanged, moduleName)`
`288`	`288`	`}`
`289`	`289`
`290`		`- if kcm.currentConfig.Modules[moduleName].GetMaintenanceState() != moduleCfg.GetMaintenanceState() {`
`291`		`- moduleMaintenanceChanged[moduleName] = moduleCfg.GetMaintenanceState()`
	`290`	`+ if kcm.currentConfig.Modules[moduleName].GetMaintenance() != moduleCfg.GetMaintenance() {`
	`291`	`+ moduleMaintenanceChanged[moduleName] = moduleCfg.GetMaintenance()`
`292`	`292`	`}`
`293`	`293`	`kcm.logger.Info("Module section changed. Enabled flag transition.",`
`294`	`294`	`slog.String("moduleName", moduleName),`
`295`	`295`	`slog.String("previous", kcm.currentConfig.Modules[moduleName].GetEnabled()),`
`296`	`296`	`slog.String("current", moduleCfg.GetEnabled()),`
`297`		`- slog.String("maintenanceFlag", moduleCfg.GetMaintenanceState().String()))`
	`297`	`+ slog.String("maintenanceFlag", moduleCfg.GetMaintenance().String()))`
`298`	`298`	`} else {`
`299`	`299`	`modulesChanged = append(modulesChanged, moduleName)`
`300`	`300`	`if moduleCfg.GetEnabled() != "" && moduleCfg.GetEnabled() != "n/d" {`
`301`	`301`	`modulesStateChanged = append(modulesStateChanged, moduleName)`
`302`	`302`	`}`
`303`	`303`
`304`		`- if moduleCfg.GetMaintenanceState() == utils.NoResourceReconciliation {`
	`304`	`+ if moduleCfg.GetMaintenance() == utils.NoResourceReconciliation {`
`305`	`305`	`moduleMaintenanceChanged[moduleName] = utils.NoResourceReconciliation`
`306`	`306`	`}`
`307`	`307`	`kcm.logger.Info("Module section added",`
`308`	`308`	`slog.String("moduleName", moduleName),`
`309`	`309`	`slog.String("enabledFlag", moduleCfg.GetEnabled()),`
`310`		`- slog.String("maintenanceFlag", moduleCfg.GetMaintenanceState().String()))`
	`310`	`+ slog.String("maintenanceFlag", moduleCfg.GetMaintenance().String()))`
`311`	`311`	`}`
`312`	`312`	`}`
`313`	`313`
`@@ -375,29 +375,29 @@ func (kcm *KubeConfigManager) handleBatchConfigEvent(obj config.Event) {`
`375`	`375`	`modulesStateChanged = append(modulesStateChanged, moduleName)`
`376`	`376`	`}`
`377`	`377`
`378`		`- if kcm.currentConfig.Modules[moduleName].GetMaintenanceState() != moduleCfg.GetMaintenanceState() {`
`379`		`- moduleMaintenanceChanged[moduleName] = moduleCfg.GetMaintenanceState()`
	`378`	`+ if kcm.currentConfig.Modules[moduleName].GetMaintenance() != moduleCfg.GetMaintenance() {`
	`379`	`+ moduleMaintenanceChanged[moduleName] = moduleCfg.GetMaintenance()`
`380`	`380`	`}`
`381`	`381`
`382`	`382`	`kcm.logger.Info("Module section changed. Enabled flag transition",`
`383`	`383`	`slog.String("moduleName", moduleName),`
`384`	`384`	`slog.String("previous", kcm.currentConfig.Modules[moduleName].GetEnabled()),`
`385`	`385`	`slog.String("current", moduleCfg.GetEnabled()),`
`386`		`- slog.String("maintenanceFlag", moduleCfg.GetMaintenanceState().String()))`
	`386`	`+ slog.String("maintenanceFlag", moduleCfg.GetMaintenance().String()))`
`387`	`387`	`} else {`
`388`	`388`	`modulesChanged = append(modulesChanged, moduleName)`
`389`	`389`	`if moduleCfg.GetEnabled() != "" && moduleCfg.GetEnabled() != "n/d" {`
`390`	`390`	`modulesStateChanged = append(modulesStateChanged, moduleName)`
`391`	`391`	`}`
`392`	`392`
`393`		`- if moduleCfg.GetMaintenanceState() == utils.NoResourceReconciliation {`
	`393`	`+ if moduleCfg.GetMaintenance() == utils.NoResourceReconciliation {`
`394`	`394`	`moduleMaintenanceChanged[moduleName] = utils.NoResourceReconciliation`
`395`	`395`	`}`
`396`	`396`
`397`	`397`	`kcm.logger.Info("Module section added",`
`398`	`398`	`slog.String("moduleName", moduleName),`
`399`	`399`	`slog.String("enabledFlag", moduleCfg.GetEnabled()),`
`400`		`- slog.String("maintenanceFlag", moduleCfg.GetMaintenanceState().String()))`
	`400`	`+ slog.String("maintenanceFlag", moduleCfg.GetMaintenance().String()))`
`401`	`401`	`}`
`402`	`402`	`}`
`403`	`403`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,8 +76,8 @@ func NewHelmModule(bm BasicModule, namespace string, tmpDir string, deps HelmM`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`additionalLabels := make(map[string]string)`
`79`		`- if bm.GetMaintenanceState() != Managed {`
`80`		`- additionalLabels["maintenanceState"] = utils.NoResourceReconciliation.String()`
	`79`	`+ if bm.GetMaintenance() != Managed {`
	`80`	`+ additionalLabels["maintenance"] = utils.NoResourceReconciliation.String()`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`hm := &HelmModule{`
Original file line number	Diff line number	Diff line change
`@@ -284,9 +284,9 @@ func (mm ModuleManager) validateNewKubeConfig(kubeConfig config.KubeConfig, al`
`284`	`284`	`continue`
`285`	`285`	`}`
`286`	`286`
`287`		`- if moduleConfig.GetMaintenanceState() == utils.NoResourceReconciliation {`
	`287`	`+ if moduleConfig.GetMaintenance() == utils.NoResourceReconciliation {`
`288`	`288`	`mm.dependencies.MetricStorage.Grouped().GaugeSet(moduleMaintenanceMetricGroup, moduleMaintenanceMetricName, 1, map[string]string{"moduleName": moduleName, "state": utils.NoResourceReconciliation.String()})`
`289`		`- mod.SetMaintenanceState(moduleConfig.GetMaintenanceState())`
	`289`	`+ mod.SetMaintenance(moduleConfig.GetMaintenance())`
`290`	`290`	`}`
`291`	`291`
`292`	`292`	`validateConfig := false`
`@@ -498,9 +498,9 @@ func (mm *ModuleManager) UpdateModulesMetrics() {`
`498`	`498`	`}`
`499`	`499`	`}`
`500`	`500`
`501`		`-func (mm *ModuleManager) SetModuleMaintenanceState(moduleName string, state utils.Maintenance) {`
	`501`	`+func (mm *ModuleManager) SetModuleMaintenance(moduleName string, state utils.Maintenance) {`
`502`	`502`	`if bm := mm.GetModule(moduleName); bm != nil {`
`503`		`- bm.SetMaintenanceState(state)`
	`503`	`+ bm.SetMaintenance(state)`
`504`	`504`	`mm.logger.Info("set module management state",`
`505`	`505`	`slog.String("module", moduleName),`
`506`	`506`	`slog.String("state", state.String()))`
`@@ -742,12 +742,12 @@ func (mm *ModuleManager) RunModule(moduleName string, logLabels map[string]strin`
`742`	`742`	`}`
`743`	`743`
`744`	`744`	`if err == nil {`
`745`		`- moduleMaintenanceState := bm.GetMaintenanceState()`
`746`		`- if moduleMaintenanceState != modules.UnmanagedEnforced {`
	`745`	`+ moduleMaintenance := bm.GetMaintenance()`
	`746`	`+ if moduleMaintenance != modules.UnmanagedEnforced {`
`747`	`747`	`err = helmModule.RunHelmInstall(logLabels)`
`748`	`748`	`}`
`749`	`749`
`750`		`- if moduleMaintenanceState == modules.UnmanagedEnabled {`
	`750`	`+ if moduleMaintenance == modules.UnmanagedEnabled {`
`751`	`751`	`bm.SetUnmanagedEnforced()`
`752`	`752`	`mm.dependencies.HelmResourcesManager.StopMonitor(moduleName)`
`753`	`753`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ var (`
`14`	`14`	`ModuleEnabled = true`
`15`	`15`	`ModuleDisabled = false`
`16`	`16`
`17`		`- EnabledSuffix = "Enabled"`
`18`		`- MaintenanceStateSuffix = "Maintenance"`
	`17`	`+ EnabledSuffix = "Enabled"`
	`18`	`+ MaintenanceSuffix = "Maintenance"`
`19`	`19`	`)`
`20`	`20`
`21`	`21`	`type Maintenance string`
`@@ -39,7 +39,7 @@ type ModuleConfig struct {`
`39`	`39`
`40`	`40`	`// String returns description of ModuleConfig values.`
`41`	`41`	`func (mc *ModuleConfig) String() string {`
`42`		`- return fmt.Sprintf("Module(Name=%s IsEnabled=%v MaintenanceState=%v Values:\n%s)", mc.ModuleName, mc.IsEnabled, mc.Maintenance, mc.values.DebugString())`
	`42`	`+ return fmt.Sprintf("Module(Name=%s IsEnabled=%v Maintenance=%v Values:\n%s)", mc.ModuleName, mc.IsEnabled, mc.Maintenance, mc.values.DebugString())`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`// ModuleConfigKey transforms module kebab-case name to the config camelCase name`
`@@ -52,9 +52,9 @@ func (mc *ModuleConfig) ModuleEnabledKey() string {`
`52`	`52`	`return ModuleNameToValuesKey(mc.ModuleName) + EnabledSuffix`
`53`	`53`	`}`
`54`	`54`
`55`		`-// ModuleMaintenanceStateKey transforms module kebab-case name to the config camelCase name with 'MaintenanceState' suffix`
`56`		`-func (mc *ModuleConfig) ModuleMaintenanceStateKey() string {`
`57`		`- return ModuleNameToValuesKey(mc.ModuleName) + MaintenanceStateSuffix`
	`55`	`+// ModuleMaintenanceKey transforms module kebab-case name to the config camelCase name with 'Maintenance' suffix`
	`56`	`+func (mc *ModuleConfig) ModuleMaintenanceKey() string {`
	`57`	`+ return ModuleNameToValuesKey(mc.ModuleName) + MaintenanceSuffix`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`// GetEnabled returns string description of enabled status.`
`@@ -72,7 +72,7 @@ func (mc *ModuleConfig) GetEnabled() string {`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`		`-func (mc *ModuleConfig) GetMaintenanceState() Maintenance {`
	`75`	`+func (mc *ModuleConfig) GetMaintenance() Maintenance {`
`76`	`76`	`if mc == nil {`
`77`	`77`	`return Managed`
`78`	`78`	`}`
`@@ -158,12 +158,12 @@ func (mc ModuleConfig) LoadFromValues(values Values) (ModuleConfig, error) {`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`		`- if maintenanceState, hasMaintenanceState := values[mc.ModuleMaintenanceStateKey()]; hasMaintenanceState {`
`162`		`- switch v := maintenanceState.(type) {`
	`161`	`+ if maintenance, hasMaintenance := values[mc.ModuleMaintenanceKey()]; hasMaintenance {`
	`162`	`+ switch v := maintenance.(type) {`
`163`	`163`	`case Maintenance:`
`164`	`164`	`mc.Maintenance = v`
`165`	`165`	`default:`
`166`		`- return nil, fmt.Errorf("load '%s' MaintenanceState config: MaintenanceState value should be string. Got: %#v", mc.ModuleName, maintenanceState)`
	`166`	`+ return nil, fmt.Errorf("load '%s' Maintenance config: Maintenance value should be string. Got: %#v", mc.ModuleName, maintenance)`
`167`	`167`	`}`
`168`	`168`	`}`
`169`	`169`