feat: add backend caching for AMT API endpoints

internal/cache/cache.go

@@ -0,0 +1,117 @@
+package cache
+
+import (
+	"sync"
+	"time"
+)
+
+const (
+	// CleanupInterval is how often expired cache entries are removed.
+	CleanupInterval = 30 * time.Second
+	// PowerStateTTL is the cache duration for power state (changes frequently).
+	PowerStateTTL = 5 * time.Second
+	// FeaturesTTL is the cache duration for features (rarely changes).
+	FeaturesTTL = 30 * time.Second
+	// KVMTTL is the cache duration for KVM display settings (rarely changes).
+	KVMTTL = 30 * time.Second
+)
+
+// Entry represents a cached value with expiration.
+type Entry struct {
+	Value     interface{}
+	ExpiresAt time.Time
+}
+
+// Cache is a simple in-memory cache with TTL support.
+type Cache struct {
+	mu    sync.RWMutex
+	items map[string]Entry
+}
+
+// New creates a new Cache instance.
+func New() *Cache {
+	c := &Cache{
+		items: make(map[string]Entry),
+	}
+	// Start cleanup goroutine
+	go c.cleanupExpired()
+
+	return c
+}
+
+// Set stores a value in the cache with the given TTL.
+func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.items[key] = Entry{
+		Value:     value,
+		ExpiresAt: time.Now().Add(ttl),
+	}
+}
+
+// Get retrieves a value from the cache.
+// Returns the value and true if found and not expired, nil and false otherwise.
+func (c *Cache) Get(key string) (interface{}, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	entry, found := c.items[key]
+	if !found {
+		return nil, false
+	}
+
+	if time.Now().After(entry.ExpiresAt) {
+		return nil, false
+	}
+
+	return entry.Value, true
+}
+
+// Delete removes a value from the cache.
+func (c *Cache) Delete(key string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	delete(c.items, key)
+}
+
+// DeletePattern removes all keys matching a pattern (simple prefix match).
+func (c *Cache) DeletePattern(prefix string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	for key := range c.items {
+		if len(key) >= len(prefix) && key[:len(prefix)] == prefix {
+			delete(c.items, key)
+		}
+	}
+}
+
+// Clear removes all items from the cache.
+func (c *Cache) Clear() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.items = make(map[string]Entry)
+}
+
+// cleanupExpired runs periodically to remove expired entries.
+func (c *Cache) cleanupExpired() {
+	ticker := time.NewTicker(CleanupInterval)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		c.mu.Lock()
+
+		now := time.Now()
+
+		for key, entry := range c.items {
+			if now.After(entry.ExpiresAt) {
+				delete(c.items, key)
+			}
+		}
+
+		c.mu.Unlock()
+	}
+}

internal/cache/keys.go

@@ -0,0 +1,46 @@
+package cache
+
+import "fmt"
+
+// Cache key prefixes.
+const (
+	PrefixFeatures   = "features:"
+	PrefixPowerState = "power:"
+	PrefixKVMDisplay = "kvm:display:"
+	PrefixKVMInit    = "kvm:init:"
+	PrefixGeneral    = "general:"
+)
+
+// MakeFeaturesKey creates a cache key for device features.
+func MakeFeaturesKey(guid string) string {
+	return fmt.Sprintf("%s%s", PrefixFeatures, guid)
+}
+
+// MakePowerStateKey creates a cache key for power state.
+func MakePowerStateKey(guid string) string {
+	return fmt.Sprintf("%s%s", PrefixPowerState, guid)
+}
+
+// MakeKVMDisplayKey creates a cache key for KVM displays.
+func MakeKVMDisplayKey(guid string) string {
+	return fmt.Sprintf("%s%s", PrefixKVMDisplay, guid)
+}
+
+// MakeGeneralSettingsKey creates a cache key for general settings.
+func MakeGeneralSettingsKey(guid string) string {
+	return fmt.Sprintf("%s%s", PrefixGeneral, guid)
+}
+
+// MakeKVMInitKey creates a cache key for KVM initialization data.
+func MakeKVMInitKey(guid string) string {
+	return fmt.Sprintf("%s%s", PrefixKVMInit, guid)
+}
+
+// InvalidateDeviceCache removes all cached data for a device.
+func InvalidateDeviceCache(c *Cache, guid string) {
+	c.Delete(MakeFeaturesKey(guid))
+	c.Delete(MakePowerStateKey(guid))
+	c.Delete(MakeKVMDisplayKey(guid))
+	c.Delete(MakeKVMInitKey(guid))
+	c.Delete(MakeGeneralSettingsKey(guid))
+}

internal/controller/httpapi/v1/devicemanagement.go

@@ -63,6 +63,9 @@ func NewAmtRoutes(handler *gin.RouterGroup, d devices.Feature, amt amtexplorer.F
 		h.GET("kvm/displays/:guid", r.getKVMDisplays)
 		h.PUT("kvm/displays/:guid", r.setKVMDisplays)
 
+		// KVM initialization - combines display, power, redirection, and features
+		h.GET("kvm/init/:guid", r.getKVMInitData)
+
 		// Network link preference
 		h.POST("network/linkPreference/:guid", r.setLinkPreference)
 	}

internal/controller/httpapi/v1/kvminit.go

@@ -0,0 +1,24 @@
+package v1
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+// getKVMInitData returns all data needed to initialize a KVM session.
+// This combines display settings, power state, redirection status, and features
+// into a single API call to reduce latency.
+func (r *deviceManagementRoutes) getKVMInitData(c *gin.Context) {
+	guid := c.Param("guid")
+
+	initData, err := r.d.GetKVMInitData(c.Request.Context(), guid)
+	if err != nil {
+		r.l.Error(err, "http - v1 - getKVMInitData")
+		ErrorResponse(c, err)
+
+		return
+	}
+
+	c.JSON(http.StatusOK, initData)
+}

internal/controller/openapi/devicemanagement.go

@@ -32,6 +32,14 @@ func (f *FuegoAdapter) registerKVMAndCertificateRoutes() {
 		fuego.OptionPath("guid", "Device GUID"),
 	)
 
+	// kvm initialization
+	fuego.Get(f.server, "/api/v1/admin/kvm/init/{guid}", f.getKVMInitData,
+		fuego.OptionTags("Device Management"),
+		fuego.OptionSummary("Get KVM initialization data"),
+		fuego.OptionDescription("Retrieve all data needed to initialize a KVM session (display settings, power state, redirection status, and features) in a single call"),
+		fuego.OptionPath("guid", "Device GUID"),
+	)
+
 	// Certificates
 	fuego.Get(f.server, "/api/v1/admin/amt/certificates/{guid}", f.getCertificates,
 		fuego.OptionTags("Device Management"),
@@ -299,6 +307,47 @@ func (f *FuegoAdapter) setKVMDisplays(c fuego.ContextWithBody[dto.KVMScreenSetti
 	return dto.KVMScreenSettings{Displays: []dto.KVMScreenDisplay{display}}, nil
 }
 
+func (f *FuegoAdapter) getKVMInitData(_ fuego.ContextNoBody) (dto.KVMInitResponse, error) {
+	return dto.KVMInitResponse{
+		DisplaySettings: dto.KVMScreenSettings{
+			Displays: []dto.KVMScreenDisplay{
+				{
+					DisplayIndex: 0,
+					IsActive:     true,
+					ResolutionX:  1920,
+					ResolutionY:  1080,
+					UpperLeftX:   0,
+					UpperLeftY:   0,
+					Role:         "primary",
+					IsDefault:    true,
+				},
+			},
+		},
+		PowerState: dto.PowerState{
+			PowerState:         2,
+			OSPowerSavingState: 0,
+		},
+		RedirectionStatus: dto.KVMRedirectionStatus{
+			IsSOLConnected:  false,
+			IsIDERConnected: false,
+		},
+		Features: dto.GetFeaturesResponse{
+			Redirection:           true,
+			KVM:                   true,
+			SOL:                   true,
+			IDER:                  true,
+			OptInState:            0,
+			UserConsent:           "none",
+			KVMAvailable:          true,
+			OCR:                   false,
+			HTTPSBootSupported:    false,
+			WinREBootSupported:    false,
+			LocalPBABootSupported: false,
+			RemoteErase:           false,
+		},
+	}, nil
+}
+
 func (f *FuegoAdapter) getCertificates(_ fuego.ContextNoBody) (dto.SecuritySettings, error) {
 	return dto.SecuritySettings{}, nil
 }

internal/controller/ws/v1/interface.go

@@ -66,4 +66,8 @@ type Feature interface {
 	// KVM Screen Settings
 	GetKVMScreenSettings(c context.Context, guid string) (dto.KVMScreenSettings, error)
 	SetKVMScreenSettings(c context.Context, guid string, req dto.KVMScreenSettingsRequest) (dto.KVMScreenSettings, error)
+	// KVM Initialization Data - combined endpoint for display, power, redirection, and features
+	GetKVMInitData(c context.Context, guid string) (dto.KVMInitResponse, error)
+	// Link Preference (AMT_EthernetPortSettings)
+	SetLinkPreference(c context.Context, guid string, req dto.LinkPreferenceRequest) (dto.LinkPreferenceResponse, error)
 }

internal/entity/dto/v1/kvminit.go

@@ -0,0 +1,16 @@
+package dto
+
+// KVMInitResponse combines all data needed to initialize KVM session.
+// This reduces multiple API calls into a single request.
+type KVMInitResponse struct {
+	DisplaySettings   KVMScreenSettings    `json:"displaySettings"`
+	PowerState        PowerState           `json:"powerState"`
+	RedirectionStatus KVMRedirectionStatus `json:"redirectionStatus"`
+	Features          GetFeaturesResponse  `json:"features"`
+}
+
+// KVMRedirectionStatus represents the status of redirection services.
+type KVMRedirectionStatus struct {
+	IsSOLConnected  bool `json:"isSOLConnected"`
+	IsIDERConnected bool `json:"isIDERConnected"`
+}