add mutex and make sure Entries() doesn't return original map

Signed-off-by: Pranav Gaikwad <pgaikwad@redhat.com>

Author: pranavgaikwad

kai_analyzer_rpc/pkg/service/analyzer.go

@@ -61,7 +61,6 @@ type analyzer struct {
 	discoveryCacheMutex sync.Mutex
 	discoveryCache      []konveyor.RuleSet
 	cache               IncidentsCache
-	cacheMutex          sync.RWMutex
 
 	contextLines int
 	location     string
@@ -176,7 +175,6 @@ func NewAnalyzer(limitIncidents, limitCodeSnips, contextLines int, location, inc
 		discoveryCache:      []konveyor.RuleSet{},
 		discoveryCacheMutex: sync.Mutex{},
 		cache:               NewIncidentsCache(log),
-		cacheMutex:          sync.RWMutex{},
 	}, nil
 
 }
@@ -328,16 +326,11 @@ func (a *analyzer) NotifyFileChanges(client *rpc.Client, args NotifyFileChangesA
 }
 
 func (a *analyzer) setCache(rulesets []konveyor.RuleSet) {
-	a.cacheMutex.Lock()
-	defer a.cacheMutex.Unlock()
 	a.cache = NewIncidentsCache(a.Logger)
-
 	a.addRulesetsToCache(rulesets)
 }
 
 func (a *analyzer) updateCache(rulesets []konveyor.RuleSet, includedPaths []string) {
-	a.cacheMutex.Lock()
-	defer a.cacheMutex.Unlock()
 	if includedPaths != nil {
 		a.invalidateCachePerFile(includedPaths)
 	}
@@ -379,9 +372,6 @@ func (a *analyzer) invalidateCachePerFile(paths []string) {
 }
 
 func (a *analyzer) createRulesetsFromCache() []konveyor.RuleSet {
-	a.cacheMutex.RLock()
-	defer a.cacheMutex.RUnlock()
-
 	ruleSetMap := map[string]konveyor.RuleSet{}
 	a.Logger.V(8).Info("cache", "cacheVal", a.cache)
 	for filePath, cacheValue := range a.cache.Entries() {

kai_analyzer_rpc/pkg/service/cache.go

@@ -3,6 +3,7 @@ package service
 import (
 	"path/filepath"
 	"strings"
+	"sync"
 
 	"github.com/go-logr/logr"
 	"github.com/konveyor/analyzer-lsp/output/v1/konveyor"
@@ -27,26 +28,32 @@ func NewIncidentsCache(logger logr.Logger) IncidentsCache {
 	return &incidentsCache{
 		cache:  map[string][]CacheValue{},
 		logger: logger,
+		mutex:  sync.RWMutex{},
 	}
 }
 
 type incidentsCache struct {
 	cache  map[string][]CacheValue
 	logger logr.Logger
+	mutex  sync.RWMutex
 }
 
 func (i *incidentsCache) Len() int {
 	return len(i.cache)
 }
 
 func (i *incidentsCache) Get(path string) ([]CacheValue, bool) {
+	i.mutex.RLock()
+	defer i.mutex.RUnlock()
 	normalizedPath := normalizePath(path)
 	i.logger.V(8).Info("getting cache entry for path", "path", path, "normalizedPath", normalizedPath)
 	val, ok := i.cache[normalizedPath]
 	return val, ok
 }
 
 func (i *incidentsCache) Add(path string, value CacheValue) {
+	i.mutex.Lock()
+	defer i.mutex.Unlock()
 	normalizedPath := normalizePath(path)
 	i.logger.V(8).Info("adding cache entry for path", "path", path, "normalizedPath", normalizedPath)
 	if _, ok := i.cache[normalizedPath]; !ok {
@@ -56,12 +63,16 @@ func (i *incidentsCache) Add(path string, value CacheValue) {
 }
 
 func (i *incidentsCache) Delete(path string) {
+	i.mutex.Lock()
+	defer i.mutex.Unlock()
 	normalizedPath := normalizePath(path)
 	i.logger.V(8).Info("deleting cache entry for path", "path", path, "normalizedPath", normalizedPath)
 	delete(i.cache, normalizedPath)
 }
 
 func (i *incidentsCache) Keys() []string {
+	i.mutex.RLock()
+	defer i.mutex.RUnlock()
 	keys := make([]string, 0, len(i.cache))
 	for k := range i.cache {
 		keys = append(keys, k)
@@ -70,13 +81,22 @@ func (i *incidentsCache) Keys() []string {
 }
 
 func (i *incidentsCache) Entries() map[string][]CacheValue {
-	return i.cache
+	i.mutex.RLock()
+	defer i.mutex.RUnlock()
+	// make sure we never return a reference to original map or any of its slices
+	clone := make(map[string][]CacheValue, len(i.cache))
+	for k, v := range i.cache {
+		clonedV := make([]CacheValue, len(v))
+		copy(clonedV, v)
+		clone[k] = clonedV
+	}
+	return clone
 }
 
 func normalizePath(path string) string {
 	cleanedPath := filepath.Clean(path)
 	volumeName := filepath.VolumeName(cleanedPath)
-	// make sure all volume names are lowercase
+	// make sure all volume names are uppercase
 	if volumeName != "" {
 		cleanedPath = strings.ToUpper(volumeName) + cleanedPath[len(volumeName):]
 	}

kai_analyzer_rpc/pkg/service/pipe_analyzer.go

@@ -80,7 +80,6 @@ func NewPipeAnalyzer(ctx context.Context, limitIncidents, limitCodeSnips, contex
 		discoveryCache:          []konveyor.RuleSet{},
 		discoveryCacheMutex:     sync.Mutex{},
 		cache:                   NewIncidentsCache(l),
-		cacheMutex:              sync.RWMutex{},
 		location:                location,
 		contextLines:            contextLines,
 		rules:                   rules,