Skip to content

Modern Docker Management, Designed for Everyone

refactor: centralize/replace manual caching with samber/hot (#3324)

Kyle Mendell1712fc46a46e
diff --git a/backend/api/ws/handler.go b/backend/api/ws/handler.go
index 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.Cache
gpuMonitor *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) error
containerLogStreamer func(ctx context.Context, containerID string, logsChan chan<- string, follow bool, tail, since string, timestamps bool) error
systemStatsCollector 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.mod
index 36951030b..30c335360 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -44,6 +44,7 @@ require (
github.com/orandin/slog-gorm v1.4.0
github.com/pressly/goose/v3 v3.27.2
github.com/robfig/cron/v3 v3.0.1
+ github.com/samber/hot v0.13.0
github.com/samber/mo v1.17.0
github.com/samber/slog-echo v1.23.0
github.com/shirou/gopsutil/v4 v4.26.6
@@ -55,9 +56,9 @@ require (
go.getarcane.app/docker/convert v0.1.0
go.getarcane.app/streams v0.3.1
go.getarcane.app/sys/atomic v0.1.0
- go.getarcane.app/sys/cgroup v0.1.0
+ go.getarcane.app/sys/cgroup v0.1.1
go.getarcane.app/sys/crypto v0.1.0
- go.getarcane.app/updater v0.6.0
+ go.getarcane.app/updater v0.6.1
go.uber.org/fx v1.24.0
go.yaml.in/yaml/v4 v4.0.0-rc.6
golang.org/x/crypto v0.54.0
@@ -78,6 +79,7 @@ require (
dario.cat/mergo v1.0.2 // indirect
github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect
github.com/DefangLabs/secret-detector v0.0.0-20250811234530-d4b4214cd679 // indirect
+ github.com/DmitriyVTitov/size v1.5.0 // indirect
github.com/Microsoft/go-winio v0.6.3-0.20251027160822-ad3df93bed29 // indirect
github.com/ProtonMail/go-crypto v1.4.1 // indirect
github.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 // indirect
github.com/aws/aws-sdk-go-v2/service/sts v1.44.1 // indirect
github.com/aws/smithy-go v1.27.3 // indirect
+ github.com/beorn7/perks v1.0.1 // indirect
github.com/buger/goterm v1.0.4 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
@@ -170,6 +173,7 @@ require (
github.com/moby/sys/userns v0.1.0 // indirect
github.com/moby/term v0.5.2 // indirect
github.com/morikuni/aec v1.1.0 // indirect
+ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
github.com/ncruces/go-strftime v1.0.0 // indirect
github.com/pelletier/go-toml/v2 v2.3.1 // indirect
github.com/pjbgf/sha1cd v0.6.0 // indirect
@@ -177,7 +181,12 @@ require (
github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
github.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 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+ github.com/samber/go-singleflightx v0.3.2 // indirect
github.com/samber/lo v1.53.0 // indirect
github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 // indirect
github.com/secure-systems-lab/go-securesystemslib v0.11.0 // indirect
@@ -222,6 +231,7 @@ require (
go.uber.org/dig v1.19.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
go.uber.org/zap v1.26.0 // indirect
+ go.yaml.in/yaml/v2 v2.4.4 // indirect
golang.org/x/sys v0.47.0 // indirect
golang.org/x/term v0.45.0 // indirect
google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa // indirect
diff --git a/backend/go.sum b/backend/go.sum
index 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:udKWzYgxTojEK
github.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+PtYAWygg1TEWWzG
github.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.go
index 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.go
index 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) (*mod
return 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, currentPasswor
if _, 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, curren
if 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.go
index 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.go
index 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.Resp
type ContainerRegistryService struct {
db *database.DB
dockerClient registryDaemonGetter
- cache map[string]*cache.Cache[string] // imageRef -> digest cache
- cacheMu sync.RWMutex
+ cache *hot.HotCache[string, string]
ecrRefreshGroup singleflight.Group
distributionHTTPClient *http.Client
kvService *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, imageRef
return "", 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.go
index 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 *testing
assert.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.go
index 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 *SettingsService
projectService *ProjectService
statsHistory 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 *Eve
imageService: 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 cont
if !ok {
return
}
- s.updateInfoCache.InvalidateAll()
+ s.updateInfoCache.Purge()
}
}
}()
@@ -1185,43 +1185,27 @@ func (s *ContainerService) getUpdateInfoMap(ctx context.Context, imageIDs []stri
return 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.Cont
meta = s.projectService.getProjectMetadataForProject(ctx, *proj)
}
if s.iconMetaCache != nil {
- s.iconMetaCache.Put(projectName, meta)
+ s.iconMetaCache.Set(projectName, meta)
}
if metadataByProject != nil {
metadataByProject[projectName] = meta
diff --git a/backend/internal/services/docker_client_service.go b/backend/internal/services/docker_client_service.go
index 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 = 0
const 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 = nil
oldClient := s.client
s.client = nil
s.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.go
index 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 *testi
assert.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_PublishImageStateResyncNotifiesSubscribersAndInvali
eventCh, 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_PublishImageStateResyncNotifiesSubscribersAndInvali
case <-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.go
index 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 *ApiKeyService
remoteClient *remenv.Client
tokenCacheMu sync.RWMutex
- tokenCache map[string]edgeTokenCacheEntry
+ tokenCache *hot.HotCache[string, string]
tokenByEnvID map[string]string
remoteEnvMu sync.RWMutex
remoteEnvs map[string]models.Environment
@@ -72,11 +73,6 @@ const (
environmentHealthCheckTimeout = 90 * time.Second
)
-type edgeTokenCacheEntry struct {
- EnvironmentID string
- ExpiresAt time.Time
-}
-
const edgeTokenCacheTTL = time.Minute
var (
@@ -99,7 +95,10 @@ func NewEnvironmentService(db *database.DB, httpClient *http.Client, dockerServi
EnsureAvailableFunc: 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.Context
slog.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, tok
resolvedToken := 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.go
index 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_ClearingAccessTokenInvalidatesCach
func 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.go
index 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 *VulnerabilityService
eventService *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, regist
imageUpdateService: 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.Second
func (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.go
index 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.Config
httpClient *http.Client
insecureHttpClient *http.Client
- providerCache *oidc.Provider
providerMutex 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 := *httpClient
oidcClient.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.go
index 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.RWMutex
composeNameToProjID 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, eventS
lifecycleService: 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, pr
return 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, pr
if 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.go
index 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 str
ps.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.go
index 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 *KVService
registryService *ContainerRegistryService
environmentService *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]swarmNodeAgentRuntime
boundEnvsByNodeID 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 = true
runtime.identity = identity
return runtime
@@ -844,31 +842,31 @@ func (s *SwarmService) resolveSwarmNodeAgentRuntimeInternal(ctx context.Context,
runtime.connected = true
runtime.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.identity
return &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 swarm
diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.go
index 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 string
Templates []models.ComposeTemplate
@@ -51,8 +46,7 @@ type TemplateService struct {
lookupIP httputils.LookupIPFunc
settingsService *SettingsService
- remoteMu sync.RWMutex
- remoteCache remoteCache
+ remoteCache *hot.HotCache[struct{}, []models.ComposeTemplate]
registryMu sync.RWMutex
registryFetchMeta 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.C
httpClient: 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) (st
return 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.C
return 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.Comp
if 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.go
index 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.go
index 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 bool
version string
revision string
@@ -52,9 +52,8 @@ func NewVersionService(httpClient *http.Client, disabled bool, version string, r
if 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, r
dockerService: 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, currentVersi
latest, 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 releases
if 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.TagName
semverUpdateAvailable = s.IsNewer(rel.TagName, ver)
diff --git a/backend/pkg/dockerutil/volume_utils.go b/backend/pkg/dockerutil/volume_utils.go
index 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.Second
volumeUsageRefreshFallbackTimeout = 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, co
return 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.go
index 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.go
index 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.Mutex
detectionDone 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.go
index 58b536979..e480ecb59 100644
--- a/backend/pkg/libarcane/ws/diagnostics.go
+++ b/backend/pkg/libarcane/ws/diagnostics.go
@@ -3,39 +3,28 @@ package ws
import (
"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.go
index 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.Once
processEnvSnapshot 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, env
return 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 = true
entry.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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.mod
index d63ef0f51..8a8b72bc1 100644
--- a/cli/go.mod
+++ b/cli/go.mod
@@ -13,6 +13,7 @@ require (
github.com/getarcaneapp/arcane/types/v2 v2.5.0
github.com/go-viper/mapstructure/v2 v2.5.0
github.com/mattn/go-runewidth v0.0.24
+ github.com/samber/hot v0.13.0
github.com/spf13/cobra v1.10.2
github.com/spf13/pflag v1.0.10
github.com/spf13/viper v1.21.0
@@ -22,8 +23,10 @@ require (
)
require (
+ github.com/DmitriyVTitov/size v1.5.0 // indirect
github.com/Microsoft/go-winio v0.6.3-0.20251027160822-ad3df93bed29 // indirect
github.com/atotto/clipboard v0.1.4 // indirect
+ github.com/beorn7/perks v1.0.1 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/charmbracelet/colorprofile v0.4.3 // indirect
github.com/charmbracelet/harmonica v0.2.0 // indirect
@@ -46,6 +49,7 @@ require (
github.com/go-logfmt/logfmt v0.6.1 // indirect
github.com/go-logr/logr v1.4.3 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
+ github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
github.com/inconshreveable/mousetrap v1.1.0 // indirect
github.com/lucasb-eyer/go-colorful v1.4.0 // indirect
github.com/mattn/go-colorable v0.1.15 // indirect
@@ -59,13 +63,19 @@ require (
github.com/muesli/mango-cobra v1.3.0 // indirect
github.com/muesli/mango-pflag v0.2.0 // indirect
github.com/muesli/roff v0.1.0 // indirect
+ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
github.com/opencontainers/go-digest v1.0.0 // indirect
github.com/opencontainers/image-spec v1.1.1 // indirect
github.com/pelletier/go-toml/v2 v2.3.1 // indirect
github.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 // indirect
github.com/rivo/uniseg v0.4.7 // indirect
github.com/sagikazarmark/locafero v0.12.0 // indirect
github.com/sahilm/fuzzy v0.1.3 // indirect
+ github.com/samber/go-singleflightx v0.3.2 // indirect
github.com/sirupsen/logrus v1.9.4 // indirect
github.com/spf13/afero v1.15.0 // indirect
github.com/spf13/cast v1.10.0 // indirect
@@ -77,11 +87,13 @@ require (
go.opentelemetry.io/otel v1.44.0 // indirect
go.opentelemetry.io/otel/metric v1.44.0 // indirect
go.opentelemetry.io/otel/trace v1.44.0 // indirect
+ go.yaml.in/yaml/v2 v2.4.4 // indirect
go.yaml.in/yaml/v3 v3.0.4 // indirect
go.yaml.in/yaml/v4 v4.0.0-rc.6 // indirect
golang.org/x/exp v0.0.0-20260603202125-055de637280b // indirect
golang.org/x/sync v0.22.0 // indirect
golang.org/x/sys v0.47.0 // indirect
golang.org/x/text v0.40.0 // indirect
+ google.golang.org/protobuf v1.36.12-0.20260120151049-f2248ac996af // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)
diff --git a/cli/go.sum b/cli/go.sum
index 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+UlPJzBSGoP9yx0hBG0
github.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:MYEvvGnQjeNkRF1qUuGolNtNExTDwct51yp7ol
github.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+fH1jivKHWusDYFjMOOKU88ee
github.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+VjbVsjNRFZJZAJ30WjXC5VkNRk
go.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.go
index 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.sum
index 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:SBH7ygxi8pfU
github.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/AaXP
github.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:c3At6R
github.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=