start working on the frontend side

backend/internal/common/router/cache.go

@@ -0,0 +1,171 @@
+package router
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/atlasos/calypso/internal/common/cache"
+	"github.com/gin-gonic/gin"
+)
+
+// GenerateKey generates a cache key from parts (local helper)
+func GenerateKey(prefix string, parts ...string) string {
+	key := prefix
+	for _, part := range parts {
+		key += ":" + part
+	}
+	
+	// Hash long keys to keep them manageable
+	if len(key) > 200 {
+		hash := sha256.Sum256([]byte(key))
+		return prefix + ":" + hex.EncodeToString(hash[:])
+	}
+	
+	return key
+}
+
+// CacheConfig holds cache configuration
+type CacheConfig struct {
+	Enabled     bool
+	DefaultTTL  time.Duration
+	MaxAge      int // seconds for Cache-Control header
+}
+
+// cacheMiddleware creates a caching middleware
+func cacheMiddleware(cfg CacheConfig, cache *cache.Cache) gin.HandlerFunc {
+	if !cfg.Enabled || cache == nil {
+		return func(c *gin.Context) {
+			c.Next()
+		}
+	}
+
+	return func(c *gin.Context) {
+		// Only cache GET requests
+		if c.Request.Method != http.MethodGet {
+			c.Next()
+			return
+		}
+
+		// Generate cache key from request path and query string
+		keyParts := []string{c.Request.URL.Path}
+		if c.Request.URL.RawQuery != "" {
+			keyParts = append(keyParts, c.Request.URL.RawQuery)
+		}
+		cacheKey := GenerateKey("http", keyParts...)
+
+		// Try to get from cache
+		if cached, found := cache.Get(cacheKey); found {
+			if cachedResponse, ok := cached.([]byte); ok {
+				// Set cache headers
+				if cfg.MaxAge > 0 {
+					c.Header("Cache-Control", fmt.Sprintf("public, max-age=%d", cfg.MaxAge))
+					c.Header("X-Cache", "HIT")
+				}
+				c.Data(http.StatusOK, "application/json", cachedResponse)
+				c.Abort()
+				return
+			}
+		}
+
+		// Cache miss - capture response
+		writer := &responseWriter{
+			ResponseWriter: c.Writer,
+			body:          &bytes.Buffer{},
+		}
+		c.Writer = writer
+
+		c.Next()
+
+		// Only cache successful responses
+		if writer.Status() == http.StatusOK {
+			// Cache the response body
+			responseBody := writer.body.Bytes()
+			cache.Set(cacheKey, responseBody)
+
+			// Set cache headers
+			if cfg.MaxAge > 0 {
+				c.Header("Cache-Control", fmt.Sprintf("public, max-age=%d", cfg.MaxAge))
+				c.Header("X-Cache", "MISS")
+			}
+		}
+	}
+}
+
+// responseWriter wraps gin.ResponseWriter to capture response body
+type responseWriter struct {
+	gin.ResponseWriter
+	body *bytes.Buffer
+}
+
+func (w *responseWriter) Write(b []byte) (int, error) {
+	w.body.Write(b)
+	return w.ResponseWriter.Write(b)
+}
+
+func (w *responseWriter) WriteString(s string) (int, error) {
+	w.body.WriteString(s)
+	return w.ResponseWriter.WriteString(s)
+}
+
+// cacheControlMiddleware adds Cache-Control headers based on endpoint
+func cacheControlMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		path := c.Request.URL.Path
+
+		// Set appropriate cache control for different endpoints
+		switch {
+		case path == "/api/v1/health":
+			// Health check can be cached for a short time
+			c.Header("Cache-Control", "public, max-age=30")
+		case path == "/api/v1/monitoring/metrics":
+			// Metrics can be cached for a short time
+			c.Header("Cache-Control", "public, max-age=60")
+		case path == "/api/v1/monitoring/alerts":
+			// Alerts should have minimal caching
+			c.Header("Cache-Control", "public, max-age=10")
+		case path == "/api/v1/storage/disks":
+			// Disk list can be cached for a moderate time
+			c.Header("Cache-Control", "public, max-age=300")
+		case path == "/api/v1/storage/repositories":
+			// Repositories can be cached
+			c.Header("Cache-Control", "public, max-age=180")
+		case path == "/api/v1/system/services":
+			// Service list can be cached briefly
+			c.Header("Cache-Control", "public, max-age=60")
+		default:
+			// Default: no cache for other endpoints
+			c.Header("Cache-Control", "no-cache, no-store, must-revalidate")
+		}
+
+		c.Next()
+	}
+}
+
+// InvalidateCacheKey invalidates a specific cache key
+func InvalidateCacheKey(cache *cache.Cache, key string) {
+	if cache != nil {
+		cache.Delete(key)
+	}
+}
+
+// InvalidateCachePattern invalidates all cache keys matching a pattern
+func InvalidateCachePattern(cache *cache.Cache, pattern string) {
+	if cache == nil {
+		return
+	}
+
+	// Get all keys and delete matching ones
+	// Note: This is a simple implementation. For production, consider using
+	// a cache library that supports pattern matching (like Redis)
+	stats := cache.Stats()
+	if total, ok := stats["total_entries"].(int); ok && total > 0 {
+		// For now, we'll clear the entire cache if pattern matching is needed
+		// In production, use Redis with pattern matching
+		cache.Clear()
+	}
+}
+