Merge pull request #674 from meshery/registry-optimizations

Registry optimizations

Author: aabidsofi19

build/Makefile.core.mk

@@ -22,7 +22,7 @@ GOVERSION = 1.23.4
 GOPATH = $(shell go env GOPATH)
 GOBIN  = $(GOPATH)/bin
 
-SHELL :=/bin/bash -o pipefail
+SHELL :=/usr/bin/env bash -o pipefail
 
 #-----------------------------------------------------------------------------
 # Build

models/meshmodel/registry/registry.go

@@ -2,9 +2,6 @@ package registry
 
 import (
 	"fmt"
-	"strings"
-	"time"
-
 	"github.com/gofrs/uuid"
 	"github.com/layer5io/meshkit/database"
 	models "github.com/layer5io/meshkit/models/meshmodel/core/v1beta1"
@@ -17,6 +14,9 @@ import (
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 	"gorm.io/gorm/clause"
+	"strings"
+	"sync"
+	"time"
 )
 
 // MeshModelRegistrantData struct defines the body of the POST request that is sent to the capability
@@ -31,6 +31,43 @@ type MeshModelRegistrantData struct {
 	EntityType entity.EntityType     `json:"entityType"`
 	Entity     []byte                `json:"entity"` //This will be type converted to appropriate entity on server based on passed entity type
 }
+
+type EntityCacheValue struct {
+	Entities []entity.Entity
+	Count    int64
+	Unique   int
+	err      error
+}
+
+// RegistryEntityCache is a thread-safe cache for storing entity query results.
+//
+// This cache maps entity filters (`entity.Filter`) to their corresponding results (`EntityCacheValue`).
+// It uses `sync.Map` for safe concurrent access, making it suitable for multi-goroutine environments.
+//
+// The caller is responsible for managing the cache's lifecycle, including eviction and expiration if needed.
+type RegistryEntityCache struct {
+	cache sync.Map
+}
+
+func filterKey(f entity.Filter) string {
+	// Convert the filter to a unique string representation (adjust as needed)
+	return fmt.Sprintf("%v", f)
+}
+
+// Get retrieves a cached value
+func (c *RegistryEntityCache) Get(f entity.Filter) (EntityCacheValue, bool) {
+	value, exists := c.cache.Load(filterKey(f))
+	if exists {
+		return value.(EntityCacheValue), true
+	}
+	return EntityCacheValue{}, false
+}
+
+// Set stores a value in the cache
+func (c *RegistryEntityCache) Set(f entity.Filter, value EntityCacheValue) {
+	c.cache.Store(filterKey(f), value)
+}
+
 type Registry struct {
 	ID           uuid.UUID
 	RegistrantID uuid.UUID
@@ -196,6 +233,52 @@ func (rm *RegistryManager) GetEntities(f entity.Filter) ([]entity.Entity, int64,
 	return f.Get(rm.db)
 }
 
+// GetEntitiesMemoized retrieves entities based on the provided filter `f`, using a concurrent-safe cache to optimize performance.
+//
+// ## Cache Behavior:
+//   - **Cache Hit**: If the requested entities are found in the `cache`, the function returns the cached result immediately, avoiding a redundant query.
+//   - **Cache Miss**: If the requested entities are *not* found in the cache, the function fetches them from the registry using `rm.GetEntities(f)`,
+//     stores the result in the `cache`, and returns the newly retrieved entities.
+//
+// ## Concurrency and Thread Safety:
+// - The `cache` is implemented using `sync.Map`, ensuring **safe concurrent access** across multiple goroutines.
+// - `sync.Map` is optimized for scenarios where **reads significantly outnumber writes**, making it well-suited for caching use cases.
+//
+// ## Ownership and Responsibility:
+//   - **RegistryManager (`rm`)**: Owns the logic for retrieving entities from the source when a cache miss occurs.
+//   - **Caller Ownership of Cache**: The caller is responsible for providing and managing the `cache` instance.
+//     This function does *not* handle cache eviction, expiration, or memory constraints—those concerns must be managed externally.
+//
+// ## Parameters:
+// - `f entity.Filter`: The filter criteria used to retrieve entities.
+// - `cache *RegistryEntityCache`: A pointer to a concurrent-safe cache (`sync.Map`) that stores previously retrieved entity results.
+//
+// ## Returns:
+// - `[]entity.Entity`: The list of retrieved entities (either from cache or freshly fetched).
+// - `int64`: The total count of entities matching the filter.
+// - `int`: The number of unique entities found.
+// - `error`: An error if the retrieval operation fails.
+func (rm *RegistryManager) GetEntitiesMemoized(f entity.Filter, cache *RegistryEntityCache) ([]entity.Entity, int64, int, error) {
+
+	// Attempt to retrieve from cache
+	if cachedEntities, exists := cache.Get(f); exists && len(cachedEntities.Entities) > 0 {
+		return cachedEntities.Entities, cachedEntities.Count, cachedEntities.Unique, cachedEntities.err
+	}
+
+	// Fetch from source if cache miss
+	entities, count, unique, err := rm.GetEntities(f)
+
+	// Store result in cache
+	cache.Set(f, EntityCacheValue{
+		Entities: entities,
+		Count:    count,
+		Unique:   unique,
+		err:      err,
+	})
+
+	return entities, count, unique, err
+}
+
 func HostnameToPascalCase(input string) string {
 	parts := strings.Split(input, ".")
 	caser := cases.Title(language.English)

utils/utils.go

@@ -20,9 +20,12 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"time"
 	"unicode"
 
+	"github.com/layer5io/meshkit/logger"
 	"github.com/layer5io/meshkit/models/meshmodel/entity"
+	"github.com/open-policy-agent/opa/v1/logging"
 	log "github.com/sirupsen/logrus"
 	"gopkg.in/yaml.v3"
 
@@ -866,3 +869,9 @@ func ParseKubeStatusErr(err *kubeerror.StatusError) (shortDescription, longDescr
 
 	return
 }
+
+func trackTime(logger logger.Handler, start time.Time, name string) {
+
+	elapsed := time.Since(start)
+	logger.Debugf("%s took %s\n", name, elapsed)
+}