sysopsandClaude Sonnet 5
4180a26c6e
internal/cfgservice: Store (Schreiben/Historie) + Service (Lesen mit Vorrangregel + TTL-Cache, Default 5s, analog internal/flag). Genannt "cfgservice" statt "config", da internal/config bereits die Bootstrap- Konfiguration des Core-Prozesses selbst belegt. Store.Set schreibt aktuellen Stand (config_values) und Historieneintrag (config_value_history) atomar in einer Transaktion — eine Aenderung ohne Versionshistorie ist strukturell ausgeschlossen (Akzeptanzkriterium 2). Version wird pro (key, scope) monoton hochgezaehlt. Service.Resolve wendet die Vorrangregel an: Tenant-spezifischer Override (scope = Tenant-Slug) hat Vorrang vor globalem Default (scope = 'global'), faellt sauber zurueck wenn kein Override existiert (Akzeptanzkriterium 1). Invalidate erzwingt sofortiges Neuladen fuer den Schreiber, andere Instanzen sehen Aenderungen spaetestens nach der TTL. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Vorrangregel automatisiert getestet — TestService_TenantOverrideTakesPrecedenceOverGlobal: Tenant mit Override bekommt Tenant-Wert, Tenant ohne Override bekommt Global-Default. PASS. 2. Cache-Invalidierung nach Aenderung innerhalb dokumentierter Zeit gemessen — TestService_CacheInvalidationTiming: wirksam nach 154ms bei TTL=150ms (innerhalb Ziel+Toleranz), vorher nachweislich noch alter Stand. PASS. 3. Versionierungshistorie ueber mehrere Aenderungen nachvollzogen — TestStore_HistoryTracksAllChanges: 3 aufeinanderfolgende Aenderungen, Historie liefert alle 3 in korrekter Reihenfolge mit korrekten Versionsnummern. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
89 lines
2.3 KiB
Go
89 lines
2.3 KiB
Go
package cfgservice
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
|
|
// (Akzeptanzkriterium 2 / Pruefung 2 in diesem Ticket bezieht sich auf die
|
|
// Aenderungsnachvollziehbarkeit — die Cache-Frist selbst folgt demselben
|
|
// Muster wie internal/flag.DefaultCacheTTL).
|
|
const DefaultCacheTTL = 5 * time.Second
|
|
|
|
type cacheEntry struct {
|
|
value Value
|
|
expiresAt time.Time
|
|
}
|
|
|
|
// Service ist die Leseseite mit Vorrangregel (Akzeptanzkriterium 1:
|
|
// Tenant-Override vor Global-Default) und lokalem TTL-Cache.
|
|
type Service struct {
|
|
store *Store
|
|
ttl time.Duration
|
|
|
|
mu sync.RWMutex
|
|
cache map[string]cacheEntry // Schluessel: key + "\x00" + tenantSlug
|
|
}
|
|
|
|
func NewService(store *Store, ttl time.Duration) *Service {
|
|
if ttl <= 0 {
|
|
ttl = DefaultCacheTTL
|
|
}
|
|
return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
|
|
}
|
|
|
|
func cacheKey(key, tenantSlug string) string {
|
|
return key + "\x00" + tenantSlug
|
|
}
|
|
|
|
// Resolve liefert den Konfigurationswert fuer einen Tenant: ein
|
|
// Tenant-spezifischer Override hat Vorrang vor dem globalen Default
|
|
// (Akzeptanzkriterium 1 / Pruefung 1). tenantSlug == "" wertet nur den
|
|
// globalen Wert aus.
|
|
func (s *Service) Resolve(ctx context.Context, tenantSlug, key string) (Value, error) {
|
|
ck := cacheKey(key, tenantSlug)
|
|
|
|
s.mu.RLock()
|
|
entry, exists := s.cache[ck]
|
|
fresh := exists && time.Now().Before(entry.expiresAt)
|
|
s.mu.RUnlock()
|
|
if fresh {
|
|
return entry.value, nil
|
|
}
|
|
|
|
v, err := s.resolveUncached(ctx, tenantSlug, key)
|
|
if err != nil {
|
|
return Value{}, err
|
|
}
|
|
|
|
s.mu.Lock()
|
|
s.cache[ck] = cacheEntry{value: v, expiresAt: time.Now().Add(s.ttl)}
|
|
s.mu.Unlock()
|
|
return v, nil
|
|
}
|
|
|
|
func (s *Service) resolveUncached(ctx context.Context, tenantSlug, key string) (Value, error) {
|
|
if tenantSlug != "" {
|
|
v, err := s.store.Get(ctx, key, tenantSlug)
|
|
if err == nil {
|
|
return v, nil
|
|
}
|
|
if !errors.Is(err, ErrNotFound) {
|
|
return Value{}, err
|
|
}
|
|
}
|
|
return s.store.Get(ctx, key, GlobalScope)
|
|
}
|
|
|
|
// Invalidate erzwingt beim naechsten Resolve-Aufruf ein sofortiges Neuladen
|
|
// fuer einen bestimmten (key, tenantSlug) statt auf den TTL-Ablauf zu warten
|
|
// — analog internal/flag.Service.Invalidate.
|
|
func (s *Service) Invalidate(key, tenantSlug string) {
|
|
s.mu.Lock()
|
|
delete(s.cache, cacheKey(key, tenantSlug))
|
|
s.mu.Unlock()
|
|
}
|