refactor: standardize release list cache key usage and improve type handling

Signed-off-by: Evsyukov Denis <denis.evsyukov@flant.com>

Author: Evsyukov Denis

pkg/helm/nelm/cache.go

@@ -5,6 +5,10 @@ import (
 	"time"
 )
 
+const (
+	releaseListCacheKey = "release-list"
+)
+
 // cacheEntry represents a cached value with TTL
 type cacheEntry struct {
 	value     any
@@ -166,11 +170,11 @@ func (c *releaseStatusCache) setLabels(key string, labels map[string]string) {
 }
 
 // getReleaseList retrieves cached list of release names if it exists and hasn't expired
-func (c *releaseStatusCache) getReleaseList(key string) ([]string, bool) {
+func (c *releaseStatusCache) getReleaseList() ([]string, bool) {
 	c.mutex.RLock()
 	defer c.mutex.RUnlock()
 
-	entry, exists := c.entries[key]
+	entry, exists := c.entries[releaseListCacheKey]
 	if !exists || entry.isExpired() {
 		return nil, false
 	}
@@ -182,11 +186,11 @@ func (c *releaseStatusCache) getReleaseList(key string) ([]string, bool) {
 }
 
 // setReleaseList stores list of release names in cache with TTL
-func (c *releaseStatusCache) setReleaseList(key string, names []string) {
+func (c *releaseStatusCache) setReleaseList(names []string) {
 	c.mutex.Lock()
 	defer c.mutex.Unlock()
 
-	c.entries[key] = &cacheEntry{
+	c.entries[releaseListCacheKey] = &cacheEntry{
 		value:     &releaseList{names: names},
 		expiresAt: time.Now().Add(c.ttl),
 	}

pkg/helm/nelm/cache_release_list_test.go

@@ -9,16 +9,16 @@ func TestReleaseListCache(t *testing.T) {
 	cache := newReleaseStatusCache(1 * time.Second)
 
 	// Test cache miss
-	_, found := cache.getReleaseList("release-list")
+	_, found := cache.getReleaseList()
 	if found {
 		t.Error("Expected cache miss for release list")
 	}
 
 	// Test cache set and hit
 	expectedList := []string{"release1", "release2", "release3"}
-	cache.setReleaseList("release-list", expectedList)
+	cache.setReleaseList(expectedList)
 
-	cachedList, found := cache.getReleaseList("release-list")
+	cachedList, found := cache.getReleaseList()
 	if !found {
 		t.Error("Expected cache hit for release list")
 	}
@@ -33,20 +33,20 @@ func TestReleaseListCache(t *testing.T) {
 
 	// Test cache expiration
 	time.Sleep(1100 * time.Millisecond)
-	_, found = cache.getReleaseList("release-list")
+	_, found = cache.getReleaseList()
 	if found {
 		t.Error("Expected cache miss after expiration")
 	}
 
 	// Test invalidation
-	cache.setReleaseList("release-list", expectedList)
-	_, found = cache.getReleaseList("release-list")
+	cache.setReleaseList(expectedList)
+	_, found = cache.getReleaseList()
 	if !found {
 		t.Error("Expected cache hit before invalidation")
 	}
 
 	cache.invalidate("some-release")
-	_, found = cache.getReleaseList("release-list")
+	_, found = cache.getReleaseList()
 	if found {
 		t.Error("Expected cache miss after invalidation")
 	}

pkg/helm/nelm/nelm.go

@@ -141,9 +141,7 @@ func (c *NelmClient) GetReleaseLabels(releaseName, labelName string) (string, er
 	// In nelm, labels are stored as annotations - cache all of them
 	allLabels := make(map[string]string)
 	if releaseGetResult.Release != nil && releaseGetResult.Release.Annotations != nil {
-		for k, v := range releaseGetResult.Release.Annotations {
-			allLabels[k] = v
-		}
+		maps.Copy(allLabels, releaseGetResult.Release.Annotations)
 	}
 
 	// Cache all labels for future use
@@ -312,7 +310,7 @@ func (c *NelmClient) GetReleaseValues(releaseName string) (utils.Values, error)
 	}
 
 	// Cache the result
-	c.statusCache.setValues(valuesKey, map[string]interface{}(result))
+	c.statusCache.setValues(valuesKey, map[string]any(result))
 	c.logger.Debug("Fetched and cached release values", slog.String("release", releaseName))
 
 	return result, nil
@@ -404,8 +402,7 @@ func (c *NelmClient) IsReleaseExists(releaseName string) (bool, error) {
 
 func (c *NelmClient) ListReleasesNames() ([]string, error) {
 	// Check cache first
-	cacheKey := "release-list"
-	if cachedList, found := c.statusCache.getReleaseList(cacheKey); found {
+	if cachedList, found := c.statusCache.getReleaseList(); found {
 		c.logger.Debug("Using cached release list", slog.Int("count", len(cachedList)))
 		return cachedList, nil
 	}
@@ -437,7 +434,7 @@ func (c *NelmClient) ListReleasesNames() ([]string, error) {
 	sort.Strings(releaseNames)
 
 	// Cache the result
-	c.statusCache.setReleaseList(cacheKey, releaseNames)
+	c.statusCache.setReleaseList(releaseNames)
 	c.logger.Debug("Fetched and cached release list", slog.Int("count", len(releaseNames)))
 
 	return releaseNames, nil

pkg/task/batch/batch.go

@@ -2,6 +2,7 @@ package batch
 
 import (
 	"context"
+	"maps"
 	"sort"
 	"sync"
 	"time"
@@ -16,7 +17,7 @@ import (
 type ModuleManagerInterface interface {
 	GetFunctionalDependencies() map[string][]string
 	GetCritical(moduleName string) bool
-	GetModule(name string) interface{}
+	GetModule(name string) any
 }
 
 // BatchConfig defines configuration for batching operations
@@ -401,9 +402,7 @@ func (bs *BatchScheduler) GetActiveBatches() map[string]*ModuleBatch {
 	defer bs.mu.RUnlock()
 
 	result := make(map[string]*ModuleBatch, len(bs.activeBatches))
-	for id, batch := range bs.activeBatches {
-		result[id] = batch
-	}
+	maps.Copy(result, bs.activeBatches)
 
 	return result
 }

pkg/task/batch/integration.go

@@ -17,7 +17,7 @@ type ModuleManagerAdapter struct {
 	*module_manager.ModuleManager
 }
 
-func (a *ModuleManagerAdapter) GetModule(name string) interface{} {
+func (a *ModuleManagerAdapter) GetModule(name string) any {
 	return a.ModuleManager.GetModule(name)
 }
 

pkg/task/batch/optimizer.go

@@ -2,6 +2,7 @@ package batch
 
 import (
 	"context"
+	"slices"
 	"sync"
 	"time"
 
@@ -175,9 +176,7 @@ func (bo *BatchOptimizer) GetOptimalBatchSize(baseSize int) int {
 	optimalSize := int(float64(baseSize) * loadFactor)
 
 	// Ensure reasonable bounds
-	if optimalSize < 1 {
-		optimalSize = 1
-	}
+	optimalSize = max(optimalSize, 1)
 	if optimalSize > 10 {
 		optimalSize = 10
 	}
@@ -304,12 +303,7 @@ func (r *ConflictAvoidanceRule) Apply(_ context.Context, batch *ModuleBatch, sta
 		hasConflict := false
 		for addedModule := range addedModules {
 			if moduleConflicts, exists := conflicts[module]; exists {
-				for _, conflictModule := range moduleConflicts {
-					if conflictModule == addedModule {
-						hasConflict = true
-						break
-					}
-				}
+				hasConflict = slices.Contains(moduleConflicts, addedModule)
 			}
 			if hasConflict {
 				break