Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
refactor: centralize/replace manual caching with samber/hot (#3324)
Kyle Mendell1712fc46a46e
diff --git a/backend/api/ws/handler.go b/backend/api/ws/handler.goindex 87f63a771..e3d1b5ce3 100644--- a/backend/api/ws/handler.go+++ b/backend/api/ws/handler.go@@ -16,6 +16,7 @@ import ("github.com/gorilla/websocket""github.com/labstack/echo/v4"+ "github.com/samber/hot""github.com/shirou/gopsutil/v4/cpu""github.com/shirou/gopsutil/v4/disk""github.com/shirou/gopsutil/v4/host"@@ -78,12 +79,7 @@ type WebSocketHandler struct {cgroupCache *cgroup.CachegpuMonitor *system.GPUMonitor- diskUsagePathCache struct {- sync.RWMutex-- value string- timestamp time.Time- }+ diskUsagePathCache *hot.HotCache[struct{}, string]projectLogStreamer func(ctx context.Context, projectID string, logsChan chan<- string, follow bool, tail, since string, timestamps bool) errorcontainerLogStreamer func(ctx context.Context, containerID string, logsChan chan<- string, follow bool, tail, since string, timestamps bool) errorsystemStatsCollector func(ctx context.Context) systemtypes.SystemStats@@ -233,6 +229,9 @@ func NewWebSocketHandler(logStreams: make(map[string]*wsLogStream),cgroupCache: cgroup.NewCache(cgroupCacheTTL),gpuMonitor: system.NewGPUMonitor(cfg.GPUMonitoringEnabled, cfg.GPUType),+ diskUsagePathCache: hot.NewHotCache[struct{}, string](hot.LRU, 1).+ WithTTL(5 * time.Minute).+ Build(),wsUpgrader: websocket.Upgrader{CheckOrigin: httputil.ValidateWebSocketOrigin(cfg.GetAppURL()),ReadBufferSize: 32 * 1024,@@ -1345,26 +1344,20 @@ func (h *WebSocketHandler) readSystemStatsPumpInternal(ctx context.Context, canc}func (h *WebSocketHandler) getDiskUsagePath(ctx context.Context) string {- h.diskUsagePathCache.RLock()- if h.diskUsagePathCache.value != "" && time.Since(h.diskUsagePathCache.timestamp) < 5*time.Minute {- path := h.diskUsagePathCache.value- h.diskUsagePathCache.RUnlock()- return path- }- h.diskUsagePathCache.RUnlock()-- // Default path- path := "/"-- // Try to get Docker root from system service- if h.systemService != nil {- path = h.systemService.GetDiskUsagePath(ctx)+ if h.diskUsagePathCache == nil {+ h.diskUsagePathCache = hot.NewHotCache[struct{}, string](hot.LRU, 1).+ WithTTL(5 * time.Minute).+ Build()+ }+ path, found, err := h.diskUsagePathCache.GetWithLoaders(struct{}{}, func(_ []struct{}) (map[struct{}]string, error) {+ path := "/"+ if h.systemService != nil {+ path = h.systemService.GetDiskUsagePath(ctx)+ }+ return map[struct{}]string{{}: path}, nil+ })+ if err != nil || !found {+ return "/"}-- h.diskUsagePathCache.Lock()- h.diskUsagePathCache.value = path- h.diskUsagePathCache.timestamp = time.Now()- h.diskUsagePathCache.Unlock()-return path}diff --git a/backend/go.mod b/backend/go.modindex 36951030b..30c335360 100644--- a/backend/go.mod+++ b/backend/go.mod@@ -44,6 +44,7 @@ require (github.com/orandin/slog-gorm v1.4.0github.com/pressly/goose/v3 v3.27.2github.com/robfig/cron/v3 v3.0.1+ github.com/samber/hot v0.13.0github.com/samber/mo v1.17.0github.com/samber/slog-echo v1.23.0github.com/shirou/gopsutil/v4 v4.26.6@@ -55,9 +56,9 @@ require (go.getarcane.app/docker/convert v0.1.0go.getarcane.app/streams v0.3.1go.getarcane.app/sys/atomic v0.1.0- go.getarcane.app/sys/cgroup v0.1.0+ go.getarcane.app/sys/cgroup v0.1.1go.getarcane.app/sys/crypto v0.1.0- go.getarcane.app/updater v0.6.0+ go.getarcane.app/updater v0.6.1go.uber.org/fx v1.24.0go.yaml.in/yaml/v4 v4.0.0-rc.6golang.org/x/crypto v0.54.0@@ -78,6 +79,7 @@ require (dario.cat/mergo v1.0.2 // indirectgithub.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirectgithub.com/DefangLabs/secret-detector v0.0.0-20250811234530-d4b4214cd679 // indirect+ github.com/DmitriyVTitov/size v1.5.0 // indirectgithub.com/Microsoft/go-winio v0.6.3-0.20251027160822-ad3df93bed29 // indirectgithub.com/ProtonMail/go-crypto v1.4.1 // indirectgithub.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect@@ -93,6 +95,7 @@ require (github.com/aws/aws-sdk-go-v2/service/ssooidc v1.37.1 // indirectgithub.com/aws/aws-sdk-go-v2/service/sts v1.44.1 // indirectgithub.com/aws/smithy-go v1.27.3 // indirect+ github.com/beorn7/perks v1.0.1 // indirectgithub.com/buger/goterm v1.0.4 // indirectgithub.com/cespare/xxhash/v2 v2.3.0 // indirectgithub.com/clipperhouse/uax29/v2 v2.7.0 // indirect@@ -170,6 +173,7 @@ require (github.com/moby/sys/userns v0.1.0 // indirectgithub.com/moby/term v0.5.2 // indirectgithub.com/morikuni/aec v1.1.0 // indirect+ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirectgithub.com/ncruces/go-strftime v1.0.0 // indirectgithub.com/pelletier/go-toml/v2 v2.3.1 // indirectgithub.com/pjbgf/sha1cd v0.6.0 // indirect@@ -177,7 +181,12 @@ require (github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirectgithub.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirectgithub.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect+ github.com/prometheus/client_golang v1.23.2 // indirect+ github.com/prometheus/client_model v0.6.2 // indirect+ github.com/prometheus/common v0.67.5 // indirect+ github.com/prometheus/procfs v0.20.1 // indirectgithub.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect+ github.com/samber/go-singleflightx v0.3.2 // indirectgithub.com/samber/lo v1.53.0 // indirectgithub.com/santhosh-tekuri/jsonschema/v6 v6.0.2 // indirectgithub.com/secure-systems-lab/go-securesystemslib v0.11.0 // indirect@@ -222,6 +231,7 @@ require (go.uber.org/dig v1.19.0 // indirectgo.uber.org/multierr v1.11.0 // indirectgo.uber.org/zap v1.26.0 // indirect+ go.yaml.in/yaml/v2 v2.4.4 // indirectgolang.org/x/sys v0.47.0 // indirectgolang.org/x/term v0.45.0 // indirectgoogle.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa // indirectdiff --git a/backend/go.sum b/backend/go.sumindex 7f1042671..e64df11ff 100644--- a/backend/go.sum+++ b/backend/go.sum@@ -8,6 +8,8 @@ github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKgithub.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=github.com/DefangLabs/secret-detector v0.0.0-20250811234530-d4b4214cd679 h1:qNT7R4qrN+5u5ajSbqSW1opHP4LA8lzA+ASyw5MQZjs=github.com/DefangLabs/secret-detector v0.0.0-20250811234530-d4b4214cd679/go.mod h1:blbwPQh4DTlCZEfk1BLU4oMIhLda2U+A840Uag9DsZw=+github.com/DmitriyVTitov/size v1.5.0 h1:/PzqxYrOyOUX1BXj6J9OuVRVGe+66VL4D9FlUaW515g=+github.com/DmitriyVTitov/size v1.5.0/go.mod h1:le6rNI4CoLQV1b9gzp1+3d7hMAD/uu2QcJ+aYbNgiU0=github.com/Masterminds/semver/v3 v3.5.0 h1:kQceYJfbupGfZOKZQg0kou0DgAKhzDg2NZPAwZ/2OOE=github.com/Masterminds/semver/v3 v3.5.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=@@ -243,6 +245,7 @@ github.com/gofrs/flock v0.13.0 h1:95JolYOvGMqeH31+FC7D2+uULf6mG61mEZ/A8dRYMzw=github.com/gofrs/flock v0.13.0/go.mod h1:jxeyy9R1auM5S6JYDBhDt+E2TCo7DkratH4Pgi8P+Z0=github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=@@ -429,6 +432,10 @@ github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGgithub.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=+github.com/samber/go-singleflightx v0.3.2 h1:jXbUU0fvis8Fdv4HGONboX5WdEZcYLoBEcKiE+ITCyQ=+github.com/samber/go-singleflightx v0.3.2/go.mod h1:X2BR+oheHIYc73PvxRMlcASg6KYYTQyUYpdVU7t/ux4=+github.com/samber/hot v0.13.0 h1:4/OyD5xNfhmdHqyKWHHSisiytp93gA3knkWZLAvld2w=+github.com/samber/hot v0.13.0/go.mod h1:NB9v5U4NfDx7jmlrP+zHuqCuLUsywgAtCH7XOAkOxAg=github.com/samber/lo v1.53.0 h1:t975lj2py4kJPQ6haz1QMgtId2gtmfktACxIXArw3HM=github.com/samber/lo v1.53.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0=github.com/samber/mo v1.17.0 h1:EbeLc7nxIdpalstxQQakLOcXxULuMRqo7PJPtY18bQg=@@ -539,12 +546,12 @@ go.getarcane.app/streams v0.3.1 h1:Exs9a9G3paM9PnB6DQc8YvIKNbfaUTB7q271SD30zL8=go.getarcane.app/streams v0.3.1/go.mod h1:LHMKblQvsL1nqKh/Y+KgQbwFSMI2I7bs9u8ZwZqzjnQ=go.getarcane.app/sys/atomic v0.1.0 h1:0HhUeGXYdKAmMW24O+OaqcjDZx6twAuYPBu9T91zKsk=go.getarcane.app/sys/atomic v0.1.0/go.mod h1:QPb5eUXYKYG5acp9jJBAZ/PTbHbByDAQG6eDNAsZZ2w=-go.getarcane.app/sys/cgroup v0.1.0 h1:SCAbuU+rZ/EjMU8kkVxmXZsMchiZp9eFdMQFnbU+asA=-go.getarcane.app/sys/cgroup v0.1.0/go.mod h1:Paj4QOazrTXO/Ivhmvt1E/RjPJFTdKkxRgRDk4qBCUI=+go.getarcane.app/sys/cgroup v0.1.1 h1:c39W8FDqMXlKOZrpH+itaY+t8oC0tva0+6ztTrKvVIg=+go.getarcane.app/sys/cgroup v0.1.1/go.mod h1:2dUDhWV8qe9LRnLIqa5VQDhdWbTQ04EepttdIAe9dcM=go.getarcane.app/sys/crypto v0.1.0 h1:HDQ2CKHkm+wZe5xb/qR7MzW5fKi0Wq8Jcyr7qDVgRWg=go.getarcane.app/sys/crypto v0.1.0/go.mod h1:YtoRB0TENwfdNl0ZUTWkeas/8rT7NhCbI8ENsZzCCdU=-go.getarcane.app/updater v0.6.0 h1:dwnCjQdYMCB7xuCmODs/FhT28BCOUT5Uxmn1XydHv2Q=-go.getarcane.app/updater v0.6.0/go.mod h1:8f0/0pi7J0yFqgwFTywiwk/NoUN/g6AfmprOuAUrI20=+go.getarcane.app/updater v0.6.1 h1:kcRYGwLV+lbkpz6zCdDKM7PgvHnsKBAcyURNmAO4fI4=+go.getarcane.app/updater v0.6.1/go.mod h1:AVEBD3dbm+p8FOkkXGH7yDe2bHMadkYmLo5e9ajHnzI=go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=diff --git a/backend/internal/common/errors.go b/backend/internal/common/errors.goindex 1f751fa4e..b969eb120 100644--- a/backend/internal/common/errors.go+++ b/backend/internal/common/errors.go@@ -1991,18 +1991,6 @@ func (e *DefaultTransportTypeError) Error() string {return "http.DefaultTransport is not *http.Transport"}-// CacheInvalidatedDuringFetchError restarts a cache lookup when invalidation-// makes an in-flight fetch ineligible to publish its result.-type CacheInvalidatedDuringFetchError struct{}--func (e *CacheInvalidatedDuringFetchError) Error() string {- return "cache invalidated during fetch"-}--func IsCacheInvalidatedDuringFetchError(err error) bool {- return isErrorTypeInternal[*CacheInvalidatedDuringFetchError](err)-}-// ManagerCALockTypeError is returned when a cached manager CA lock value is not// the expected *sync.Mutex.type ManagerCALockTypeError struct{}@@ -2019,14 +2007,6 @@ func (e *ECRTokenResultTypeError) Error() string {return "unexpected ECR token result type"}-// OidcProviderCacheTypeError is returned when a cached OIDC provider value is-// not the expected *oidc.Provider.-type OidcProviderCacheTypeError struct{}--func (e *OidcProviderCacheTypeError) Error() string {- return "unexpected provider type from cache"-}-type FederatedCredentialInvalidRequestError struct{}func (e *FederatedCredentialInvalidRequestError) Error() string {diff --git a/backend/internal/services/auth_service.go b/backend/internal/services/auth_service.goindex f24a6d941..0dd97dbdc 100644--- a/backend/internal/services/auth_service.go+++ b/backend/internal/services/auth_service.go@@ -13,11 +13,11 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/common""github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/internal/models"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/jwtclaims""github.com/getarcaneapp/arcane/types/v2/auth""github.com/golang-jwt/jwt/v5""github.com/google/uuid"+ "github.com/samber/hot")var (@@ -82,7 +82,7 @@ type AuthService struct {// deployments, RevokeSession / ChangePassword / InvalidateUserTokenCache// only purge the local instance; peers continue to accept the token until// their own TTL expires. The TTL is kept short to bound this window.- tokenCache *cache.TTL[verifiedTokenEntry]+ tokenCache *hot.HotCache[string, verifiedTokenEntry]}func NewAuthService(userService *UserService, settingsService *SettingsService, eventService *EventService, sessionService *SessionService, roleService *RoleService, jwtSecret string, cfg *config.Config) *AuthService {@@ -98,7 +98,10 @@ func NewAuthService(userService *UserService, settingsService *SettingsService,jwtSecret: jwtclaims.CheckOrGenerateJwtSecret(jwtSecret, requireExplicitSecret),refreshExpiry: cfg.JWTRefreshExpiry,config: cfg,- tokenCache: cache.NewTTL[verifiedTokenEntry](15 * time.Second),+ tokenCache: hot.NewHotCache[string, verifiedTokenEntry](hot.LRU, 4096).+ WithTTL(15 * time.Second).+ WithJanitor().+ Build(),}}@@ -728,7 +731,7 @@ func (s *AuthService) VerifyToken(ctx context.Context, accessToken string) (*mod}tokenHash := hashTokenInternal(accessToken)- if cached, ok := s.tokenCache.Get(tokenHash).Get(); ok {+ if cached, ok, _ := s.tokenCache.Get(tokenHash); ok {return new(cached.User), cached.SessionID, nil}@@ -754,7 +757,7 @@ func (s *AuthService) VerifyToken(ctx context.Context, accessToken string) (*modreturn nil, "", err}- s.tokenCache.Put(tokenHash, verifiedTokenEntry{User: *dbUser, SessionID: session.ID})+ s.tokenCache.Set(tokenHash, verifiedTokenEntry{User: *dbUser, SessionID: session.ID})return dbUser, session.ID, nil}@@ -790,9 +793,14 @@ func (s *AuthService) ChangePassword(ctx context.Context, userID, currentPassworif _, err = s.userService.UpdateUser(ctx, user); err != nil {return err}- s.tokenCache.DeleteFunc(func(_ string, e verifiedTokenEntry) bool {- return e.User.ID == userID && e.SessionID != currentSessionID+ keys := make([]string, 0)+ s.tokenCache.Range(func(key string, entry verifiedTokenEntry) bool {+ if entry.User.ID == userID && entry.SessionID != currentSessionID {+ keys = append(keys, key)+ }+ return true})+ s.tokenCache.DeleteMany(keys)return s.sessionService.RevokeAllUserSessionsExcept(ctx, userID, currentSessionID)}@@ -803,16 +811,28 @@ func (s *AuthService) InvalidateUserTokenCache(userID string) {if s.tokenCache == nil || strings.TrimSpace(userID) == "" {return}- s.tokenCache.DeleteFunc(func(_ string, e verifiedTokenEntry) bool {- return e.User.ID == userID+ keys := make([]string, 0)+ s.tokenCache.Range(func(key string, entry verifiedTokenEntry) bool {+ if entry.User.ID == userID {+ keys = append(keys, key)+ }+ return true})+ s.tokenCache.DeleteMany(keys)}func (s *AuthService) RevokeSession(ctx context.Context, sessionID string) error {if s.sessionService == nil {return nil}- s.tokenCache.DeleteFunc(func(_ string, e verifiedTokenEntry) bool { return e.SessionID == sessionID })+ keys := make([]string, 0)+ s.tokenCache.Range(func(key string, entry verifiedTokenEntry) bool {+ if entry.SessionID == sessionID {+ keys = append(keys, key)+ }+ return true+ })+ s.tokenCache.DeleteMany(keys)return s.sessionService.RevokeSession(ctx, sessionID)}@@ -822,9 +842,14 @@ func (s *AuthService) LogoutAllOtherSessions(ctx context.Context, userID, currenif s.sessionService == nil {return nil}- s.tokenCache.DeleteFunc(func(_ string, e verifiedTokenEntry) bool {- return e.User.ID == userID && e.SessionID != currentSessionID+ keys := make([]string, 0)+ s.tokenCache.Range(func(key string, entry verifiedTokenEntry) bool {+ if entry.User.ID == userID && entry.SessionID != currentSessionID {+ keys = append(keys, key)+ }+ return true})+ s.tokenCache.DeleteMany(keys)return s.sessionService.RevokeAllUserSessionsExcept(ctx, userID, currentSessionID)}diff --git a/backend/internal/services/auth_service_test.go b/backend/internal/services/auth_service_test.goindex 6cd612188..d7918ab6e 100644--- a/backend/internal/services/auth_service_test.go+++ b/backend/internal/services/auth_service_test.go@@ -15,9 +15,9 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/internal/database""github.com/getarcaneapp/arcane/backend/v2/internal/models"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache""github.com/getarcaneapp/arcane/types/v2/auth""github.com/golang-jwt/jwt/v5"+ "github.com/samber/hot")func setupAuthServiceTestDB(t *testing.T) *database.DB {@@ -48,14 +48,20 @@ func newTestAuthService(secret string) *AuthService {jwtSecret: b,refreshExpiry: 24 * time.Hour,config: &config.Config{},- tokenCache: cache.NewTTL[verifiedTokenEntry](15 * time.Second),+ tokenCache: hot.NewHotCache[string, verifiedTokenEntry](hot.LRU, 4096).+ WithTTL(15 * time.Second).+ WithJanitor().+ Build(),}}return &AuthService{jwtSecret: []byte(secret),refreshExpiry: 24 * time.Hour,config: &config.Config{},- tokenCache: cache.NewTTL[verifiedTokenEntry](15 * time.Second),+ tokenCache: hot.NewHotCache[string, verifiedTokenEntry](hot.LRU, 4096).+ WithTTL(15 * time.Second).+ WithJanitor().+ Build(),}}diff --git a/backend/internal/services/container_registry_service.go b/backend/internal/services/container_registry_service.goindex 2e465466c..dc200b985 100644--- a/backend/internal/services/container_registry_service.go+++ b/backend/internal/services/container_registry_service.go@@ -8,10 +8,10 @@ import ("log/slog""net/http""strings"- "sync""time""github.com/cenkalti/backoff/v5"+ "github.com/samber/hot""github.com/samber/mo""golang.org/x/sync/singleflight"@@ -19,9 +19,9 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/database""github.com/getarcaneapp/arcane/backend/v2/internal/models"utilsregistry "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/registryauth"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts""github.com/getarcaneapp/arcane/backend/v2/pkg/pagination""github.com/getarcaneapp/arcane/backend/v2/pkg/utils"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/validation""github.com/getarcaneapp/arcane/types/v2/containerregistry"dockerregistry "github.com/moby/moby/api/types/registry"@@ -77,8 +77,7 @@ func (f rateLimitRoundTripFuncInternal) RoundTrip(req *http.Request) (*http.Resptype ContainerRegistryService struct {db *database.DBdockerClient registryDaemonGetter- cache map[string]*cache.Cache[string] // imageRef -> digest cache- cacheMu sync.RWMutex+ cache *hot.HotCache[string, string]ecrRefreshGroup singleflight.GroupdistributionHTTPClient *http.ClientkvService *KVService@@ -87,13 +86,32 @@ type ContainerRegistryService struct {// NewContainerRegistryService creates a registry service. kvService may be nil// in tests that do not need pull tracking or rate-limit caching.func NewContainerRegistryService(db *database.DB, dockerClient registryDaemonGetter, kvService *KVService) *ContainerRegistryService {- return &ContainerRegistryService{+ service := &ContainerRegistryService{db: db,dockerClient: dockerClient,distributionHTTPClient: updaterregistry.NewRegistryHTTPClient(),- cache: make(map[string]*cache.Cache[string]),kvService: kvService,}+ backgroundLoader := func(imageRefs []string) (map[string]string, error) {+ ctx, cancel := context.WithTimeout(context.Background(), timeouts.DefaultRegistry)+ defer cancel()+ digests := make(map[string]string, len(imageRefs))+ for _, imageRef := range imageRefs {+ result, err := service.inspectImageDigestInternal(ctx, imageRef, nil)+ if err != nil {+ return nil, err+ }+ digests[imageRef] = result.Digest+ }+ return digests, nil+ }+ service.cache = hot.NewHotCache[string, string](hot.LRU, 4096).+ WithTTL(registryCacheTTL).+ WithRevalidation(registryCacheTTL, backgroundLoader).+ WithRevalidationErrorPolicy(hot.KeepOnError).+ WithJanitor().+ Build()+ return service}func (s *ContainerRegistryService) GetAllRegistries(ctx context.Context) ([]models.ContainerRegistry, error) {@@ -752,37 +770,22 @@ func (s *ContainerRegistryService) GetImageDigest(ctx context.Context, imageRefreturn "", err}- // Build a cache key from the full image reference- cacheKey := normalizedRef-- // Get or create a cache for this specific image reference- s.cacheMu.RLock()- imageCache, exists := s.cache[cacheKey]- s.cacheMu.RUnlock()-- if !exists {- s.cacheMu.Lock()- if imageCache, exists = s.cache[cacheKey]; !exists {- imageCache = cache.New[string](registryCacheTTL)- s.cache[cacheKey] = imageCache- }- s.cacheMu.Unlock()- }+ digest, found, err := s.cache.GetWithLoaders(normalizedRef, func(_ []string) (map[string]string, error) {+ loadCtx, cancel := context.WithTimeout(ctx, timeouts.DefaultRegistry)+ defer cancel()- digest, err := imageCache.GetOrFetch(ctx, func(ctx context.Context) (string, error) {- // Pass the original imageRef; inspectImageDigestInternal normalizes internally.- result, fetchErr := s.inspectImageDigestInternal(ctx, imageRef, nil)- if fetchErr != nil {- return "", fetchErr+ result, loadErr := s.inspectImageDigestInternal(loadCtx, normalizedRef, nil)+ if loadErr != nil {+ return nil, loadErr}- return result.Digest, nil+ return map[string]string{normalizedRef: result.Digest}, nil})-- var staleErr *cache.StaleError- if err != nil && !errors.As(err, &staleErr) {+ if err != nil {return "", err}-+ if !found {+ return "", errors.New("registry digest cache loader returned no digest")+ }return digest, nil}diff --git a/backend/internal/services/container_registry_service_test.go b/backend/internal/services/container_registry_service_test.goindex a210b4976..97a05df0a 100644--- a/backend/internal/services/container_registry_service_test.go+++ b/backend/internal/services/container_registry_service_test.go@@ -9,6 +9,7 @@ import ("net/url""strings""testing"+ "time""github.com/getarcaneapp/arcane/backend/v2/internal/models""github.com/getarcaneapp/arcane/types/v2/containerregistry"@@ -661,6 +662,45 @@ func TestContainerRegistryService_InspectImageDigest_AnonymousSuccess(t *testingassert.Equal(t, "registry.example.com:5443", result.AuthRegistry)}+func TestContainerRegistryService_GetImageDigest_HonorsCallerCancellation(t *testing.T) {+ started := make(chan struct{}, 1)+ svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {+ return &fakeRegistryDaemonClient{+ distributionInspectFn: func(ctx context.Context, _ string, _ client.DistributionInspectOptions) (client.DistributionInspectResult, error) {+ select {+ case started <- struct{}{}:+ default:+ }+ <-ctx.Done()+ return client.DistributionInspectResult{}, ctx.Err()+ },+ }, nil+ }, nil)+ t.Cleanup(svc.cache.StopJanitor)++ ctx, cancel := context.WithCancel(context.Background())+ defer cancel()+ result := make(chan error, 1)+ go func() {+ _, err := svc.GetImageDigest(ctx, "registry.example.com/team/app:latest")+ result <- err+ }()++ select {+ case <-started:+ case <-time.After(time.Second):+ t.Fatal("registry lookup did not start")+ }+ cancel()++ select {+ case err := <-result:+ require.ErrorIs(t, err, context.Canceled)+ case <-time.After(time.Second):+ t.Fatal("registry lookup did not honor caller cancellation")+ }+}+func TestContainerRegistryService_InspectImageDigest_UsesStoredDockerHubCredentialsOnFirstAttempt(t *testing.T) {_, db := setupImageServiceAuthTest(t)createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.goindex 94a4d9ce5..e893fdf70 100644--- a/backend/internal/services/container_service.go+++ b/backend/internal/services/container_service.go@@ -9,7 +9,6 @@ import ("io""log/slog""maps"- "slices""strings""sync""time"@@ -19,7 +18,6 @@ import ("github.com/moby/moby/api/types/events""github.com/moby/moby/api/types/network""github.com/moby/moby/client"- "golang.org/x/sync/singleflight""github.com/getarcaneapp/arcane/backend/v2/internal/common""github.com/getarcaneapp/arcane/backend/v2/internal/database"@@ -29,11 +27,11 @@ import ("github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts""github.com/getarcaneapp/arcane/backend/v2/pkg/pagination""github.com/getarcaneapp/arcane/backend/v2/pkg/projects"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/iconcatalog"containertypes "github.com/getarcaneapp/arcane/types/v2/container""github.com/getarcaneapp/arcane/types/v2/containerregistry"imagetypes "github.com/getarcaneapp/arcane/types/v2/image"+ "github.com/samber/hot""go.getarcane.app/streams/bus"containerstats "go.getarcane.app/streams/stats""go.getarcane.app/sys/cgroup"@@ -48,9 +46,8 @@ type ContainerService struct {settingsService *SettingsServiceprojectService *ProjectServicestatsHistory containerstats.Store- updateInfoCache *cache.KeyedCache[string, *imagetypes.UpdateInfo]- updateInfoSF singleflight.Group- iconMetaCache *cache.TTL[projects.ArcaneComposeMetadata]+ updateInfoCache *hot.HotCache[string, *imagetypes.UpdateInfo]+ iconMetaCache *hot.HotCache[string, projects.ArcaneComposeMetadata]}const (@@ -74,8 +71,11 @@ func NewContainerService(ctx context.Context, db *database.DB, eventService *EveimageService: imageService,settingsService: settingsService,projectService: projectService,- updateInfoCache: cache.NewKeyed[string, *imagetypes.UpdateInfo](),- iconMetaCache: cache.NewTTL[projects.ArcaneComposeMetadata](containerIconMetadataTTL),+ updateInfoCache: hot.NewHotCache[string, *imagetypes.UpdateInfo](hot.LRU, 4096).Build(),+ iconMetaCache: hot.NewHotCache[string, projects.ArcaneComposeMetadata](hot.LRU, 1024).+ WithTTL(containerIconMetadataTTL).+ WithJanitor().+ Build(),}svc.subscribeUpdateInfoCacheInvalidationInternal(ctx)return svc@@ -96,7 +96,7 @@ func (s *ContainerService) subscribeUpdateInfoCacheInvalidationInternal(ctx contif !ok {return}- s.updateInfoCache.InvalidateAll()+ s.updateInfoCache.Purge()}}}()@@ -1185,43 +1185,27 @@ func (s *ContainerService) getUpdateInfoMap(ctx context.Context, imageIDs []strireturn updateInfoMap}- updateInfoMap := make(map[string]*imagetypes.UpdateInfo, len(imageIDs))- var uncachedIDs []string- for _, imageID := range imageIDs {- info, ok := s.updateInfoCache.Get(imageID).Get()- if !ok {- uncachedIDs = append(uncachedIDs, imageID)- continue+ infos, _, err := s.updateInfoCache.GetManyWithLoaders(imageIDs, func(missingIDs []string) (map[string]*imagetypes.UpdateInfo, error) {+ loaded, loadErr := s.imageService.GetUpdateInfoByImageIDs(ctx, missingIDs)+ if loadErr != nil {+ return nil, loadErr}- if info != nil {- updateInfoMap[imageID] = info+ for _, imageID := range missingIDs {+ if _, ok := loaded[imageID]; !ok {+ loaded[imageID] = nil+ }}+ return loaded, nil+ })+ if err != nil {+ slog.WarnContext(ctx, "Failed to fetch image update info for container images", "imageIDs", len(imageIDs), "error", err)+ infos, _ = s.updateInfoCache.PeekMany(imageIDs)}- if len(uncachedIDs) > 0 {- // Singleflight keyed by the uncached set so concurrent list requests- // that miss on the same images share one batch query.- slices.Sort(uncachedIDs)- res, err, _ := s.updateInfoSF.Do(strings.Join(uncachedIDs, ","), func() (any, error) {- infos, fetchErr := s.imageService.GetUpdateInfoByImageIDs(ctx, uncachedIDs)- if fetchErr != nil {- return nil, fetchErr- }- for _, imageID := range uncachedIDs {- // Cache nil results too so absent rows don't refetch until invalidation.- s.updateInfoCache.Set(imageID, infos[imageID])- }- return infos, nil- })- if err != nil {- slog.WarnContext(ctx, "Failed to fetch image update info for container images", "imageIDs", len(uncachedIDs), "error", err)- return updateInfoMap- }- infos, _ := res.(map[string]*imagetypes.UpdateInfo)- for _, imageID := range uncachedIDs {- if info := infos[imageID]; info != nil {- updateInfoMap[imageID] = info- }+ updateInfoMap := make(map[string]*imagetypes.UpdateInfo, len(infos))+ for imageID, info := range infos {+ if info != nil {+ updateInfoMap[imageID] = info}}return updateInfoMap@@ -1299,7 +1283,7 @@ func (s *ContainerService) getCachedProjectIconMetadataInternal(ctx context.Cont}if s.iconMetaCache != nil {- if meta, ok := s.iconMetaCache.Get(projectName).Get(); ok {+ if meta, ok, _ := s.iconMetaCache.Get(projectName); ok {if metadataByProject != nil {metadataByProject[projectName] = meta}@@ -1313,7 +1297,7 @@ func (s *ContainerService) getCachedProjectIconMetadataInternal(ctx context.Contmeta = s.projectService.getProjectMetadataForProject(ctx, *proj)}if s.iconMetaCache != nil {- s.iconMetaCache.Put(projectName, meta)+ s.iconMetaCache.Set(projectName, meta)}if metadataByProject != nil {metadataByProject[projectName] = metadiff --git a/backend/internal/services/docker_client_service.go b/backend/internal/services/docker_client_service.goindex c8bae0e8a..ea4f9a912 100644--- a/backend/internal/services/docker_client_service.go+++ b/backend/internal/services/docker_client_service.go@@ -16,7 +16,6 @@ import (docker "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache"dashboardtypes "github.com/getarcaneapp/arcane/types/v2/dashboard""github.com/moby/moby/api/types/container""github.com/moby/moby/api/types/events"@@ -30,43 +29,26 @@ import ()const dockerClientNegotiationTimeout = 5 * time.Second-const dockerListCacheTTL = 0const dockerImageStateResyncActionInternal events.Action = "arcane-resync"type DockerClientService struct {- db *database.DB- config *config.Config- settingsService *SettingsService- client *client.Client- clientVersion string- clientLastProbe time.Time- mu sync.Mutex- containerCache *cache.Cache[[]container.Summary]- imageCache *cache.Cache[[]image.Summary]- networkCache *cache.Cache[[]network.Summary]- volumeCache *cache.Cache[*client.VolumeListResult]- eventBus *bus.DockerEventBus- subscriptionCtx context.Context- subscriptionStop context.CancelFunc- subscriptionUnsub []func()+ db *database.DB+ config *config.Config+ settingsService *SettingsService+ client *client.Client+ clientVersion string+ clientLastProbe time.Time+ mu sync.Mutex+ eventBus *bus.DockerEventBus}-func NewDockerClientService(ctx context.Context, db *database.DB, cfg *config.Config, settingsService *SettingsService) *DockerClientService {- subscriptionCtx, subscriptionStop := context.WithCancel(ctx)- svc := &DockerClientService{- db: db,- config: cfg,- settingsService: settingsService,- containerCache: cache.New[[]container.Summary](dockerListCacheTTL),- imageCache: cache.New[[]image.Summary](dockerListCacheTTL),- networkCache: cache.New[[]network.Summary](dockerListCacheTTL),- volumeCache: cache.New[*client.VolumeListResult](dockerListCacheTTL),- eventBus: bus.NewDockerEventBus(),- subscriptionCtx: subscriptionCtx,- subscriptionStop: subscriptionStop,- }- svc.subscribeListCacheInvalidationInternal(subscriptionCtx)- return svc+func NewDockerClientService(_ context.Context, db *database.DB, cfg *config.Config, settingsService *SettingsService) *DockerClientService {+ return &DockerClientService{+ db: db,+ config: cfg,+ settingsService: settingsService,+ eventBus: bus.NewDockerEventBus(),+ }}func newDockerClientInternal(ctx context.Context, host string) (*client.Client, error) {@@ -208,18 +190,9 @@ func (s *DockerClientService) DockerHost() string {return s.config.DockerHost}-// Close stops Docker event subscriptions owned by this service and closes the-// cached Docker client.+// Close closes the cached Docker client.func (s *DockerClientService) Close() {s.mu.Lock()- if s.subscriptionStop != nil {- s.subscriptionStop()- s.subscriptionStop = nil- }- for _, unsubscribe := range s.subscriptionUnsub {- unsubscribe()- }- s.subscriptionUnsub = niloldClient := s.clients.client = nils.mu.Unlock()@@ -236,82 +209,6 @@ func (s *DockerClientService) EventBus() *bus.DockerEventBus {return s.eventBus}-func (s *DockerClientService) ensureListCachesInternal() {- s.mu.Lock()- if s.containerCache == nil {- s.containerCache = cache.New[[]container.Summary](dockerListCacheTTL)- }- if s.imageCache == nil {- s.imageCache = cache.New[[]image.Summary](dockerListCacheTTL)- }- if s.networkCache == nil {- s.networkCache = cache.New[[]network.Summary](dockerListCacheTTL)- }- if s.volumeCache == nil {- s.volumeCache = cache.New[*client.VolumeListResult](dockerListCacheTTL)- }- s.mu.Unlock()-}--func (s *DockerClientService) subscribeListCacheInvalidationInternal(ctx context.Context) {- s.subscribeCacheInvalidationInternal(ctx, events.ContainerEventType, func() {- if s.containerCache != nil {- s.containerCache.Invalidate()- }- })- s.subscribeCacheInvalidationInternal(ctx, events.ImageEventType, func() {- if s.imageCache != nil {- s.imageCache.Invalidate()- }- })- s.subscribeCacheInvalidationInternal(ctx, events.NetworkEventType, func() {- if s.networkCache != nil {- s.networkCache.Invalidate()- }- })- s.subscribeCacheInvalidationInternal(ctx, events.VolumeEventType, func() {- if s.volumeCache != nil {- s.volumeCache.Invalidate()- }- })-}--func (s *DockerClientService) subscribeCacheInvalidationInternal(ctx context.Context, eventType events.Type, invalidate func()) {- ch, unsubscribe := s.EventBus().Subscribe(eventType, bus.WithSubscriberBuffer(16))- s.mu.Lock()- s.subscriptionUnsub = append(s.subscriptionUnsub, unsubscribe)- s.mu.Unlock()- go func() {- for {- select {- case <-ctx.Done():- return- case _, ok := <-ch:- if !ok {- return- }- invalidate()- }- }- }()-}--func (s *DockerClientService) invalidateListCachesInternal() {- s.ensureListCachesInternal()- if s.containerCache != nil {- s.containerCache.Invalidate()- }- if s.imageCache != nil {- s.imageCache.Invalidate()- }- if s.networkCache != nil {- s.networkCache.Invalidate()- }- if s.volumeCache != nil {- s.volumeCache.Invalidate()- }-}-func (s *DockerClientService) WatchEvents(ctx context.Context) {eventBackoff := backoff.NewExponentialBackOff()eventBackoff.InitialInterval = 500 * time.Millisecond@@ -327,7 +224,6 @@ func (s *DockerClientService) WatchEvents(ctx context.Context) {continue}- s.invalidateListCachesInternal()eventBackoff.Reset()result := dockerClient.Events(ctx, client.EventsListOptions{})s.publishImageStateResyncInternal()@@ -380,87 +276,71 @@ func sleepDockerEventBackoffInternal(ctx context.Context, eventBackoff *backoff.}func (s *DockerClientService) listContainersInternal(ctx context.Context) ([]container.Summary, error) {- s.ensureListCachesInternal()- containerCache := s.containerCache- return containerCache.GetOrFetch(ctx, func(ctx context.Context) ([]container.Summary, error) {- dockerClient, err := s.GetClient(ctx)- if err != nil {- return nil, fmt.Errorf("failed to connect to Docker: %w", err)- }+ dockerClient, err := s.GetClient(ctx)+ if err != nil {+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ }- settings := s.settingsService.GetSettingsConfig()- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)- defer cancel()+ settings := s.settingsService.GetSettingsConfig()+ apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)+ defer cancel()- containerList, err := dockerClient.ContainerList(apiCtx, client.ContainerListOptions{All: true})- if err != nil {- return nil, fmt.Errorf("failed to list Docker containers: %w", err)- }- return containerList.Items, nil- })+ containerList, err := dockerClient.ContainerList(apiCtx, client.ContainerListOptions{All: true})+ if err != nil {+ return nil, fmt.Errorf("failed to list Docker containers: %w", err)+ }+ return containerList.Items, nil}func (s *DockerClientService) listImagesInternal(ctx context.Context) ([]image.Summary, error) {- s.ensureListCachesInternal()- imageCache := s.imageCache- return imageCache.GetOrFetch(ctx, func(ctx context.Context) ([]image.Summary, error) {- dockerClient, err := s.GetClient(ctx)- if err != nil {- return nil, fmt.Errorf("failed to connect to Docker: %w", err)- }+ dockerClient, err := s.GetClient(ctx)+ if err != nil {+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ }- settings := s.settingsService.GetSettingsConfig()- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)- defer cancel()+ settings := s.settingsService.GetSettingsConfig()+ apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)+ defer cancel()- imageList, err := dockerClient.ImageList(apiCtx, client.ImageListOptions{All: true})- if err != nil {- return nil, fmt.Errorf("failed to list Docker images: %w", err)- }- return imageList.Items, nil- })+ imageList, err := dockerClient.ImageList(apiCtx, client.ImageListOptions{All: true})+ if err != nil {+ return nil, fmt.Errorf("failed to list Docker images: %w", err)+ }+ return imageList.Items, nil}func (s *DockerClientService) listNetworksInternal(ctx context.Context) ([]network.Summary, error) {- s.ensureListCachesInternal()- networkCache := s.networkCache- return networkCache.GetOrFetch(ctx, func(ctx context.Context) ([]network.Summary, error) {- dockerClient, err := s.GetClient(ctx)- if err != nil {- return nil, fmt.Errorf("failed to connect to Docker: %w", err)- }+ dockerClient, err := s.GetClient(ctx)+ if err != nil {+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ }- settings := s.settingsService.GetSettingsConfig()- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)- defer cancel()+ settings := s.settingsService.GetSettingsConfig()+ apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)+ defer cancel()- networkList, err := libarcane.NetworkListWithCompatibility(apiCtx, dockerClient, client.NetworkListOptions{})- if err != nil {- return nil, fmt.Errorf("failed to list Docker networks: %w", err)- }- return networkList.Items, nil- })+ networkList, err := libarcane.NetworkListWithCompatibility(apiCtx, dockerClient, client.NetworkListOptions{})+ if err != nil {+ return nil, fmt.Errorf("failed to list Docker networks: %w", err)+ }+ return networkList.Items, nil}func (s *DockerClientService) listVolumesInternal(ctx context.Context) (*client.VolumeListResult, error) {- s.ensureListCachesInternal()- volumeCache := s.volumeCache- return volumeCache.GetOrFetch(ctx, func(ctx context.Context) (*client.VolumeListResult, error) {- dockerClient, err := s.GetClient(ctx)- if err != nil {- return nil, fmt.Errorf("failed to connect to Docker: %w", err)- }+ dockerClient, err := s.GetClient(ctx)+ if err != nil {+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)+ }- settings := s.settingsService.GetSettingsConfig()- apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)- defer cancel()+ settings := s.settingsService.GetSettingsConfig()+ apiCtx, cancel := timeouts.WithTimeout(ctx, settings.DockerAPITimeout.AsInt(), timeouts.DefaultDockerAPI)+ defer cancel()- volResp, err := dockerClient.VolumeList(apiCtx, client.VolumeListOptions{})- if err != nil {- return nil, fmt.Errorf("failed to list Docker volumes: %w", err)- }- return &volResp, nil- })+ volResp, err := dockerClient.VolumeList(apiCtx, client.VolumeListOptions{})+ if err != nil {+ return nil, fmt.Errorf("failed to list Docker volumes: %w", err)+ }+ return &volResp, nil}func (s *DockerClientService) GetSnapshot(ctx context.Context, envID string) (*dashboardtypes.DockerSnapshot, error) {diff --git a/backend/internal/services/docker_client_service_test.go b/backend/internal/services/docker_client_service_test.goindex c7b6cf32f..e7ffb871e 100644--- a/backend/internal/services/docker_client_service_test.go+++ b/backend/internal/services/docker_client_service_test.go@@ -169,7 +169,7 @@ func TestDockerClientService_RefreshClientProbeFailureKeepsCachedClient(t *testiassert.False(t, svc.clientLastProbe.IsZero())}-func TestDockerClientService_PublishImageStateResyncNotifiesSubscribersAndInvalidatesCache(t *testing.T) {+func TestDockerClientService_PublishImageStateResyncNotifiesSubscribers(t *testing.T) {ctx, cancel := context.WithCancel(context.Background())t.Cleanup(cancel)svc := NewDockerClientService(ctx, nil, &config.Config{}, nil)@@ -178,14 +178,6 @@ func TestDockerClientService_PublishImageStateResyncNotifiesSubscribersAndInvalieventCh, unsubscribe := svc.EventBus().Subscribe(events.ImageEventType)t.Cleanup(unsubscribe)- fetches := 0- _, err := svc.imageCache.GetOrFetch(ctx, func(context.Context) ([]image.Summary, error) {- fetches++- return []image.Summary{{ID: "sha256:first"}}, nil- })- require.NoError(t, err)- require.Equal(t, 1, fetches)-svc.publishImageStateResyncInternal()select {@@ -195,14 +187,6 @@ func TestDockerClientService_PublishImageStateResyncNotifiesSubscribersAndInvalicase <-time.After(time.Second):t.Fatal("timed out waiting for image state resync event")}-- require.Eventually(t, func() bool {- _, fetchErr := svc.imageCache.GetOrFetch(ctx, func(context.Context) ([]image.Summary, error) {- fetches++- return []image.Summary{{ID: "sha256:second"}}, nil- })- return fetchErr == nil && fetches == 2- }, time.Second, 5*time.Millisecond)}func TestCountImageUsage_UsesContainerImageIDs(t *testing.T) {diff --git a/backend/internal/services/environment_service.go b/backend/internal/services/environment_service.goindex b1406b893..ee529d0eb 100644--- a/backend/internal/services/environment_service.go+++ b/backend/internal/services/environment_service.go@@ -29,6 +29,7 @@ import (schedulertypes "github.com/getarcaneapp/arcane/types/v2/scheduler""github.com/google/uuid""github.com/moby/moby/client"+ "github.com/samber/hot""go.getarcane.app/sys/crypto""gorm.io/gorm")@@ -42,7 +43,7 @@ type EnvironmentService struct {apiKeyService *ApiKeyServiceremoteClient *remenv.ClienttokenCacheMu sync.RWMutex- tokenCache map[string]edgeTokenCacheEntry+ tokenCache *hot.HotCache[string, string]tokenByEnvID map[string]stringremoteEnvMu sync.RWMutexremoteEnvs map[string]models.Environment@@ -72,11 +73,6 @@ const (environmentHealthCheckTimeout = 90 * time.Second)-type edgeTokenCacheEntry struct {- EnvironmentID string- ExpiresAt time.Time-}-const edgeTokenCacheTTL = time.Minutevar (@@ -99,7 +95,10 @@ func NewEnvironmentService(db *database.DB, httpClient *http.Client, dockerServiEnsureAvailableFunc: ensureRemoteEnvironmentTunnelAvailableInternal,DoFunc: doRemoteEnvironmentTunnelRequestInternal,}),- tokenCache: make(map[string]edgeTokenCacheEntry),+ tokenCache: hot.NewHotCache[string, string](hot.LRU, 1024).+ WithTTL(edgeTokenCacheTTL).+ WithJanitor().+ Build(),tokenByEnvID: make(map[string]string),remoteEnvs: make(map[string]models.Environment),}@@ -280,7 +279,7 @@ func (s *EnvironmentService) ResolveEdgeEnvironmentByToken(ctx context.Context,return "", errors.New("agent token required")}- if envID, ok := s.getCachedEnvironmentIDForTokenInternal(token, time.Now()).Get(); ok {+ if envID, ok := s.getCachedEnvironmentIDForTokenInternal(token).Get(); ok {return envID, nil}@@ -297,7 +296,7 @@ func (s *EnvironmentService) ResolveEdgeEnvironmentByToken(ctx context.Context,return "", fmt.Errorf("failed to resolve edge environment by token: %w", err)}- s.cacheEnvironmentTokenInternal(env.ID, token, time.Now())+ s.cacheEnvironmentTokenInternal(env.ID, token)return env.ID, nil}@@ -337,62 +336,40 @@ func (s *EnvironmentService) logEdgeTokenResolveMissInternal(ctx context.Contextslog.DebugContext(ctx, "Edge agent token did not match any environment", args...)}-func (s *EnvironmentService) getCachedEnvironmentIDForTokenInternal(token string, now time.Time) mo.Option[string] {- if s == nil || token == "" {+func (s *EnvironmentService) getCachedEnvironmentIDForTokenInternal(token string) mo.Option[string] {+ if s == nil || s.tokenCache == nil || token == "" {return mo.None[string]()}- if now.IsZero() {- now = time.Now()- }-- s.tokenCacheMu.RLock()- entry, ok := s.tokenCache[token]- s.tokenCacheMu.RUnlock()- if !ok {- return mo.None[string]()- }- if entry.ExpiresAt.After(now) {- return mo.Some(entry.EnvironmentID)- }-- s.tokenCacheMu.Lock()- defer s.tokenCacheMu.Unlock()- entry, ok = s.tokenCache[token]- if !ok {- return mo.None[string]()+ staleEnvironmentID, wasCached := s.tokenCache.Peek(token)+ environmentID, ok, _ := s.tokenCache.Get(token)+ if ok {+ return mo.Some(environmentID)}- if !entry.ExpiresAt.After(now) {- delete(s.tokenCache, token)- if currentToken, ok := s.tokenByEnvID[entry.EnvironmentID]; ok && currentToken == token {- delete(s.tokenByEnvID, entry.EnvironmentID)+ if wasCached {+ s.tokenCacheMu.Lock()+ if currentToken, indexed := s.tokenByEnvID[staleEnvironmentID]; indexed && currentToken == token {+ delete(s.tokenByEnvID, staleEnvironmentID)}- return mo.None[string]()+ s.tokenCacheMu.Unlock()}-- return mo.Some(entry.EnvironmentID)+ return mo.None[string]()}-func (s *EnvironmentService) cacheEnvironmentTokenInternal(envID string, token string, now time.Time) {- if s == nil || envID == "" || token == "" {+func (s *EnvironmentService) cacheEnvironmentTokenInternal(envID string, token string) {+ if s == nil || s.tokenCache == nil || envID == "" || token == "" {return}- if now.IsZero() {- now = time.Now()- }s.tokenCacheMu.Lock()defer s.tokenCacheMu.Unlock()if previousToken, ok := s.tokenByEnvID[envID]; ok && previousToken != token {- delete(s.tokenCache, previousToken)+ s.tokenCache.Delete(previousToken)}s.tokenByEnvID[envID] = token- s.tokenCache[token] = edgeTokenCacheEntry{- EnvironmentID: envID,- ExpiresAt: now.Add(edgeTokenCacheTTL),- }+ s.tokenCache.Set(token, envID)}func (s *EnvironmentService) invalidateEnvironmentTokenInternal(envID string) {@@ -405,7 +382,9 @@ func (s *EnvironmentService) invalidateEnvironmentTokenInternal(envID string) {if token, ok := s.tokenByEnvID[envID]; ok {delete(s.tokenByEnvID, envID)- delete(s.tokenCache, token)+ if s.tokenCache != nil {+ s.tokenCache.Delete(token)+ }}}@@ -419,7 +398,7 @@ func (s *EnvironmentService) syncEnvironmentTokenCacheInternal(envID string, tokresolvedToken := strings.TrimSpace(token)if resolvedToken != "" {- s.cacheEnvironmentTokenInternal(envID, resolvedToken, time.Now())+ s.cacheEnvironmentTokenInternal(envID, resolvedToken)}}diff --git a/backend/internal/services/environment_service_test.go b/backend/internal/services/environment_service_test.goindex 876f8f425..8cd740aa0 100644--- a/backend/internal/services/environment_service_test.go+++ b/backend/internal/services/environment_service_test.go@@ -542,12 +542,12 @@ func TestEnvironmentService_UpdateEnvironment_ClearingAccessTokenInvalidatesCach_, err = svc.UpdateEnvironment(ctx, "edge-auth-clear", map[string]any{"access_token": nil}, nil, nil)require.NoError(t, err)- cachedEnvID, ok := svc.getCachedEnvironmentIDForTokenInternal(oldToken, time.Now()).Get()+ cachedEnvID, ok := svc.getCachedEnvironmentIDForTokenInternal(oldToken).Get()require.False(t, ok)require.Empty(t, cachedEnvID)+ _, tokenStillCached := svc.tokenCache.Peek(oldToken)svc.tokenCacheMu.RLock()- _, tokenStillCached := svc.tokenCache[oldToken]_, reverseIndexStillCached := svc.tokenByEnvID["edge-auth-clear"]svc.tokenCacheMu.RUnlock()@@ -561,16 +561,18 @@ func TestEnvironmentService_UpdateEnvironment_ClearingAccessTokenInvalidatesCachfunc TestEnvironmentService_getCachedEnvironmentIDForTokenInternal_ExpiresAndCleansReverseIndex(t *testing.T) {svc := NewEnvironmentService(nil, nil, nil, nil, nil, nil)- now := time.Now()-- svc.cacheEnvironmentTokenInternal("env-expired", "expired-token", now.Add(-2*edgeTokenCacheTTL))+ svc.tokenCacheMu.Lock()+ svc.tokenByEnvID["env-expired"] = "expired-token"+ svc.tokenCache.SetWithTTL("expired-token", "env-expired", time.Nanosecond)+ time.Sleep(time.Millisecond)+ svc.tokenCacheMu.Unlock()- envID, ok := svc.getCachedEnvironmentIDForTokenInternal("expired-token", now).Get()+ envID, ok := svc.getCachedEnvironmentIDForTokenInternal("expired-token").Get()require.False(t, ok)require.Empty(t, envID)+ _, tokenStillCached := svc.tokenCache.Peek("expired-token")svc.tokenCacheMu.RLock()- _, tokenStillCached := svc.tokenCache["expired-token"]_, reverseIndexStillCached := svc.tokenByEnvID["env-expired"]svc.tokenCacheMu.RUnlock()diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.goindex 0a818a37b..8003915c2 100644--- a/backend/internal/services/image_service.go+++ b/backend/internal/services/image_service.go@@ -8,7 +8,6 @@ import ("log/slog""net/http""strings"- "sync""time"ref "github.com/distribution/reference"@@ -24,6 +23,7 @@ import ("github.com/moby/moby/api/types/container""github.com/moby/moby/api/types/image""github.com/moby/moby/client"+ "github.com/samber/hot""github.com/samber/mo""golang.org/x/sync/errgroup""gorm.io/gorm"@@ -37,15 +37,7 @@ type ImageService struct {vulnerabilityService *VulnerabilityServiceeventService *EventService- projectIDCache projectIDNameCache-}--// projectIDNameCache memoizes the (project name → project ID) map used to enrich image-// usage data with the owning project. The TTL bounds staleness; see projectIDCacheTTL.-type projectIDNameCache struct {- mu sync.RWMutex- byName map[string]string- expires time.Time+ projectIDCache *hot.HotCache[struct{}, map[string]string]}func NewImageService(db *database.DB, dockerService *DockerClientService, registryService *ContainerRegistryService, imageUpdateService *ImageUpdateService, vulnerabilityService *VulnerabilityService, eventService *EventService) *ImageService {@@ -56,6 +48,9 @@ func NewImageService(db *database.DB, dockerService *DockerClientService, registimageUpdateService: imageUpdateService,vulnerabilityService: vulnerabilityService,eventService: eventService,+ projectIDCache: hot.NewHotCache[struct{}, map[string]string](hot.LRU, 1).+ WithTTL(projectIDCacheTTL).+ Build(),}}@@ -880,35 +875,34 @@ func (s *ImageService) GetTotalImageSize(ctx context.Context) (int64, error) {const projectIDCacheTTL = 5 * time.Secondfunc (s *ImageService) loadProjectIDByNameCachedInternal(ctx context.Context) map[string]string {- s.projectIDCache.mu.RLock()- if cached := s.projectIDCache.byName; cached != nil && time.Now().Before(s.projectIDCache.expires) {- s.projectIDCache.mu.RUnlock()- return cached- }- s.projectIDCache.mu.RUnlock()-- s.projectIDCache.mu.Lock()- defer s.projectIDCache.mu.Unlock()- if cached := s.projectIDCache.byName; cached != nil && time.Now().Before(s.projectIDCache.expires) {- return cached- }+ if s.projectIDCache == nil {+ s.projectIDCache = hot.NewHotCache[struct{}, map[string]string](hot.LRU, 1).+ WithTTL(projectIDCacheTTL).+ Build()+ }+ stale, staleFound := s.projectIDCache.Peek(struct{}{})+ byName, found, err := s.projectIDCache.GetWithLoaders(struct{}{}, func(_ []struct{}) (map[struct{}]map[string]string, error) {+ var projects []models.Project+ if err := s.db.WithContext(ctx).Select("id", "name").Find(&projects).Error; err != nil {+ return nil, err+ }- var projects []models.Project- if err := s.db.WithContext(ctx).Select("id", "name").Find(&projects).Error; err != nil {+ loaded := make(map[string]string, len(projects))+ for _, project := range projects {+ loaded[project.Name] = project.ID+ }+ return map[struct{}]map[string]string{{}: loaded}, nil+ })+ if err != nil {slog.WarnContext(ctx, "failed to load project ID map", "error", err)- // Return last cached value if any; otherwise an empty map (don't store, so we retry next call).- if s.projectIDCache.byName != nil {- return s.projectIDCache.byName+ if staleFound {+ return stale}return map[string]string{}}-- byName := make(map[string]string, len(projects))- for _, p := range projects {- byName[p.Name] = p.ID+ if !found {+ return map[string]string{}}- s.projectIDCache.byName = byName- s.projectIDCache.expires = time.Now().Add(projectIDCacheTTL)return byName}diff --git a/backend/internal/services/oidc_service.go b/backend/internal/services/oidc_service.goindex 7ae081ea7..69f86bd5e 100644--- a/backend/internal/services/oidc_service.go+++ b/backend/internal/services/oidc_service.go@@ -16,11 +16,10 @@ import ("time""github.com/coreos/go-oidc/v3/oidc"+ "github.com/samber/hot""golang.org/x/net/http2""golang.org/x/oauth2"- "golang.org/x/sync/singleflight"- "github.com/getarcaneapp/arcane/backend/v2/internal/common""github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/internal/models""github.com/getarcaneapp/arcane/backend/v2/pkg/utils"@@ -34,11 +33,13 @@ type OidcService struct {config *config.ConfighttpClient *http.ClientinsecureHttpClient *http.Client- providerCache *oidc.ProviderproviderMutex sync.RWMutex- cachedIssuer string- cachedSkipTls bool- sfGroup singleflight.Group+ providerCache *hot.HotCache[oidcProviderKey, *oidc.Provider]+}++type oidcProviderKey struct {+ issuer string+ skipTLS bool}type OidcState struct {@@ -59,12 +60,14 @@ func NewOidcService(authService *AuthService, settingsService *SettingsService,oidcClient := *httpClientoidcClient.Timeout = 0- return &OidcService{+ service := &OidcService{authService: authService,settingsService: settingsService,config: cfg,httpClient: &oidcClient,}+ service.providerCache = hot.NewHotCache[oidcProviderKey, *oidc.Provider](hot.LRU, 4).Build()+ return service}func (s *OidcService) getEffectiveConfigInternal(ctx context.Context) (*models.OidcConfig, error) {@@ -273,63 +276,31 @@ func (s *OidcService) GetOidcRedirectURL(origin string) string {}func (s *OidcService) getOrDiscoverProviderInternal(ctx context.Context, cfg *models.OidcConfig) (*oidc.Provider, error) {- issuer := cfg.IssuerURL- skipTls := cfg.SkipTlsVerify-- s.providerMutex.RLock()- if s.providerCache != nil && s.cachedIssuer == issuer && s.cachedSkipTls == skipTls {- provider := s.providerCache- s.providerMutex.RUnlock()- return provider, nil- }- s.providerMutex.RUnlock()-- // Use singleflight to prevent thundering herd. Include skipTls in key to handle toggling.- sfKey := fmt.Sprintf("%s|%v", issuer, skipTls)- v, err, _ := s.sfGroup.Do(sfKey, func() (any, error) {- // Double check inside the lock/singleflight- s.providerMutex.RLock()- if s.providerCache != nil && s.cachedIssuer == issuer && s.cachedSkipTls == skipTls {- provider := s.providerCache- s.providerMutex.RUnlock()- return provider, nil- }- s.providerMutex.RUnlock()-- // Create a context with a longer timeout for discovery- // We use context.WithoutCancel(ctx) as the parent because we don't want the discovery- // to be cancelled if the incoming request context is cancelled (e.g. client disconnect).- // This ensures the provider is cached for subsequent requests.- discoveryCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)- defer cancel()-- // Use the custom HTTP client with the new context- providerCtx := oidc.ClientContext(discoveryCtx, s.getHttpClientInternal(skipTls))- provider, discoveredIssuer, err := s.discoverProviderInternal(providerCtx, issuer)- if err != nil {- slog.ErrorContext(ctx, "getOrDiscoverProviderInternal: discovery failed", "issuer", issuer, "skipTls", skipTls, "error", err)- return nil, fmt.Errorf("failed to discover provider at %s: %w", issuer, err)+ if s.providerCache == nil {+ s.providerCache = hot.NewHotCache[oidcProviderKey, *oidc.Provider](hot.LRU, 4).Build()+ }+ key := oidcProviderKey{issuer: cfg.IssuerURL, skipTLS: cfg.SkipTlsVerify}+ provider, found, err := s.providerCache.GetWithLoaders(key, func(keys []oidcProviderKey) (map[oidcProviderKey]*oidc.Provider, error) {+ providers := make(map[oidcProviderKey]*oidc.Provider, len(keys))+ for _, providerKey := range keys {+ discoveryCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)+ providerCtx := oidc.ClientContext(discoveryCtx, s.getHttpClientInternal(providerKey.skipTLS))+ discovered, discoveredIssuer, discoverErr := s.discoverProviderInternal(providerCtx, providerKey.issuer)+ cancel()+ if discoverErr != nil {+ slog.ErrorContext(ctx, "getOrDiscoverProviderInternal: discovery failed", "issuer", providerKey.issuer, "skipTls", providerKey.skipTLS, "error", discoverErr)+ return nil, fmt.Errorf("failed to discover provider at %s: %w", providerKey.issuer, discoverErr)+ }+ providers[providerKey] = discovered+ slog.DebugContext(ctx, "getOrDiscoverProviderInternal: provider cached", "issuer", providerKey.issuer, "effectiveIssuer", discoveredIssuer, "skipTls", providerKey.skipTLS)}-- s.providerMutex.Lock()- s.providerCache = provider- // Cache based on the configured issuer to avoid repeated discovery on- // trailing-slash-only mismatches.- s.cachedIssuer = issuer- s.cachedSkipTls = skipTls- s.providerMutex.Unlock()-- slog.DebugContext(ctx, "getOrDiscoverProviderInternal: provider cached", "issuer", issuer, "effectiveIssuer", discoveredIssuer, "skipTls", skipTls)- return provider, nil+ return providers, nil})-if err != nil {return nil, err}-- provider, ok := v.(*oidc.Provider)- if !ok {- return nil, &common.OidcProviderCacheTypeError{}+ if !found {+ return nil, errors.New("OIDC provider cache loader returned no provider")}return provider, nil}diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.goindex 08233b69d..10a76480f 100644--- a/backend/internal/services/project_service.go+++ b/backend/internal/services/project_service.go@@ -37,13 +37,13 @@ import ("github.com/getarcaneapp/arcane/backend/v2/pkg/pagination""github.com/getarcaneapp/arcane/backend/v2/pkg/projects""github.com/getarcaneapp/arcane/backend/v2/pkg/utils"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/iconcatalog""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/mapper""github.com/getarcaneapp/arcane/types/v2""github.com/getarcaneapp/arcane/types/v2/containerregistry"imagetypes "github.com/getarcaneapp/arcane/types/v2/image""github.com/getarcaneapp/arcane/types/v2/project"+ "github.com/samber/hot"buildtypes "go.getarcane.app/builds/types""go.getarcane.app/sys/cgroup"libupdater "go.getarcane.app/updater/pkg/labels"@@ -64,7 +64,7 @@ type ProjectService struct {composeNameCacheMu sync.RWMutexcomposeNameToProjID map[string]string- composeCache *cache.KeyedCache[string, composeCacheEntry]+ composeCache *hot.HotCache[string, composeCacheEntry]}type registryCredentialsProviderInternal func(context.Context) ([]containerregistry.Credential, error)@@ -87,7 +87,7 @@ func NewProjectService(db *database.DB, settingsService *SettingsService, eventSlifecycleService: lifecycleService,containerRegistryService: containerRegistryService,config: cfg,- composeCache: cache.NewKeyed[string, composeCacheEntry](),+ composeCache: hot.NewHotCache[string, composeCacheEntry](hot.LRU, 2048).Build(),}}@@ -508,13 +508,20 @@ func (s *ProjectService) getCachedComposeProjectInternal(ctx context.Context, prreturn nil, errors.New("project is nil")}if s.composeCache == nil {- s.composeCache = cache.NewKeyed[string, composeCacheEntry]()+ s.composeCache = hot.NewHotCache[string, composeCacheEntry](hot.LRU, 2048).Build()}- entry, err := s.composeCache.GetOrFetch(ctx, proj.ID, validComposeCacheEntryInternal, func(ctx context.Context) (composeCacheEntry, error) {+ if cached, ok := s.composeCache.Peek(proj.ID); ok {+ if validComposeCacheEntryInternal(cached) {+ return cached.project, nil+ }+ s.composeCache.Delete(proj.ID)+ }++ entry, found, err := s.composeCache.GetWithLoaders(proj.ID, func(_ []string) (map[string]composeCacheEntry, error) {composeProject, composePath, err := s.loadComposeProjectForProjectInternal(ctx, proj, cfg)if err != nil {- return composeCacheEntry{}, err+ return nil, err}entry := composeCacheEntry{@@ -525,7 +532,7 @@ func (s *ProjectService) getCachedComposeProjectInternal(ctx context.Context, prif info, statErr := os.Stat(composePath); statErr == nil {entry.composeMtime = info.ModTime()} else {- return composeCacheEntry{}, fmt.Errorf("stat compose file: %w", statErr)+ return nil, fmt.Errorf("stat compose file: %w", statErr)}if composeProject != nil {for _, composeFile := range composeProject.ComposeFiles {@@ -534,17 +541,20 @@ func (s *ProjectService) getCachedComposeProjectInternal(ctx context.Context, pr}info, statErr := os.Stat(composeFile)if statErr != nil {- return composeCacheEntry{}, fmt.Errorf("stat compose include %s: %w", composeFile, statErr)+ return nil, fmt.Errorf("stat compose include %s: %w", composeFile, statErr)}entry.includeMtimes[composeFile] = info.ModTime()}}- return entry, nil+ return map[string]composeCacheEntry{proj.ID: entry}, nil})if err != nil {return nil, err}+ if !found {+ return nil, errors.New("compose cache loader returned no project")+ }return entry.project, nil}@@ -571,7 +581,7 @@ func (s *ProjectService) invalidateComposeCacheInternal(projectID string) {if s.composeCache == nil || strings.TrimSpace(projectID) == "" {return}- s.composeCache.Invalidate(projectID)+ s.composeCache.Delete(projectID)}func (s *ProjectService) refreshProjectImageRefsInternal(ctx context.Context, proj *models.Project) {diff --git a/backend/internal/services/role_service.go b/backend/internal/services/role_service.goindex e0629c8e6..68eea32fc 100644--- a/backend/internal/services/role_service.go+++ b/backend/internal/services/role_service.go@@ -17,9 +17,9 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/models""github.com/getarcaneapp/arcane/backend/v2/pkg/authz""github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/dbutil"roletypes "github.com/getarcaneapp/arcane/types/v2/role"+ "github.com/samber/hot""github.com/samber/mo")@@ -34,15 +34,21 @@ const permissionCacheTTL = 60 * time.Second// short TTL to keep the hot path off the database.type RoleService struct {db *database.DB- userCache *cache.TTL[*authz.PermissionSet]- apiKeyCache *cache.TTL[*authz.PermissionSet]+ userCache *hot.HotCache[string, *authz.PermissionSet]+ apiKeyCache *hot.HotCache[string, *authz.PermissionSet]}func NewRoleService(db *database.DB) *RoleService {return &RoleService{- db: db,- userCache: cache.NewTTL[*authz.PermissionSet](permissionCacheTTL),- apiKeyCache: cache.NewTTL[*authz.PermissionSet](permissionCacheTTL),+ db: db,+ userCache: hot.NewHotCache[string, *authz.PermissionSet](hot.LRU, 2048).+ WithTTL(permissionCacheTTL).+ WithJanitor().+ Build(),+ apiKeyCache: hot.NewHotCache[string, *authz.PermissionSet](hot.LRU, 2048).+ WithTTL(permissionCacheTTL).+ WithJanitor().+ Build(),}}@@ -605,14 +611,14 @@ func (s *RoleService) ResolvePermissions(ctx context.Context, user *models.User)if user == nil {return authz.NewPermissionSet(), nil}- if ps, ok := s.userCache.Get(user.ID).Get(); ok {+ if ps, ok, _ := s.userCache.Get(user.ID); ok {return ps, nil}ps, err := s.resolveUserPermissionsInternal(ctx, s.db.WithContext(ctx), user.ID)if err != nil {return nil, err}- s.userCache.Put(user.ID, ps)+ s.userCache.Set(user.ID, ps)return ps, nil}@@ -663,7 +669,7 @@ func decodePermissionsJSONInternal(raw string) ([]string, error) {// ResolveApiKeyPermissions returns the PermissionSet for an API key. Caches// per-key. Falls back to an empty set (deny-all) if the key has no perms.func (s *RoleService) ResolveApiKeyPermissions(ctx context.Context, apiKeyID string) (*authz.PermissionSet, error) {- if ps, ok := s.apiKeyCache.Get(apiKeyID).Get(); ok {+ if ps, ok, _ := s.apiKeyCache.Get(apiKeyID); ok {return ps, nil}var perms []models.ApiKeyPermission@@ -678,7 +684,7 @@ func (s *RoleService) ResolveApiKeyPermissions(ctx context.Context, apiKeyID strps.AddEnv(*p.EnvironmentID, p.Permission)}}- s.apiKeyCache.Put(apiKeyID, ps)+ s.apiKeyCache.Set(apiKeyID, ps)return ps, nil}diff --git a/backend/internal/services/swarm_service.go b/backend/internal/services/swarm_service.goindex 4077df7c8..67fd43e53 100644--- a/backend/internal/services/swarm_service.go+++ b/backend/internal/services/swarm_service.go@@ -32,6 +32,7 @@ import ("github.com/moby/moby/api/types/swarm""github.com/moby/moby/api/types/system"dockerclient "github.com/moby/moby/client"+ "github.com/samber/hot""go.getarcane.app/sys/atomic""golang.org/x/sync/errgroup")@@ -50,8 +51,7 @@ type SwarmService struct {kvService *KVServiceregistryService *ContainerRegistryServiceenvironmentService *EnvironmentService- identityCacheMu sync.RWMutex- identityCache map[string]swarmNodeIdentityCacheEntry+ identityCache *hot.HotCache[string, SwarmNodeIdentity]}func NewSwarmService(@@ -67,7 +67,10 @@ func NewSwarmService(kvService: kvService,registryService: registryService,environmentService: environmentService,- identityCache: make(map[string]swarmNodeIdentityCacheEntry),+ identityCache: hot.NewHotCache[string, SwarmNodeIdentity](hot.LRU, 512).+ WithTTL(swarmNodeIdentityCacheTTL).+ WithJanitor().+ Build(),}}@@ -86,11 +89,6 @@ type swarmNodeAgentRuntime struct {identity *SwarmNodeIdentity}-type swarmNodeIdentityCacheEntry struct {- identity SwarmNodeIdentity- expiresAt time.Time-}-type swarmNodeAgentCoverage struct {runtimeByEnvID map[string]swarmNodeAgentRuntimeboundEnvsByNodeID map[string][]models.Environment@@ -830,7 +828,7 @@ func (s *SwarmService) resolveSwarmNodeAgentRuntimeInternal(ctx context.Context,runtime.lastPollAt = pollState.LastPollAt}- if identity := s.cachedSwarmNodeIdentityInternal(env.ID, time.Now()); identity != nil {+ if identity := s.cachedSwarmNodeIdentityInternal(env.ID); identity != nil {runtime.connected = trueruntime.identity = identityreturn runtime@@ -844,31 +842,31 @@ func (s *SwarmService) resolveSwarmNodeAgentRuntimeInternal(ctx context.Context,runtime.connected = trueruntime.identity = identity- s.cacheSwarmNodeIdentityInternal(env.ID, *identity, time.Now())+ s.cacheSwarmNodeIdentityInternal(env.ID, *identity)return runtime}-func (s *SwarmService) cachedSwarmNodeIdentityInternal(environmentID string, now time.Time) *SwarmNodeIdentity {- s.identityCacheMu.RLock()- entry, ok := s.identityCache[environmentID]- s.identityCacheMu.RUnlock()- if !ok || !now.Before(entry.expiresAt) {+func (s *SwarmService) cachedSwarmNodeIdentityInternal(environmentID string) *SwarmNodeIdentity {+ if s.identityCache == nil {+ return nil+ }+ identity, ok, _ := s.identityCache.Get(environmentID)+ if !ok {return nil}- identity := entry.identityreturn &identity}-func (s *SwarmService) cacheSwarmNodeIdentityInternal(environmentID string, identity SwarmNodeIdentity, now time.Time) {- s.identityCacheMu.Lock()- s.identityCache[environmentID] = swarmNodeIdentityCacheEntry{identity: identity, expiresAt: now.Add(swarmNodeIdentityCacheTTL)}- s.identityCacheMu.Unlock()+func (s *SwarmService) cacheSwarmNodeIdentityInternal(environmentID string, identity SwarmNodeIdentity) {+ if s.identityCache != nil {+ s.identityCache.Set(environmentID, identity)+ }}func (s *SwarmService) invalidateSwarmNodeIdentityInternal(environmentID string) {- s.identityCacheMu.Lock()- delete(s.identityCache, environmentID)- s.identityCacheMu.Unlock()+ if s.identityCache != nil {+ s.identityCache.Delete(environmentID)+ }}// JoinEnvironments joins visible remote environments to the selected swarmdiff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.goindex a3888a3f0..ead53bf8b 100644--- a/backend/internal/services/template_service.go+++ b/backend/internal/services/template_service.go@@ -28,17 +28,12 @@ import ("github.com/getarcaneapp/arcane/types/v2/env"tmpl "github.com/getarcaneapp/arcane/types/v2/template""github.com/google/uuid"+ "github.com/samber/hot""github.com/samber/mo""golang.org/x/sync/errgroup""gorm.io/gorm")-type remoteCache struct {- templates []models.ComposeTemplate- lastFetch time.Time- refreshing bool-}-type registryFetchMeta struct {LastModified stringTemplates []models.ComposeTemplate@@ -51,8 +46,7 @@ type TemplateService struct {lookupIP httputils.LookupIPFuncsettingsService *SettingsService- remoteMu sync.RWMutex- remoteCache remoteCache+ remoteCache *hot.HotCache[struct{}, []models.ComposeTemplate]registryMu sync.RWMutexregistryFetchMeta map[string]*registryFetchMeta@@ -73,6 +67,8 @@ const (const remoteIDPrefix = "remote"+var errNoRemoteTemplates = errors.New("remote template registries returned no templates")+func makeRemoteID(registryID, slug string) string {return fmt.Sprintf("%s:%s:%s", remoteIDPrefix, registryID, slug)}@@ -87,11 +83,29 @@ func NewTemplateService(ctx context.Context, db *database.DB, httpClient *http.ChttpClient: httpClient,lookupIP: httputils.DefaultLookupIP,settingsService: settingsService,- remoteCache: remoteCache{},registryFetchMeta: make(map[string]*registryFetchMeta),registryErrors: make(map[string]string),}service.safeHTTPClient = service.newSafeHTTPClientInternal()+ revalidationCtx := context.WithoutCancel(ctx)+ loader := func(_ []struct{}) (map[struct{}][]models.ComposeTemplate, error) {+ loadCtx, cancel := context.WithTimeout(revalidationCtx, 2*time.Minute)+ defer cancel()+ templates, err := service.loadRemoteTemplates(loadCtx)+ if err != nil {+ return nil, err+ }+ if len(templates) == 0 {+ return nil, errNoRemoteTemplates+ }+ return map[struct{}][]models.ComposeTemplate{{}: templates}, nil+ }+ service.remoteCache = hot.NewHotCache[struct{}, []models.ComposeTemplate](hot.LRU, 1).+ WithTTL(remoteCacheDuration).+ WithLoaders(loader).+ WithRevalidation(24*time.Hour, loader).+ WithRevalidationErrorPolicy(hot.KeepOnError).+ Build()if err := projects.EnsureDefaultTemplates(ctx, service.configuredTemplatesDirSettingInternal(ctx)); err != nil {slog.WarnContext(ctx, "failed to ensure default templates", "error", err)@@ -117,50 +131,18 @@ func (s *TemplateService) getTemplatesDirectoryInternal(ctx context.Context) (streturn projects.GetTemplatesDirectory(ctx, strings.TrimSpace(s.configuredTemplatesDirSettingInternal(ctx)))}-func (s *TemplateService) ensureRemoteTemplatesLoaded(ctx context.Context) error {- s.remoteMu.Lock()-- // If cache has entries and is fresh, return.- // An empty slice is treated as "no cache" so callers always trigger a blocking- // refresh — otherwise a single failed/empty refresh would poison the cache.- if len(s.remoteCache.templates) > 0 && time.Since(s.remoteCache.lastFetch) < remoteCacheDuration {- s.remoteMu.Unlock()- return nil+func (s *TemplateService) ensureRemoteTemplatesLoaded(_ context.Context) error {+ if s.remoteCache == nil {+ return errors.New("remote template cache is not initialized")}-- // If we have a non-empty stale cache and nobody is refreshing, trigger background refresh.- if len(s.remoteCache.templates) > 0 {- if !s.remoteCache.refreshing {- s.remoteCache.refreshing = true- s.remoteMu.Unlock()-- // Use a closure that accepts context to satisfy linter, though we create a new one- go func(parentCtx context.Context) {- // Create a detached context with timeout for background fetch- // We use context.WithoutCancel(parentCtx) to ensure it outlives the request- bgCtx, cancel := context.WithTimeout(context.WithoutCancel(parentCtx), 2*time.Minute)- defer cancel()-- defer func() {- s.remoteMu.Lock()- s.remoteCache.refreshing = false- s.remoteMu.Unlock()- }()-- if err := s.refreshRemoteTemplates(bgCtx); err != nil {- slog.WarnContext(bgCtx, "background remote template refresh failed", "error", err)- }- }(ctx)- return nil // Return stale cache- }- s.remoteMu.Unlock()- return nil // Return stale cache while someone else refreshes+ templates, found, err := s.remoteCache.Get(struct{}{})+ if err != nil {+ return fmt.Errorf("failed to load remote templates: %w", err)}-- s.remoteMu.Unlock()-- // No cache at all, must block- return s.refreshRemoteTemplates(ctx)+ if !found || len(templates) == 0 {+ return errNoRemoteTemplates+ }+ return nil}func (s *TemplateService) refreshRemoteTemplates(ctx context.Context) error {@@ -169,10 +151,13 @@ func (s *TemplateService) refreshRemoteTemplates(ctx context.Context) error {return fmt.Errorf("failed to load remote templates: %w", err)}- s.remoteMu.Lock()- defer s.remoteMu.Unlock()- s.remoteCache.templates = templates- s.remoteCache.lastFetch = time.Now()+ if len(templates) == 0 {+ return errNoRemoteTemplates+ }+ if s.remoteCache == nil {+ return errors.New("remote template cache is not initialized")+ }+ s.remoteCache.Set(struct{}{}, templates)return nil}@@ -267,7 +252,7 @@ func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.Creturn nil, fmt.Errorf("failed to query local template: %w", err)}- if err := s.ensureRemoteTemplatesLoaded(ctx); err != nil {+ if err := s.ensureRemoteTemplatesLoaded(ctx); err != nil && !errors.Is(err, errNoRemoteTemplates) {return nil, fmt.Errorf("template %q lookup failed: registry refresh error: %w", id, err)}@@ -280,7 +265,7 @@ func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.C// silently returned empty.if strings.HasPrefix(id, remoteIDPrefix+":") {slog.InfoContext(ctx, "remote template not in cache, forcing registry refresh", "templateID", id, "cacheSize", s.remoteCacheSizeInternal())- if refreshErr := s.refreshRemoteTemplates(ctx); refreshErr != nil {+ if refreshErr := s.refreshRemoteTemplates(ctx); refreshErr != nil && !errors.Is(refreshErr, errNoRemoteTemplates) {return nil, fmt.Errorf("template %q not found and registry refresh failed: %w", id, refreshErr)}if found := s.lookupRemoteFromCacheInternal(id); found != nil {@@ -295,11 +280,16 @@ func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.C}func (s *TemplateService) lookupRemoteFromCacheInternal(id string) *models.ComposeTemplate {- s.remoteMu.RLock()- defer s.remoteMu.RUnlock()- for i := range s.remoteCache.templates {- if s.remoteCache.templates[i].ID == id {- cloned := cloneRemoteTemplates(s.remoteCache.templates[i : i+1])+ if s.remoteCache == nil {+ return nil+ }+ templates, found := s.remoteCache.Peek(struct{}{})+ if !found {+ return nil+ }+ for i := range templates {+ if templates[i].ID == id {+ cloned := cloneRemoteTemplates(templates[i : i+1])return &cloned[0]}}@@ -307,9 +297,11 @@ func (s *TemplateService) lookupRemoteFromCacheInternal(id string) *models.Compo}func (s *TemplateService) remoteCacheSizeInternal() int {- s.remoteMu.RLock()- defer s.remoteMu.RUnlock()- return len(s.remoteCache.templates)+ if s.remoteCache == nil {+ return 0+ }+ templates, _ := s.remoteCache.Peek(struct{}{})+ return len(templates)}func (s *TemplateService) CreateTemplate(ctx context.Context, template *models.ComposeTemplate) error {@@ -984,9 +976,9 @@ func cloneRegistry(registry *models.TemplateRegistry) *models.TemplateRegistry {}func (s *TemplateService) invalidateRemoteCache() {- s.remoteMu.Lock()- s.remoteCache = remoteCache{}- s.remoteMu.Unlock()+ if s.remoteCache != nil {+ s.remoteCache.Purge()+ }s.registryMu.Lock()s.registryFetchMeta = make(map[string]*registryFetchMeta)@@ -1284,9 +1276,8 @@ func (s *TemplateService) getMergedTemplates(ctx context.Context) ([]models.Compif err := s.ensureRemoteTemplatesLoaded(ctx); err != nil {slog.WarnContext(ctx, "failed to load remote templates", "error", err)} else {- s.remoteMu.RLock()- copied := cloneRemoteTemplates(s.remoteCache.templates)- s.remoteMu.RUnlock()+ remoteTemplates, _ := s.remoteCache.Peek(struct{}{})+ copied := cloneRemoteTemplates(remoteTemplates)if len(copied) > 0 {templates = append(templates, copied...)diff --git a/backend/internal/services/template_service_test.go b/backend/internal/services/template_service_test.goindex 6afe40012..dd09e8377 100644--- a/backend/internal/services/template_service_test.go+++ b/backend/internal/services/template_service_test.go@@ -324,24 +324,17 @@ func TestGetAllTemplatesPaginated_FiltersByType(t *testing.T) {}require.NoError(t, db.WithContext(context.Background()).Create(&localTemplates).Error)- service := &TemplateService{- db: db,- httpClient: http.DefaultClient,- registryFetchMeta: make(map[string]*registryFetchMeta),- remoteCache: remoteCache{- templates: []models.ComposeTemplate{- {- BaseModel: models.BaseModel{ID: "remote-one", CreatedAt: now, UpdatedAt: &now},- Name: "Remote One",- Description: "Remote template",- Content: "services: {}",- IsRemote: true,- RegistryID: mo.EmptyableToOption(strings.TrimSpace("registry-one")).ToPointer(),- },- },- lastFetch: now,+ service := NewTemplateService(context.Background(), db, http.DefaultClient, nil)+ service.remoteCache.Set(struct{}{}, []models.ComposeTemplate{+ {+ BaseModel: models.BaseModel{ID: "remote-one", CreatedAt: now, UpdatedAt: &now},+ Name: "Remote One",+ Description: "Remote template",+ Content: "services: {}",+ IsRemote: true,+ RegistryID: mo.EmptyableToOption(strings.TrimSpace("registry-one")).ToPointer(),},- }+ })tests := []struct {name string@@ -468,13 +461,9 @@ func TestGetTemplate_ForceRefreshesRemoteCacheOnMiss(t *testing.T) {require.NoError(t, settingsSvc.UpdateSetting(context.Background(), "templatesDirectory", filepath.Join(tempDir, "templates")))require.NoError(t, settingsSvc.UpdateSetting(context.Background(), "projectsDirectory", filepath.Join(tempDir, "projects")))- service := &TemplateService{- db: db,- httpClient: client,- lookupIP: lookupIP,- settingsService: settingsSvc,- registryFetchMeta: make(map[string]*registryFetchMeta),- }+ service := NewTemplateService(context.Background(), db, client, settingsSvc)+ service.lookupIP = lookupIP+ service.safeHTTPClient = service.newSafeHTTPClientInternal()// Cache starts empty; GetTemplate for a remote ID should force a refresh and find the template.got, err := service.GetTemplate(context.Background(), "remote:reg-1:affine")diff --git a/backend/internal/services/version_service.go b/backend/internal/services/version_service.goindex 15b10132a..b691f516a 100644--- a/backend/internal/services/version_service.go+++ b/backend/internal/services/version_service.go@@ -19,8 +19,8 @@ import ("github.com/getarcaneapp/arcane/backend/v2/buildables""github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache""github.com/getarcaneapp/arcane/types/v2/version"+ "github.com/samber/hot""go.getarcane.app/sys/cgroup"libupdater "go.getarcane.app/updater/pkg/labels")@@ -39,7 +39,7 @@ type latestRelease struct {type VersionService struct {httpClient *http.Client- cache *cache.Cache[latestRelease]+ cache *hot.HotCache[struct{}, latestRelease]disabled boolversion stringrevision string@@ -52,9 +52,8 @@ func NewVersionService(httpClient *http.Client, disabled bool, version string, rif httpClient == nil {httpClient = http.DefaultClient}- return &VersionService{+ service := &VersionService{httpClient: httpClient,- cache: cache.New[latestRelease](versionTTL),disabled: disabled,version: version,revision: revision,@@ -62,53 +61,68 @@ func NewVersionService(httpClient *http.Client, disabled bool, version string, rdockerService: dockerService,imageUpdateService: imageUpdateService,}-}--func (s *VersionService) getLatestReleaseInternal(ctx context.Context) (latestRelease, error) {- rel, err := s.cache.GetOrFetch(ctx, func(ctx context.Context) (latestRelease, error) {- reqCtx, cancel := context.WithTimeout(ctx, defaultRequestTimeout)+ loader := func(_ []struct{}) (map[struct{}]latestRelease, error) {+ ctx, cancel := context.WithTimeout(context.Background(), defaultRequestTimeout)defer cancel()-- req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, versionCheckURL, nil)+ release, err := service.fetchLatestReleaseInternal(ctx)if err != nil {- return latestRelease{}, fmt.Errorf("create GitHub request: %w", err)+ return nil, err}+ return map[struct{}]latestRelease{{}: release}, nil+ }+ service.cache = hot.NewHotCache[struct{}, latestRelease](hot.LRU, 1).+ WithTTL(versionTTL).+ WithLoaders(loader).+ WithRevalidation(24*time.Hour, loader).+ WithRevalidationErrorPolicy(hot.KeepOnError).+ Build()+ return service+}- resp, err := s.httpClient.Do(req)- if err != nil {- return latestRelease{}, fmt.Errorf("get latest release: %w", err)- }- defer func() { _ = resp.Body.Close() }()+func (s *VersionService) getLatestReleaseInternal(_ context.Context) (latestRelease, error) {+ release, found, err := s.cache.Get(struct{}{})+ if err != nil {+ return latestRelease{}, err+ }+ if !found {+ return latestRelease{}, errors.New("latest release cache loader returned no release")+ }+ return release, nil+}- if resp.StatusCode != http.StatusOK {- return latestRelease{}, fmt.Errorf("GitHub API returned status %d", resp.StatusCode)- }+func (s *VersionService) fetchLatestReleaseInternal(ctx context.Context) (latestRelease, error) {+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, versionCheckURL, nil)+ if err != nil {+ return latestRelease{}, fmt.Errorf("create GitHub request: %w", err)+ }- var payload struct {- TagName string `json:"tag_name"`- Body string `json:"body"`- PublishedAt string `json:"published_at"`- }- if err := json.UnmarshalRead(resp.Body, &payload); err != nil {- return latestRelease{}, fmt.Errorf("decode payload: %w", err)- }- if payload.TagName == "" {- return latestRelease{}, errors.New("GitHub API returned empty tag name")- }+ resp, err := s.httpClient.Do(req)+ if err != nil {+ return latestRelease{}, fmt.Errorf("get latest release: %w", err)+ }+ defer func() { _ = resp.Body.Close() }()- return latestRelease{- TagName: payload.TagName,- Body: payload.Body,- PublishedAt: payload.PublishedAt,- }, nil- })+ if resp.StatusCode != http.StatusOK {+ return latestRelease{}, fmt.Errorf("GitHub API returned status %d", resp.StatusCode)+ }- if staleErr, ok := errors.AsType[*cache.StaleError](err); ok {- slog.Warn("Failed to fetch latest release, returning stale cache", "error", staleErr.Err)- return rel, nil+ var payload struct {+ TagName string `json:"tag_name"`+ Body string `json:"body"`+ PublishedAt string `json:"published_at"`+ }+ if err := json.UnmarshalRead(resp.Body, &payload); err != nil {+ return latestRelease{}, fmt.Errorf("decode payload: %w", err)+ }+ if payload.TagName == "" {+ return latestRelease{}, errors.New("GitHub API returned empty tag name")}- return rel, err+ return latestRelease{+ TagName: payload.TagName,+ Body: payload.Body,+ PublishedAt: payload.PublishedAt,+ }, nil}func (s *VersionService) GetLatestVersion(ctx context.Context) (string, error) {@@ -184,11 +198,7 @@ func (s *VersionService) GetVersionInformation(ctx context.Context, currentVersilatest, err := s.GetLatestVersion(ctx)if err != nil {- if staleErr, ok := errors.AsType[*cache.StaleError](err); ok {- slog.Warn("Failed to refresh latest version; using stale cache", "error", staleErr.Err)- } else {- return check, err- }+ return check, err}if latest != "" {@@ -254,8 +264,7 @@ func (s *VersionService) GetAppVersionInfo(ctx context.Context) *version.Info {// For semver versions, check GitHub releasesif isSemver {rel, err := s.getLatestReleaseInternal(ctx)- var staleErr *cache.StaleError- if err == nil || errors.As(err, &staleErr) {+ if err == nil {if rel.TagName != "" {info.NewestVersion = rel.TagNamesemverUpdateAvailable = s.IsNewer(rel.TagName, ver)diff --git a/backend/pkg/dockerutil/volume_utils.go b/backend/pkg/dockerutil/volume_utils.goindex d7f7a43b2..5e38c4fd8 100644--- a/backend/pkg/dockerutil/volume_utils.go+++ b/backend/pkg/dockerutil/volume_utils.go@@ -5,39 +5,27 @@ import ("errors""fmt""log/slog"- "sync""time""github.com/moby/moby/api/types/container""github.com/moby/moby/api/types/mount""github.com/moby/moby/api/types/volume""github.com/moby/moby/client"+ "github.com/samber/hot""github.com/samber/mo")-var (- volumeUsageCacheMutex sync.RWMutex- volumeUsageCacheEntries = make(map[string]*volumeUsageCacheEntryInternal)- volumeUsageCacheGenerations = make(map[string]uint64)-)+var volumeUsageCache = hot.NewHotCache[string, []volume.Volume](hot.LRU, 16).+ WithTTL(volumeUsageCacheTTL).+ WithCopyOnRead(cloneVolumeUsageInternal).+ WithCopyOnWrite(cloneVolumeUsageInternal).+ Build()const (volumeUsageCacheTTL = 30 * time.SecondvolumeUsageRefreshFallbackTimeout = 30 * time.Second)-type volumeUsageCacheEntryInternal struct {- volumes []volume.Volume- refreshedAt time.Time- generation uint64- refresh *volumeUsageRefreshInternal-}--type volumeUsageRefreshInternal struct {- done chan struct{}- err error-}-// GetVolumeUsageData returns current volume usage data, sharing an in-flight// refresh with concurrent callers while allowing each caller to honor its own context.func GetVolumeUsageData(ctx context.Context, dockerClient *client.Client) ([]volume.Volume, error) {@@ -46,35 +34,50 @@ func GetVolumeUsageData(ctx context.Context, dockerClient *client.Client) ([]vol}key := volumeUsageCacheKeyInternal(dockerClient)- for {- cached, _, fresh := volumeUsageCacheSnapshotInternal(key)- if fresh {- slog.DebugContext(ctx, "returning cached volume usage data", "volume_count", len(cached), "docker_host", key)- return cached, nil- }+ stale, staleFound := volumeUsageCache.Peek(key)+ if cached, found, _ := volumeUsageCache.Get(key); found {+ slog.DebugContext(ctx, "returning cached volume usage data", "volume_count", len(cached), "docker_host", key)+ return cached, nil+ }- refresh := startVolumeUsageRefreshInternal(ctx, key, dockerClient)- select {- case <-ctx.Done():- if stale, staleFound, _ := volumeUsageCacheSnapshotInternal(key); staleFound {- slog.WarnContext(ctx, "volume usage refresh timed out; returning stale cache", "error", ctx.Err(), "volume_count", len(stale), "docker_host", key)- return stale, nil- }- return nil, ctx.Err()- case <-refresh.done:- updated, updatedFound, _ := volumeUsageCacheSnapshotInternal(key)- if updatedFound {- if refresh.err != nil {- slog.WarnContext(ctx, "volume usage refresh failed; returning stale cache", "error", refresh.err, "volume_count", len(updated), "docker_host", key)- }- return updated, nil+ type refreshResult struct {+ volumes []volume.Volume+ found bool+ err error+ }+ result := make(chan refreshResult, 1)+ refreshCtx, cancel := volumeUsageRefreshContextInternal(ctx)+ go func() {+ defer cancel()+ volumes, found, err := volumeUsageCache.GetWithLoaders(key, func(_ []string) (map[string][]volume.Volume, error) {+ loaded, loadErr := fetchVolumeUsageDataInternal(refreshCtx, dockerClient)+ if loadErr != nil {+ return nil, loadErr}- if refresh.err != nil {- return nil, refresh.err+ return map[string][]volume.Volume{key: loaded}, nil+ })+ result <- refreshResult{volumes: volumes, found: found, err: err}+ }()++ select {+ case <-ctx.Done():+ if staleFound {+ slog.WarnContext(ctx, "volume usage refresh timed out; returning stale cache", "error", ctx.Err(), "volume_count", len(stale), "docker_host", key)+ return stale, nil+ }+ return nil, ctx.Err()+ case refreshed := <-result:+ if refreshed.err != nil {+ if staleFound {+ slog.WarnContext(ctx, "volume usage refresh failed; returning stale cache", "error", refreshed.err, "volume_count", len(stale), "docker_host", key)+ return stale, nil}- // The cache was invalidated while the refresh was running. Retry against- // the new generation rather than publishing obsolete usage data.+ return nil, refreshed.err+ }+ if !refreshed.found {+ return nil, errors.New("volume usage cache loader returned no data")}+ return refreshed.volumes, nil}}@@ -86,23 +89,40 @@ func GetVolumeUsageDataStaleWhileRevalidate(ctx context.Context, dockerClient *c}key := volumeUsageCacheKeyInternal(dockerClient)- cached, found, fresh := volumeUsageCacheSnapshotInternal(key)+ cached, found := volumeUsageCache.Peek(key)+ if fresh, freshFound, _ := volumeUsageCache.Get(key); freshFound {+ slog.DebugContext(ctx, "volume usage cache lookup",+ "docker_host", key,+ "cache_state", "fresh",+ "volume_count", len(fresh),+ "refresh_requested", false,+ )+ return mo.Some(fresh)+ }cacheState := "miss"if found {cacheState = "stale"- if fresh {- cacheState = "fresh"- }}slog.DebugContext(ctx, "volume usage cache lookup","docker_host", key,"cache_state", cacheState,"volume_count", len(cached),- "refresh_requested", !fresh,+ "refresh_requested", true,)- if !fresh {- startVolumeUsageRefreshInternal(ctx, key, dockerClient)- }+ refreshCtx, cancel := volumeUsageRefreshContextInternal(ctx)+ go func() {+ defer cancel()+ _, _, err := volumeUsageCache.GetWithLoaders(key, func(_ []string) (map[string][]volume.Volume, error) {+ loaded, loadErr := fetchVolumeUsageDataInternal(refreshCtx, dockerClient)+ if loadErr != nil {+ return nil, loadErr+ }+ return map[string][]volume.Volume{key: loaded}, nil+ })+ if err != nil {+ slog.WarnContext(refreshCtx, "failed to refresh volume usage cache", "error", err, "docker_host", key)+ }+ }()if !found {return mo.None[[]volume.Volume]()}@@ -116,10 +136,7 @@ func InvalidateVolumeUsageCache(dockerClient *client.Client) {}key := volumeUsageCacheKeyInternal(dockerClient)- volumeUsageCacheMutex.Lock()- volumeUsageCacheGenerations[key]++- delete(volumeUsageCacheEntries, key)- volumeUsageCacheMutex.Unlock()+ volumeUsageCache.Delete(key)}func volumeUsageCacheKeyInternal(dockerClient *client.Client) string {@@ -130,66 +147,6 @@ func volumeUsageCacheKeyInternal(dockerClient *client.Client) string {return fmt.Sprintf("client:%p", dockerClient)}-func volumeUsageCacheSnapshotInternal(key string) ([]volume.Volume, bool, bool) {- volumeUsageCacheMutex.RLock()- entry := volumeUsageCacheEntries[key]- if entry == nil || entry.volumes == nil {- volumeUsageCacheMutex.RUnlock()- return nil, false, false- }- volumes := append([]volume.Volume(nil), entry.volumes...)- fresh := time.Since(entry.refreshedAt) < volumeUsageCacheTTL- volumeUsageCacheMutex.RUnlock()- return volumes, true, fresh-}--func startVolumeUsageRefreshInternal(ctx context.Context, key string, dockerClient *client.Client) *volumeUsageRefreshInternal {- volumeUsageCacheMutex.Lock()- generation := volumeUsageCacheGenerations[key]- entry := volumeUsageCacheEntries[key]- if entry == nil || entry.generation != generation {- entry = &volumeUsageCacheEntryInternal{generation: generation}- volumeUsageCacheEntries[key] = entry- }- if entry.refresh != nil {- refresh := entry.refresh- volumeUsageCacheMutex.Unlock()- return refresh- }-- refresh := &volumeUsageRefreshInternal{done: make(chan struct{})}- entry.refresh = refresh- volumeUsageCacheMutex.Unlock()-- refreshCtx, cancel := volumeUsageRefreshContextInternal(ctx)- go func() {- defer cancel()-- volumes, err := fetchVolumeUsageDataInternal(refreshCtx, dockerClient)-- volumeUsageCacheMutex.Lock()- current := volumeUsageCacheEntries[key]- if current != nil && current.generation == generation && current.refresh == refresh {- if err == nil {- current.volumes = volumes- current.refreshedAt = time.Now()- }- current.refresh = nil- }- refresh.err = err- close(refresh.done)- volumeUsageCacheMutex.Unlock()-- if err != nil {- slog.WarnContext(refreshCtx, "failed to refresh volume usage cache", "error", err, "docker_host", key)- return- }- slog.DebugContext(refreshCtx, "refreshed volume usage cache", "volume_count", len(volumes), "docker_host", key)- }()-- return refresh-}-func volumeUsageRefreshContextInternal(ctx context.Context) (context.Context, context.CancelFunc) {detached := context.WithoutCancel(ctx)if deadline, ok := ctx.Deadline(); ok {@@ -198,6 +155,10 @@ func volumeUsageRefreshContextInternal(ctx context.Context) (context.Context, coreturn context.WithTimeout(detached, volumeUsageRefreshFallbackTimeout)}+func cloneVolumeUsageInternal(volumes []volume.Volume) []volume.Volume {+ return append([]volume.Volume(nil), volumes...)+}+func fetchVolumeUsageDataInternal(ctx context.Context, dockerClient *client.Client) ([]volume.Volume, error) {diskUsage, err := dockerClient.DiskUsage(ctx, client.DiskUsageOptions{Volumes: true,diff --git a/backend/pkg/dockerutil/volume_utils_test.go b/backend/pkg/dockerutil/volume_utils_test.goindex 5c568c537..e820df9d8 100644--- a/backend/pkg/dockerutil/volume_utils_test.go+++ b/backend/pkg/dockerutil/volume_utils_test.go@@ -86,9 +86,10 @@ func TestVolumeUsageCacheBehaviorInternal(t *testing.T) {require.NoError(t, err)key := volumeUsageCacheKeyInternal(dockerClient)- volumeUsageCacheMutex.Lock()- volumeUsageCacheEntries[key].refreshedAt = time.Now().Add(-volumeUsageCacheTTL)- volumeUsageCacheMutex.Unlock()+ cached, found := volumeUsageCache.Peek(key)+ require.True(t, found)+ volumeUsageCache.SetWithTTL(key, cached, time.Nanosecond)+ time.Sleep(time.Millisecond)startedAt := time.Now()stale, found := GetVolumeUsageDataStaleWhileRevalidate(ctx, dockerClient).Get()@@ -129,16 +130,16 @@ func TestVolumeUsageCacheBehaviorInternal(t *testing.T) {_, err = GetVolumeUsageData(ctx, clientB)require.NoError(t, err)- cachedA, foundA, _ := volumeUsageCacheSnapshotInternal(volumeUsageCacheKeyInternal(clientA))- cachedB, foundB, _ := volumeUsageCacheSnapshotInternal(volumeUsageCacheKeyInternal(clientB))+ cachedA, foundA := volumeUsageCache.Peek(volumeUsageCacheKeyInternal(clientA))+ cachedB, foundB := volumeUsageCache.Peek(volumeUsageCacheKeyInternal(clientB))require.True(t, foundA)require.True(t, foundB)require.Equal(t, "host-a", cachedA[0].Name)require.Equal(t, "host-b", cachedB[0].Name)InvalidateVolumeUsageCache(clientA)- _, foundA, _ = volumeUsageCacheSnapshotInternal(volumeUsageCacheKeyInternal(clientA))- cachedB, foundB, _ = volumeUsageCacheSnapshotInternal(volumeUsageCacheKeyInternal(clientB))+ _, foundA = volumeUsageCache.Peek(volumeUsageCacheKeyInternal(clientA))+ cachedB, foundB = volumeUsageCache.Peek(volumeUsageCacheKeyInternal(clientB))require.False(t, foundA)require.True(t, foundB)require.Equal(t, "host-b", cachedB[0].Name)@@ -168,8 +169,5 @@ func writeVolumeUsageResponseInternal(t *testing.T, w http.ResponseWriter, name}func resetVolumeUsageCacheForTestInternal() {- volumeUsageCacheMutex.Lock()- volumeUsageCacheEntries = make(map[string]*volumeUsageCacheEntryInternal)- volumeUsageCacheGenerations = make(map[string]uint64)- volumeUsageCacheMutex.Unlock()+ volumeUsageCache.Purge()}diff --git a/backend/pkg/libarcane/system/gpu.go b/backend/pkg/libarcane/system/gpu.goindex 5a1c1d417..ba0b323c7 100644--- a/backend/pkg/libarcane/system/gpu.go+++ b/backend/pkg/libarcane/system/gpu.go@@ -15,13 +15,16 @@ import ("time"systemtypes "github.com/getarcaneapp/arcane/types/v2/system"+ "github.com/samber/hot")// AMDGPUSysfsPath is the sysfs base used to discover AMD GPUs.-const AMDGPUSysfsPath = "/sys/class/drm"+const (+ AMDGPUSysfsPath = "/sys/class/drm"-// gpuDetectionTTL bounds how long a successful detection result is reused before re-detecting.-const gpuDetectionTTL = 30 * time.Second+ // gpuDetectionTTL bounds how long a successful detection result is reused before re-detecting.+ gpuDetectionTTL = 30 * time.Second+)// GPUMonitor probes for an attached GPU (NVIDIA / AMD / Intel) and reports VRAM usage.// Detection is cached for gpuDetectionTTL; once a vendor is detected, subsequent Stats@@ -33,18 +36,26 @@ type GPUMonitor struct {detectionMu sync.MutexdetectionDone bool- cacheMu sync.RWMutex- detected bool- timestamp time.Time- gpuType string- toolPath string+ detectionCache *hot.HotCache[struct{}, gpuDetection]+}++type gpuDetection struct {+ detected bool+ gpuType string+ toolPath string}// NewGPUMonitor creates a monitor. enabled gates Stats; when false, Stats returns// (nil, nil). configuredType is the user-pinned vendor ("nvidia"|"amd"|"intel"|"auto"|"")// — anything else falls back to auto-detection.func NewGPUMonitor(enabled bool, configuredType string) *GPUMonitor {- return &GPUMonitor{enabled: enabled, configuredType: configuredType}+ return &GPUMonitor{+ enabled: enabled,+ configuredType: configuredType,+ detectionCache: hot.NewHotCache[struct{}, gpuDetection](hot.LRU, 1).+ WithTTL(gpuDetectionTTL).+ Build(),+ }}// Enabled reports whether GPU monitoring is on.@@ -66,25 +77,19 @@ func (m *GPUMonitor) Stats(ctx context.Context) ([]systemtypes.GPUStats, error)}}- m.cacheMu.RLock()- if m.detected && time.Since(m.timestamp) < gpuDetectionTTL {- t := m.gpuType- m.cacheMu.RUnlock()- return m.statsForTypeInternal(ctx, t)+ if detection, found, _ := m.detectionCache.Get(struct{}{}); found && detection.detected {+ return m.statsForTypeInternal(ctx, detection.gpuType)}- m.cacheMu.RUnlock()if err := m.detectInternal(ctx); err != nil {return nil, err}- m.cacheMu.RLock()- t := m.gpuType- m.cacheMu.RUnlock()- if t == "" {+ detection, found, _ := m.detectionCache.Get(struct{}{})+ if !found || detection.gpuType == "" {return nil, errors.New("no supported GPU found")}- return m.statsForTypeInternal(ctx, t)+ return m.statsForTypeInternal(ctx, detection.gpuType)}func (m *GPUMonitor) statsForTypeInternal(ctx context.Context, gpuType string) ([]systemtypes.GPUStats, error) {@@ -100,14 +105,9 @@ func (m *GPUMonitor) statsForTypeInternal(ctx context.Context, gpuType string) (}}-// markDetected records a successful detection. Caller must NOT hold cacheMu.+// markDetected records a successful detection.func (m *GPUMonitor) markDetectedInternal(gpuType, toolPath string) {- m.cacheMu.Lock()- m.detected = true- m.gpuType = gpuType- m.toolPath = toolPath- m.timestamp = time.Now()- m.cacheMu.Unlock()+ m.detectionCache.Set(struct{}{}, gpuDetection{detected: true, gpuType: gpuType, toolPath: toolPath})m.detectionDone = true}diff --git a/backend/pkg/libarcane/ws/diagnostics.go b/backend/pkg/libarcane/ws/diagnostics.goindex 58b536979..e480ecb59 100644--- a/backend/pkg/libarcane/ws/diagnostics.go+++ b/backend/pkg/libarcane/ws/diagnostics.go@@ -3,39 +3,28 @@ package wsimport ("runtime""strings"- "sync""time"++ "github.com/samber/hot")const wsPkgPath = "internal/utils/ws"const workerGoroutineCountTTL = 5 * time.Second-var workerGoroutineCountCache struct {- sync.Mutex-- value int- at time.Time-}+var workerGoroutineCountCache = hot.NewHotCache[struct{}, int](hot.LRU, 1).+ WithTTL(workerGoroutineCountTTL).+ Build()// CountWorkerGoroutines returns a best-effort count of websocket worker goroutines// belonging to this package. Intended for diagnostics endpoints only.func CountWorkerGoroutines() int {- workerGoroutineCountCache.Lock()- if !workerGoroutineCountCache.at.IsZero() && time.Since(workerGoroutineCountCache.at) < workerGoroutineCountTTL {- value := workerGoroutineCountCache.value- workerGoroutineCountCache.Unlock()- return value+ count, found, err := workerGoroutineCountCache.GetWithLoaders(struct{}{}, func(_ []struct{}) (map[struct{}]int, error) {+ return map[struct{}]int{{}: countWorkerGoroutinesInternal()}, nil+ })+ if err != nil || !found {+ return countWorkerGoroutinesInternal()}- workerGoroutineCountCache.Unlock()-- count := countWorkerGoroutinesInternal()-- workerGoroutineCountCache.Lock()- workerGoroutineCountCache.value = count- workerGoroutineCountCache.at = time.Now()- workerGoroutineCountCache.Unlock()-return count}diff --git a/backend/pkg/projects/env.go b/backend/pkg/projects/env.goindex 82998ec45..778bba5ca 100644--- a/backend/pkg/projects/env.go+++ b/backend/pkg/projects/env.go@@ -18,7 +18,7 @@ import ("time""github.com/compose-spec/compose-go/v2/dotenv"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache"+ "github.com/samber/hot")const (@@ -75,8 +75,8 @@ type envFileCacheEntry struct {var (processEnvOnce sync.OnceprocessEnvSnapshot EnvMap- globalEnvFileCache = cache.NewKeyed[string, envFileCacheEntry]()- projectEnvFileCache = cache.NewKeyed[string, envFileCacheEntry]()+ globalEnvFileCache = hot.NewHotCache[string, envFileCacheEntry](hot.LRU, 4096).Build()+ projectEnvFileCache = hot.NewHotCache[string, envFileCacheEntry](hot.LRU, 4096).Build())func NewEnvLoader(projectsDir, workdir string, autoInjectEnv bool) *EnvLoader {@@ -167,29 +167,43 @@ func (l *EnvLoader) loadAndMergeProjectEnv(ctx context.Context, path string, envreturn nil}-func loadCachedEnvFileInternal(ctx context.Context, envCache *cache.KeyedCache[string, envFileCacheEntry], key, path string, contextEnv EnvMap) (envFileCacheEntry, error) {- return envCache.GetOrFetch(ctx, key, validEnvFileCacheEntryInternal, func(context.Context) (envFileCacheEntry, error) {+func loadCachedEnvFileInternal(_ context.Context, envCache *hot.HotCache[string, envFileCacheEntry], key, path string, contextEnv EnvMap) (envFileCacheEntry, error) {+ if cached, ok := envCache.Peek(key); ok {+ if validEnvFileCacheEntryInternal(cached) {+ return cached, nil+ }+ envCache.Delete(key)+ }++ entry, found, err := envCache.GetWithLoaders(key, func(_ []string) (map[string]envFileCacheEntry, error) {entry := envFileCacheEntry{path: path}info, err := os.Stat(path)if err != nil {if errors.Is(err, os.ErrNotExist) {- return entry, nil+ return map[string]envFileCacheEntry{key: entry}, nil}- return entry, err+ return nil, err}if info.IsDir() {- return entry, fmt.Errorf("path is a directory: %s", path)+ return nil, fmt.Errorf("path is a directory: %s", path)}parsed, err := parseProjectEnvFileExistingInternal(path, contextEnv)if err != nil {- return entry, fmt.Errorf("parse env file: %w", err)+ return nil, fmt.Errorf("parse env file: %w", err)}entry.exists = trueentry.mtime = info.ModTime()entry.values = parsed- return entry, nil+ return map[string]envFileCacheEntry{key: entry}, nil})+ if err != nil {+ return envFileCacheEntry{}, err+ }+ if !found {+ return envFileCacheEntry{}, errors.New("environment file cache loader returned no entry")+ }+ return entry, nil}func envContextFingerprintInternal(envMap EnvMap) string {diff --git a/backend/pkg/utils/cache/cache_util.go b/backend/pkg/utils/cache/cache_util.godeleted file mode 100644index ae6a72258..000000000--- a/backend/pkg/utils/cache/cache_util.go+++ /dev/null@@ -1,231 +0,0 @@-package cache--import (- "context"- "fmt"- "sync"- "time"-- "github.com/getarcaneapp/arcane/backend/v2/internal/common"- "github.com/samber/mo"- "golang.org/x/sync/singleflight"-)--type StaleError struct {- Err error-}--func (e *StaleError) Error() string { return "stale cache value: " + e.Err.Error() }-func (e *StaleError) Unwrap() error { return e.Err }--type Cache[T any] struct {- ttl time.Duration-- mu sync.RWMutex- val T- exp time.Time- set bool- generation uint64-- sf singleflight.Group-}--type cacheSnapshotInternal[T any] struct {- value T- set bool- fresh bool- generation uint64-}--type KeyedCache[K comparable, T any] struct {- mu sync.RWMutex- entries map[K]T- keyGenerations map[K]uint64- allGeneration uint64- sf singleflight.Group-}--func New[T any](ttl time.Duration) *Cache[T] {- return &Cache[T]{ttl: ttl}-}--func NewKeyed[K comparable, T any]() *KeyedCache[K, T] {- return &KeyedCache[K, T]{- entries: make(map[K]T),- keyGenerations: make(map[K]uint64),- }-}--func (c *Cache[T]) snapshotInternal() cacheSnapshotInternal[T] {- c.mu.RLock()- defer c.mu.RUnlock()- return cacheSnapshotInternal[T]{- value: c.val,- set: c.set,- fresh: c.set && (c.ttl <= 0 || time.Now().Before(c.exp)),- generation: c.generation,- }-}--func retryInvalidatedFetchInternal(ctx context.Context, err error) (bool, error) {- if !common.IsCacheInvalidatedDuringFetchError(err) {- return false, err- }- if ctxErr := ctx.Err(); ctxErr != nil {- return false, ctxErr- }- return true, nil-}--// Get returns the cached value for key, if present.-func (c *KeyedCache[K, T]) Get(key K) mo.Option[T] {- c.mu.RLock()- defer c.mu.RUnlock()- cached, ok := c.entries[key]- return mo.TupleToOption(cached, ok)-}--// Set stores value for key, replacing any existing entry.-func (c *KeyedCache[K, T]) Set(key K, value T) {- c.mu.Lock()- c.entries[key] = value- c.mu.Unlock()-}--func (c *KeyedCache[K, T]) GetOrFetch(- ctx context.Context,- key K,- valid func(cached T) bool,- fetch func(ctx context.Context) (T, error),-) (T, error) {- for {- c.mu.RLock()- cached, ok := c.entries[key]- allGeneration := c.allGeneration- keyGeneration := c.keyGenerations[key]- c.mu.RUnlock()- if ok && (valid == nil || valid(cached)) {- return cached, nil- }-- flightKey := fmt.Sprintf("%#v:%d:%d", key, allGeneration, keyGeneration)- res, err, _ := c.sf.Do(flightKey, func() (any, error) {- c.mu.RLock()- cached, ok := c.entries[key]- generationCurrent := c.allGeneration == allGeneration && c.keyGenerations[key] == keyGeneration- c.mu.RUnlock()- if !generationCurrent {- return nil, &common.CacheInvalidatedDuringFetchError{}- }- if ok && (valid == nil || valid(cached)) {- return cached, nil- }-- v, err := fetch(ctx)- if err != nil {- return nil, err- }-- c.mu.Lock()- generationCurrent = c.allGeneration == allGeneration && c.keyGenerations[key] == keyGeneration- if generationCurrent {- c.entries[key] = v- }- c.mu.Unlock()- if !generationCurrent {- return nil, &common.CacheInvalidatedDuringFetchError{}- }- return v, nil- })- retry, err := retryInvalidatedFetchInternal(ctx, err)- if retry {- continue- }- if err != nil {- var zero T- return zero, err- }-- v, _ := res.(T)- return v, nil- }-}--func (c *KeyedCache[K, T]) Invalidate(key K) {- c.mu.Lock()- delete(c.entries, key)- c.keyGenerations[key]++- c.mu.Unlock()-}--func (c *KeyedCache[K, T]) InvalidateAll() {- c.mu.Lock()- c.entries = make(map[K]T)- c.keyGenerations = make(map[K]uint64)- c.allGeneration++- c.mu.Unlock()-}--func (c *Cache[T]) GetOrFetch(ctx context.Context, fetch func(ctx context.Context) (T, error)) (T, error) {- for {- snapshot := c.snapshotInternal()- if snapshot.fresh {- return snapshot.value, nil- }-- res, err, _ := c.sf.Do(fmt.Sprintf("singleton:%d", snapshot.generation), func() (any, error) {- current := c.snapshotInternal()- if current.fresh {- return current.value, nil- }- if current.generation != snapshot.generation {- return nil, &common.CacheInvalidatedDuringFetchError{}- }-- v, err := fetch(ctx)- if err != nil {- return nil, err- }-- c.mu.Lock()- generationCurrent := c.generation == snapshot.generation- if generationCurrent {- c.val = v- c.set = true- if c.ttl > 0 {- c.exp = time.Now().Add(c.ttl)- }- }- c.mu.Unlock()- if !generationCurrent {- return nil, &common.CacheInvalidatedDuringFetchError{}- }- return v, nil- })- retry, err := retryInvalidatedFetchInternal(ctx, err)- if retry {- continue- }- if err != nil {- current := c.snapshotInternal()- if snapshot.set && current.generation == snapshot.generation {- return snapshot.value, &StaleError{Err: err}- }- var zero T- return zero, err- }-- v, _ := res.(T)- return v, nil- }-}--func (c *Cache[T]) Invalidate() {- c.mu.Lock()- c.generation++- c.set = false- var zero T- c.val = zero- c.exp = time.Time{}- c.mu.Unlock()-}diff --git a/backend/pkg/utils/cache/cache_util_test.go b/backend/pkg/utils/cache/cache_util_test.godeleted file mode 100644index abb440d7d..000000000--- a/backend/pkg/utils/cache/cache_util_test.go+++ /dev/null@@ -1,420 +0,0 @@-package cache--import (- "context"- "errors"- "fmt"- "sync"- "sync/atomic"- "testing"- "time"-)--func TestKeyedCacheGetSet(t *testing.T) {- c := NewKeyed[string, *int]()-- if _, ok := c.Get("missing").Get(); ok {- t.Fatal("expected miss for unset key")- }-- c.Set("hit", new(42))- got, ok := c.Get("hit").Get()- if !ok || got == nil || *got != 42 {- t.Fatalf("expected cached value 42, got %v (ok=%v)", got, ok)- }-- // Nil values are valid entries and must report as hits.- c.Set("nil-entry", nil)- got, ok = c.Get("nil-entry").Get()- if !ok || got != nil {- t.Fatalf("expected nil hit, got %v (ok=%v)", got, ok)- }-- c.Invalidate("hit")- if _, ok := c.Get("hit").Get(); ok {- t.Fatal("expected miss after invalidate")- }-}--func TestCacheInvalidationDoesNotPublishInFlightFetch(t *testing.T) {- c := New[string](time.Minute)- firstFetchStarted := make(chan struct{})- releaseFirstFetch := make(chan struct{})- var fetchCalls atomic.Int32-- fetch := func(ctx context.Context) (string, error) {- switch fetchCalls.Add(1) {- case 1:- close(firstFetchStarted)- select {- case <-releaseFirstFetch:- return "obsolete", nil- case <-ctx.Done():- return "", ctx.Err()- }- case 2:- return "fresh", nil- default:- return "", fmt.Errorf("unexpected fetch call")- }- }-- type result struct {- value string- err error- }- firstResult := make(chan result, 1)- go func() {- value, err := c.GetOrFetch(context.Background(), fetch)- firstResult <- result{value: value, err: err}- }()-- select {- case <-firstFetchStarted:- case <-time.After(5 * time.Second):- t.Fatal("first fetch did not start")- }-- c.Invalidate()- currentResult := make(chan result, 1)- go func() {- value, err := c.GetOrFetch(context.Background(), fetch)- currentResult <- result{value: value, err: err}- }()-- var current result- select {- case current = <-currentResult:- case <-time.After(5 * time.Second):- t.Fatal("post-invalidation fetch waited for the obsolete singleflight call")- }- if current.err != nil || current.value != "fresh" {- t.Fatalf("expected fresh post-invalidation result, got %q (err=%v)", current.value, current.err)- }-- close(releaseFirstFetch)- var first result- select {- case first = <-firstResult:- case <-time.After(5 * time.Second):- t.Fatal("first caller did not finish")- }- if first.err != nil || first.value != "fresh" {- t.Fatalf("expected first caller to observe the current generation, got %q (err=%v)", first.value, first.err)- }- if got := fetchCalls.Load(); got != 2 {- t.Fatalf("expected two generation-specific fetches, got %d", got)- }-- value, err := c.GetOrFetch(context.Background(), fetch)- if err != nil || value != "fresh" {- t.Fatalf("expected cache to retain fresh value, got %q (err=%v)", value, err)- }-}--func TestCacheCanceledCallerDoesNotRetryAfterInvalidation(t *testing.T) {- c := New[string](time.Minute)- ctx, cancel := context.WithCancel(context.Background())- fetchStarted := make(chan struct{})- releaseFetch := make(chan struct{})- var fetchCalls atomic.Int32-- resultChannel := make(chan error, 1)- go func() {- _, err := c.GetOrFetch(ctx, func(context.Context) (string, error) {- if fetchCalls.Add(1) == 1 {- close(fetchStarted)- <-releaseFetch- return "obsolete", nil- }- return "retry", nil- })- resultChannel <- err- }()-- select {- case <-fetchStarted:- case <-time.After(5 * time.Second):- t.Fatal("singleton fetch did not start")- }-- c.Invalidate()- cancel()- close(releaseFetch)-- select {- case err := <-resultChannel:- if !errors.Is(err, context.Canceled) {- t.Fatalf("expected canceled caller to return context cancellation, got %v", err)- }- case <-time.After(5 * time.Second):- t.Fatal("canceled singleton caller did not finish")- }- if got := fetchCalls.Load(); got != 1 {- t.Fatalf("expected canceled singleton caller not to retry, got %d fetches", got)- }-}--func TestCacheConcurrentMissesUseSingleflight(t *testing.T) {- const callerCount = 32-- c := New[int](time.Minute)- start := make(chan struct{})- fetchStarted := make(chan struct{})- releaseFetch := make(chan struct{})- var fetchStartedOnce sync.Once- var fetchCalls atomic.Int32- var callersReady sync.WaitGroup- var callersDone sync.WaitGroup- callersReady.Add(callerCount)- callersDone.Add(callerCount)-- type result struct {- value int- err error- }- results := make(chan result, callerCount)- for range callerCount {- go func() {- defer callersDone.Done()- callersReady.Done()- <-start- value, err := c.GetOrFetch(context.Background(), func(context.Context) (int, error) {- fetchCalls.Add(1)- fetchStartedOnce.Do(func() { close(fetchStarted) })- <-releaseFetch- return 42, nil- })- results <- result{value: value, err: err}- }()- }-- callersReady.Wait()- close(start)- select {- case <-fetchStarted:- case <-time.After(5 * time.Second):- t.Fatal("singleflight fetch did not start")- }- close(releaseFetch)- callersDone.Wait()- close(results)-- for result := range results {- if result.err != nil || result.value != 42 {- t.Fatalf("expected shared value 42, got %d (err=%v)", result.value, result.err)- }- }- if got := fetchCalls.Load(); got != 1 {- t.Fatalf("expected one shared fetch, got %d", got)- }-}--func TestKeyedCacheInvalidationDoesNotPublishInFlightFetch(t *testing.T) {- tests := []struct {- name string- invalidateAll bool- otherEntryPresent bool- }{- {name: "key", otherEntryPresent: true},- {name: "all", invalidateAll: true},- }-- for _, test := range tests {- t.Run(test.name, func(t *testing.T) {- c := NewKeyed[string, string]()- c.Set("other", "preserved")- firstFetchStarted := make(chan struct{})- releaseFirstFetch := make(chan struct{})- var fetchCalls atomic.Int32-- fetch := func(ctx context.Context) (string, error) {- switch fetchCalls.Add(1) {- case 1:- close(firstFetchStarted)- select {- case <-releaseFirstFetch:- return "obsolete", nil- case <-ctx.Done():- return "", ctx.Err()- }- case 2:- return "fresh", nil- default:- return "", fmt.Errorf("unexpected fetch call")- }- }-- type result struct {- value string- err error- }- firstResult := make(chan result, 1)- go func() {- value, err := c.GetOrFetch(context.Background(), "target", nil, fetch)- firstResult <- result{value: value, err: err}- }()-- select {- case <-firstFetchStarted:- case <-time.After(5 * time.Second):- t.Fatal("first keyed fetch did not start")- }-- if test.invalidateAll {- c.InvalidateAll()- } else {- c.Invalidate("target")- }-- currentResult := make(chan result, 1)- go func() {- value, err := c.GetOrFetch(context.Background(), "target", nil, fetch)- currentResult <- result{value: value, err: err}- }()-- var current result- select {- case current = <-currentResult:- case <-time.After(5 * time.Second):- t.Fatal("post-invalidation keyed fetch waited for the obsolete singleflight call")- }- if current.err != nil || current.value != "fresh" {- t.Fatalf("expected fresh keyed result, got %q (err=%v)", current.value, current.err)- }-- close(releaseFirstFetch)- var first result- select {- case first = <-firstResult:- case <-time.After(5 * time.Second):- t.Fatal("first keyed caller did not finish")- }- if first.err != nil || first.value != "fresh" {- t.Fatalf("expected first keyed caller to observe the current generation, got %q (err=%v)", first.value, first.err)- }- if got := fetchCalls.Load(); got != 2 {- t.Fatalf("expected two generation-specific keyed fetches, got %d", got)- }-- value, ok := c.Get("target").Get()- if !ok || value != "fresh" {- t.Fatalf("expected keyed cache to retain fresh value, got %q (ok=%v)", value, ok)- }- _, otherPresent := c.Get("other").Get()- if otherPresent != test.otherEntryPresent {- t.Fatalf("unexpected unrelated entry state: got present=%v, want %v", otherPresent, test.otherEntryPresent)- }- })- }-}--func TestKeyedCacheCanceledCallerDoesNotRetryAfterInvalidation(t *testing.T) {- c := NewKeyed[string, string]()- ctx, cancel := context.WithCancel(context.Background())- fetchStarted := make(chan struct{})- releaseFetch := make(chan struct{})- var fetchCalls atomic.Int32-- resultChannel := make(chan error, 1)- go func() {- _, err := c.GetOrFetch(ctx, "target", nil, func(context.Context) (string, error) {- if fetchCalls.Add(1) == 1 {- close(fetchStarted)- <-releaseFetch- return "obsolete", nil- }- return "retry", nil- })- resultChannel <- err- }()-- select {- case <-fetchStarted:- case <-time.After(5 * time.Second):- t.Fatal("keyed fetch did not start")- }-- c.Invalidate("target")- cancel()- close(releaseFetch)-- select {- case err := <-resultChannel:- if !errors.Is(err, context.Canceled) {- t.Fatalf("expected canceled caller to return context cancellation, got %v", err)- }- case <-time.After(5 * time.Second):- t.Fatal("canceled keyed caller did not finish")- }- if got := fetchCalls.Load(); got != 1 {- t.Fatalf("expected canceled keyed caller not to retry, got %d fetches", got)- }-}--func TestCacheStaleFallbackRequiresCurrentGeneration(t *testing.T) {- upstreamErr := errors.New("upstream unavailable")-- t.Run("current generation", func(t *testing.T) {- c := New[string](time.Minute)- c.val = "stale"- c.set = true- c.exp = time.Now().Add(-time.Minute)-- value, err := c.GetOrFetch(context.Background(), func(context.Context) (string, error) {- return "", upstreamErr- })- if value != "stale" {- t.Fatalf("expected stale fallback, got %q", value)- }- var staleErr *StaleError- if !errors.As(err, &staleErr) || !errors.Is(err, upstreamErr) {- t.Fatalf("expected stale error wrapping upstream failure, got %v", err)- }- })-- t.Run("invalidated generation", func(t *testing.T) {- c := New[string](time.Minute)- c.val = "stale"- c.set = true- c.exp = time.Now().Add(-time.Minute)- fetchStarted := make(chan struct{})- releaseFetch := make(chan struct{})-- type result struct {- value string- err error- }- resultChannel := make(chan result, 1)- go func() {- value, err := c.GetOrFetch(context.Background(), func(context.Context) (string, error) {- close(fetchStarted)- <-releaseFetch- return "", upstreamErr- })- resultChannel <- result{value: value, err: err}- }()-- select {- case <-fetchStarted:- case <-time.After(5 * time.Second):- t.Fatal("stale fallback fetch did not start")- }- c.Invalidate()- close(releaseFetch)-- var got result- select {- case got = <-resultChannel:- case <-time.After(5 * time.Second):- t.Fatal("invalidated stale fallback did not finish")- }- if got.value != "" || !errors.Is(got.err, upstreamErr) {- t.Fatalf("expected upstream error without stale data, got %q (err=%v)", got.value, got.err)- }- var staleErr *StaleError- if errors.As(got.err, &staleErr) {- t.Fatalf("invalidated stale generation must not be returned: %v", got.err)- }- })-}diff --git a/backend/pkg/utils/cache/ttl.go b/backend/pkg/utils/cache/ttl.godeleted file mode 100644index 347b916ba..000000000--- a/backend/pkg/utils/cache/ttl.go+++ /dev/null@@ -1,75 +0,0 @@-package cache--import (- "sync"- "time"-- "github.com/samber/mo"-)--type entry[V any] struct {- value V- expiresAt time.Time-}--// TTL is a concurrency-safe in-memory cache with per-entry expiration.-type TTL[V any] struct {- mu sync.RWMutex- entries map[string]*entry[V]- ttl time.Duration- lastSweep time.Time-}--func NewTTL[V any](ttl time.Duration) *TTL[V] {- return &TTL[V]{- entries: make(map[string]*entry[V]),- ttl: ttl,- }-}--func (c *TTL[V]) Get(key string) mo.Option[V] {- c.mu.RLock()- defer c.mu.RUnlock()- e, exists := c.entries[key]- e, ok := mo.TupleToOption(e, exists).Get()- if !ok || time.Now().After(e.expiresAt) {- return mo.None[V]()- }- return mo.Some(e.value)-}--func (c *TTL[V]) Put(key string, value V) {- c.mu.Lock()- defer c.mu.Unlock()- now := time.Now()- if now.Sub(c.lastSweep) > c.ttl {- for k, e := range c.entries {- if now.After(e.expiresAt) {- delete(c.entries, k)- }- }- c.lastSweep = now- }- c.entries[key] = &entry[V]{- value: value,- expiresAt: now.Add(c.ttl),- }-}--// DeleteFunc removes all entries where the predicate returns true.-func (c *TTL[V]) DeleteFunc(fn func(key string, value V) bool) {- c.mu.Lock()- defer c.mu.Unlock()- for k, e := range c.entries {- if fn(k, e.value) {- delete(c.entries, k)- }- }-}--// Delete removes the entry for key, if present.-func (c *TTL[V]) Delete(key string) {- c.mu.Lock()- delete(c.entries, key)- c.mu.Unlock()-}diff --git a/cli/go.mod b/cli/go.modindex d63ef0f51..8a8b72bc1 100644--- a/cli/go.mod+++ b/cli/go.mod@@ -13,6 +13,7 @@ require (github.com/getarcaneapp/arcane/types/v2 v2.5.0github.com/go-viper/mapstructure/v2 v2.5.0github.com/mattn/go-runewidth v0.0.24+ github.com/samber/hot v0.13.0github.com/spf13/cobra v1.10.2github.com/spf13/pflag v1.0.10github.com/spf13/viper v1.21.0@@ -22,8 +23,10 @@ require ()require (+ github.com/DmitriyVTitov/size v1.5.0 // indirectgithub.com/Microsoft/go-winio v0.6.3-0.20251027160822-ad3df93bed29 // indirectgithub.com/atotto/clipboard v0.1.4 // indirect+ github.com/beorn7/perks v1.0.1 // indirectgithub.com/cespare/xxhash/v2 v2.3.0 // indirectgithub.com/charmbracelet/colorprofile v0.4.3 // indirectgithub.com/charmbracelet/harmonica v0.2.0 // indirect@@ -46,6 +49,7 @@ require (github.com/go-logfmt/logfmt v0.6.1 // indirectgithub.com/go-logr/logr v1.4.3 // indirectgithub.com/go-logr/stdr v1.2.2 // indirect+ github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirectgithub.com/inconshreveable/mousetrap v1.1.0 // indirectgithub.com/lucasb-eyer/go-colorful v1.4.0 // indirectgithub.com/mattn/go-colorable v0.1.15 // indirect@@ -59,13 +63,19 @@ require (github.com/muesli/mango-cobra v1.3.0 // indirectgithub.com/muesli/mango-pflag v0.2.0 // indirectgithub.com/muesli/roff v0.1.0 // indirect+ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirectgithub.com/opencontainers/go-digest v1.0.0 // indirectgithub.com/opencontainers/image-spec v1.1.1 // indirectgithub.com/pelletier/go-toml/v2 v2.3.1 // indirectgithub.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect+ github.com/prometheus/client_golang v1.23.2 // indirect+ github.com/prometheus/client_model v0.6.2 // indirect+ github.com/prometheus/common v0.67.5 // indirect+ github.com/prometheus/procfs v0.20.1 // indirectgithub.com/rivo/uniseg v0.4.7 // indirectgithub.com/sagikazarmark/locafero v0.12.0 // indirectgithub.com/sahilm/fuzzy v0.1.3 // indirect+ github.com/samber/go-singleflightx v0.3.2 // indirectgithub.com/sirupsen/logrus v1.9.4 // indirectgithub.com/spf13/afero v1.15.0 // indirectgithub.com/spf13/cast v1.10.0 // indirect@@ -77,11 +87,13 @@ require (go.opentelemetry.io/otel v1.44.0 // indirectgo.opentelemetry.io/otel/metric v1.44.0 // indirectgo.opentelemetry.io/otel/trace v1.44.0 // indirect+ go.yaml.in/yaml/v2 v2.4.4 // indirectgo.yaml.in/yaml/v3 v3.0.4 // indirectgo.yaml.in/yaml/v4 v4.0.0-rc.6 // indirectgolang.org/x/exp v0.0.0-20260603202125-055de637280b // indirectgolang.org/x/sync v0.22.0 // indirectgolang.org/x/sys v0.47.0 // indirectgolang.org/x/text v0.40.0 // indirect+ google.golang.org/protobuf v1.36.12-0.20260120151049-f2248ac996af // indirectgopkg.in/yaml.v3 v3.0.1 // indirect)diff --git a/cli/go.sum b/cli/go.sumindex 67b32ef28..6e23c9d6c 100644--- a/cli/go.sum+++ b/cli/go.sum@@ -8,12 +8,16 @@ charm.land/lipgloss/v2 v2.0.5 h1:kbNxgeeUOYv5J0YdpxFjfvf3dFvqH8Aci4zB6xqFtrY=charm.land/lipgloss/v2 v2.0.5/go.mod h1:9oqhxt4yxIMe6q5A4kHr44DremZk7J9UNh74GlWa5nc=charm.land/log/v2 v2.0.0 h1:SY3Cey7ipx86/MBXQHwsguOT6X1exT94mmJRdzTNs+s=charm.land/log/v2 v2.0.0/go.mod h1:c3cZSRqm20qUVVAR1WmS/7ab8bgha3C6G7DjPcaVZz0=+github.com/DmitriyVTitov/size v1.5.0 h1:/PzqxYrOyOUX1BXj6J9OuVRVGe+66VL4D9FlUaW515g=+github.com/DmitriyVTitov/size v1.5.0/go.mod h1:le6rNI4CoLQV1b9gzp1+3d7hMAD/uu2QcJ+aYbNgiU0=github.com/Microsoft/go-winio v0.6.3-0.20251027160822-ad3df93bed29 h1:0kQAzHq8vLs7Pptv+7TxjdETLf/nIqJpIB4oC6Ba4vY=github.com/Microsoft/go-winio v0.6.3-0.20251027160822-ad3df93bed29/go.mod h1:ZWa7ssZJT30CCDGJ7fk/2SBTq9BIQrrVjrcss0UW2s0=github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=github.com/aymanbagabas/go-udiff v0.4.1 h1:OEIrQ8maEeDBXQDoGCbbTTXYJMYRCRO1fnodZ12Gv5o=github.com/aymanbagabas/go-udiff v0.4.1/go.mod h1:0L9PGwj20lrtmEMeyw4WKJ/TMyDtvAoK9bf2u/mNo3w=+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=github.com/charmbracelet/colorprofile v0.4.3 h1:QPa1IWkYI+AOB+fE+mg/5/4HRMZcaXex9t5KX76i20Q=@@ -72,6 +76,9 @@ github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=github.com/go-viper/mapstructure/v2 v2.5.0 h1:vM5IJoUAy3d7zRSVtIwQgBj7BiWtMPfmPEgAXnvj1Ro=github.com/go-viper/mapstructure/v2 v2.5.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=@@ -110,6 +117,8 @@ github.com/muesli/mango-pflag v0.2.0 h1:QViokgKDZQCzKhYe1zH8D+UlPJzBSGoP9yx0hBG0github.com/muesli/mango-pflag v0.2.0/go.mod h1:X9LT1p/pbGA1wjvEbtwnixujKErkP0jVmrxwrw3fL0Y=github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040=@@ -118,6 +127,14 @@ github.com/pelletier/go-toml/v2 v2.3.1 h1:MYEvvGnQjeNkRF1qUuGolNtNExTDwct51yp7olgithub.com/pelletier/go-toml/v2 v2.3.1/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=+github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=+github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=+github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=+github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=+github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4=+github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw=+github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc=+github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo=github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=@@ -127,6 +144,10 @@ github.com/sagikazarmark/locafero v0.12.0 h1:/NQhBAkUb4+fH1jivKHWusDYFjMOOKU88eegithub.com/sagikazarmark/locafero v0.12.0/go.mod h1:sZh36u/YSZ918v0Io+U9ogLYQJ9tLLBmM4eneO6WwsI=github.com/sahilm/fuzzy v0.1.3 h1:juByESSS32nVD81vr6tHmKmA/8zde7gE+x5CLxrzXPU=github.com/sahilm/fuzzy v0.1.3/go.mod h1:au6//VbVSqu6DFrkL2CfjlJ5iURpNCPeE+1GwY3XsT8=+github.com/samber/go-singleflightx v0.3.2 h1:jXbUU0fvis8Fdv4HGONboX5WdEZcYLoBEcKiE+ITCyQ=+github.com/samber/go-singleflightx v0.3.2/go.mod h1:X2BR+oheHIYc73PvxRMlcASg6KYYTQyUYpdVU7t/ux4=+github.com/samber/hot v0.13.0 h1:4/OyD5xNfhmdHqyKWHHSisiytp93gA3knkWZLAvld2w=+github.com/samber/hot v0.13.0/go.mod h1:NB9v5U4NfDx7jmlrP+zHuqCuLUsywgAtCH7XOAkOxAg=github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w=github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g=github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=@@ -164,8 +185,12 @@ go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRkgo.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA=go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk=go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE=+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=go.withmatt.com/size v0.0.0-20250220224316-11aee5773e67 h1:nHPqmzoLZv+9OqER7S2oXnIBDAbIaIKKrVtNtDvJzjc=go.withmatt.com/size v0.0.0-20250220224316-11aee5773e67/go.mod h1:WFmSrzphcXaSV4LG3YfIw42bPHDK8A6WsAYZCxyys/c=+go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=+go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=go.yaml.in/yaml/v4 v4.0.0-rc.6 h1:1h7H1ohdUh93/FyE4YaDa1Zh64K6VVbjF4K6WUxMtH4=@@ -178,6 +203,8 @@ golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=+google.golang.org/protobuf v1.36.12-0.20260120151049-f2248ac996af h1:+5/Sw3GsDNlEmu7TfklWKPdQ0Ykja5VEmq2i817+jbI=+google.golang.org/protobuf v1.36.12-0.20260120151049-f2248ac996af/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=diff --git a/cli/internal/config/config.go b/cli/internal/config/config.goindex 29e082912..9e2b8984c 100644--- a/cli/internal/config/config.go+++ b/cli/internal/config/config.go@@ -25,11 +25,11 @@ import ("os""path/filepath""strings"- "sync""time""github.com/getarcaneapp/arcane/cli/v2/internal/types""github.com/go-viper/mapstructure/v2"+ "github.com/samber/hot""github.com/spf13/viper")@@ -48,12 +48,10 @@ const (var customConfigPath string-var (- cacheMu sync.RWMutex- cachedPath string- cachedCfg *types.Config- cacheLoaded bool-)+var configCache = hot.NewHotCache[string, *types.Config](hot.LRU, 4).+ WithCopyOnRead(cloneConfig).+ WithCopyOnWrite(cloneConfig).+ Build()func cloneConfig(cfg *types.Config) *types.Config {return cfg.Clone()@@ -76,11 +74,7 @@ func normalizeConfig(cfg *types.Config) *types.Config {}func invalidateCache() {- cacheMu.Lock()- defer cacheMu.Unlock()- cacheLoaded = false- cachedPath = ""- cachedCfg = nil+ configCache.Purge()}// DefaultConfig returns a Config with sensible default values.@@ -150,23 +144,15 @@ func Load() (*types.Config, error) {return nil, err}- cacheMu.RLock()- if cacheLoaded && cachedCfg != nil && cachedPath == path {- cfg := cloneConfig(cachedCfg)- cacheMu.RUnlock()+ if cfg, ok, _ := configCache.Get(path); ok {return cfg, nil}- cacheMu.RUnlock()data, err := os.ReadFile(path)if err != nil {if os.IsNotExist(err) {def := DefaultConfig()- cacheMu.Lock()- cacheLoaded = true- cachedPath = path- cachedCfg = cloneConfig(def)- cacheMu.Unlock()+ configCache.Set(path, def)return def, nil}return nil, fmt.Errorf("failed to read config file: %w", err)@@ -193,11 +179,7 @@ func Load() (*types.Config, error) {}normalized := normalizeConfig(&cfg)- cacheMu.Lock()- cacheLoaded = true- cachedPath = path- cachedCfg = cloneConfig(normalized)- cacheMu.Unlock()+ configCache.Set(path, normalized)return normalized, nil}@@ -262,11 +244,7 @@ func Save(c *types.Config) error {return fmt.Errorf("failed to set config permissions: %w", err)}- cacheMu.Lock()- cacheLoaded = true- cachedPath = path- cachedCfg = cloneConfig(cfg)- cacheMu.Unlock()+ configCache.Set(path, cfg)return nil}diff --git a/go.work.sum b/go.work.sumindex 8b094c739..648f93eb7 100644--- a/go.work.sum+++ b/go.work.sum@@ -1119,7 +1119,6 @@ github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUgithub.com/golang/glog v1.2.5 h1:DrW6hGnjIhtvhOIiAKT6Psh/Kd/ldepEa81DKeiRJ5I=github.com/golang/glog v1.2.5/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w=github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=github.com/golang/mock v1.1.1 h1:G5FRp8JnTd7RQH5kemVNlMeyXQAztQ3mOWV95KxsXH8=github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=github.com/golang/mock v1.7.0-rc.1 h1:YojYx61/OLFsiv6Rw1Z96LpldJIy31o+UHmwAUMJ6/U=@@ -1715,14 +1714,11 @@ github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPgithub.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=github.com/prometheus/client_golang v1.20.4/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=-github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=-github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=-github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I=github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=github.com/prometheus/otlptranslator v0.0.2 h1:+1CdeLVrRQ6Psmhnobldo0kTp96Rj80DRXRd5OSnMEQ=github.com/prometheus/otlptranslator v0.0.2/go.mod h1:P8AwMgdD7XEr6QRUJ2QWLpiAZTgTE2UYgjlu3svompI=@@ -1732,7 +1728,6 @@ github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6Rgithub.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=-github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw=github.com/prometheus/procfs v0.19.2/go.mod h1:M0aotyiemPhBCM0z5w87kL22CxfcH05ZpYlu+b4J7mw=@@ -2081,12 +2076,12 @@ go.etcd.io/gofail v0.2.0 h1:p19drv16FKK345a09a1iubchlw/vmRuksmRzgBIGjcA=go.etcd.io/gofail v0.2.0/go.mod h1:nL3ILMGfkXTekKI3clMBNazKnjUZjYLKmBHzsVAnC1o=go.etcd.io/raft/v3 v3.6.0 h1:5NtvbDVYpnfZWcIHgGRk9DyzkBIXOi8j+DDp1IcnUWQ=go.etcd.io/raft/v3 v3.6.0/go.mod h1:nLvLevg6+xrVtHUmVaTcTz603gQPHfh7kUAwV6YpfGo=-go.getarcane.app/streams v0.3.1 h1:Exs9a9G3paM9PnB6DQc8YvIKNbfaUTB7q271SD30zL8=-go.getarcane.app/streams v0.3.1/go.mod h1:LHMKblQvsL1nqKh/Y+KgQbwFSMI2I7bs9u8ZwZqzjnQ=go.getarcane.app/updater v0.3.6 h1:+BqoycaRsHj+cLVSzcYQuqbHxUKbtmaozMNblz5bVSw=go.getarcane.app/updater v0.3.6/go.mod h1:2ENitZR/lA5MuBn60OZYR5wvU3ZCE+pAgfrebfOlRDA=go.getarcane.app/updater v0.3.7 h1:WqHsxudvt8gvCR7iSHdxdzwH0+hM0FAh64bSypBX9Mo=go.getarcane.app/updater v0.3.7/go.mod h1:9RZOKaBbpUJfVA4Q9/jvqtjvWBwCnVw0OkPeQCnqAAo=+go.getarcane.app/updater v0.6.1 h1:kcRYGwLV+lbkpz6zCdDKM7PgvHnsKBAcyURNmAO4fI4=+go.getarcane.app/updater v0.6.1/go.mod h1:AVEBD3dbm+p8FOkkXGH7yDe2bHMadkYmLo5e9ajHnzI=go.mongodb.org/mongo-driver v1.7.5 h1:ny3p0reEpgsR2cfA5cjgwFZg3Cv/ofFh/8jbhGtz9VI=go.mongodb.org/mongo-driver v1.7.5/go.mod h1:VXEWRZ6URJIkUq2SCAyapmhH0ZLRBP+FT4xhp5Zvxng=go.mongodb.org/mongo-driver v1.17.6 h1:87JUG1wZfWsr6rIz3ZmpH90rL5tea7O3IHuSwHUpsss=@@ -2261,6 +2256,7 @@ golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ=+golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=@@ -2308,6 +2304,7 @@ golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww=+golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=golang.org/x/oauth2 v0.33.0 h1:4Q+qn+E5z8gPRJfmRy7C2gGG3T4jIprK6aSYgTXGRpo=@@ -2336,6 +2333,7 @@ golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=@@ -2393,6 +2391,7 @@ golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8 h1:LvzTn0GQhWuvKH/kVRS3R3bVAsdQWI7hvfLHGgh9+lU=golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8/go.mod h1:Pi4ztBfryZoJEkyFTI5/Ocsu2jXyDr6iSdgJiYE/uwE=