extern/netbird
1
0
Fork 0
mirror of https://github.com/netbirdio/netbird.git synced 2025-06-20 09:47:49 +02:00
Code Issues Packages Projects Releases Wiki Activity

[management] add log when using redis cache (#3562)

Browse Source
This commit is contained in:
Pascal Fischer 2025-03-21 18:16:27 +01:00 committed by GitHub
parent b62a1b56ce
commit f081435a56
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 15 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
management/server/account.go
View File

@ -198,7 +198,7 @@ func BuildManager(
log.WithContext(ctx).Infof("single account mode disabled, accounts number %d", accountsCounter) log.WithContext(ctx).Infof("single account mode disabled, accounts number %d", accountsCounter)
} }
cacheStore, err := nbcache.NewStore(nbcache.DefaultIDPCacheExpirationMax, nbcache.DefaultIDPCacheCleanupInterval) cacheStore, err := nbcache.NewStore(ctx, nbcache.DefaultIDPCacheExpirationMax, nbcache.DefaultIDPCacheCleanupInterval)
if err != nil { if err != nil {
return nil, fmt.Errorf("getting cache store: %s", err) return nil, fmt.Errorf("getting cache store: %s", err)
} }

2
management/server/cache/idp_test.go vendored
View File

@ -44,7 +44,7 @@ func TestNewIDPCacheManagers(t *testing.T) {
t.Setenv(cache.RedisStoreEnvVar, redisURL) t.Setenv(cache.RedisStoreEnvVar, redisURL)
} }
cacheStore, err := cache.NewStore(cache.DefaultIDPCacheExpirationMax, cache.DefaultIDPCacheCleanupInterval) cacheStore, err := cache.NewStore(context.Background(), cache.DefaultIDPCacheExpirationMax, cache.DefaultIDPCacheCleanupInterval)
if err != nil { if err != nil {
t.Fatalf("couldn't create cache store: %s", err) t.Fatalf("couldn't create cache store: %s", err)
} }

13
management/server/cache/store.go vendored
View File

@ -11,6 +11,7 @@ import (
redis_store "github.com/eko/gocache/store/redis/v4" redis_store "github.com/eko/gocache/store/redis/v4"
gocache "github.com/patrickmn/go-cache" gocache "github.com/patrickmn/go-cache"
"github.com/redis/go-redis/v9" "github.com/redis/go-redis/v9"
log "github.com/sirupsen/logrus"
) )
// RedisStoreEnvVar is the environment variable that determines if a redis store should be used. // RedisStoreEnvVar is the environment variable that determines if a redis store should be used.
@ -19,16 +20,16 @@ const RedisStoreEnvVar = "NB_IDP_CACHE_REDIS_ADDRESS"
// NewStore creates a new cache store with the given max timeout and cleanup interval. It checks for the environment Variable RedisStoreEnvVar // NewStore creates a new cache store with the given max timeout and cleanup interval. It checks for the environment Variable RedisStoreEnvVar
// to determine if a redis store should be used. If the environment variable is set, it will attempt to connect to the redis store. // to determine if a redis store should be used. If the environment variable is set, it will attempt to connect to the redis store.
func NewStore(maxTimeout, cleanupInterval time.Duration) (store.StoreInterface, error) { func NewStore(ctx context.Context, maxTimeout, cleanupInterval time.Duration) (store.StoreInterface, error) {
redisAddr := os.Getenv(RedisStoreEnvVar) redisAddr := os.Getenv(RedisStoreEnvVar)
if redisAddr != "" { if redisAddr != "" {
return getRedisStore(redisAddr) return getRedisStore(ctx, redisAddr)
} }
goc := gocache.New(maxTimeout, cleanupInterval) goc := gocache.New(maxTimeout, cleanupInterval)
return gocache_store.NewGoCache(goc), nil return gocache_store.NewGoCache(goc), nil
} }
func getRedisStore(redisEnvAddr string) (store.StoreInterface, error) { func getRedisStore(ctx context.Context, redisEnvAddr string) (store.StoreInterface, error) {
options, err := redis.ParseURL(redisEnvAddr) options, err := redis.ParseURL(redisEnvAddr)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing redis cache url: %s", err) return nil, fmt.Errorf("parsing redis cache url: %s", err)
@ -38,13 +39,15 @@ func getRedisStore(redisEnvAddr string) (store.StoreInterface, error) {
options.MinIdleConns = 3 options.MinIdleConns = 3
options.MaxActiveConns = 100 options.MaxActiveConns = 100
redisClient := redis.NewClient(options) redisClient := redis.NewClient(options)
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) subCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel() defer cancel()
_, err = redisClient.Ping(ctx).Result() _, err = redisClient.Ping(subCtx).Result()
if err != nil { if err != nil {
return nil, err return nil, err
} }
log.WithContext(subCtx).Infof("using redis cache at %s", redisEnvAddr)
return redis_store.NewRedis(redisClient), nil return redis_store.NewRedis(redisClient), nil
} }

6
management/server/cache/store_test.go vendored
View File

@ -15,7 +15,7 @@ import (
) )
func TestMemoryStore(t *testing.T) { func TestMemoryStore(t *testing.T) {
memStore, err := cache.NewStore(100*time.Millisecond, 300*time.Millisecond) memStore, err := cache.NewStore(context.Background(), 100*time.Millisecond, 300*time.Millisecond)
if err != nil { if err != nil {
t.Fatalf("couldn't create memory store: %s", err) t.Fatalf("couldn't create memory store: %s", err)
} }
@ -42,7 +42,7 @@ func TestMemoryStore(t *testing.T) {
func TestRedisStoreConnectionFailure(t *testing.T) { func TestRedisStoreConnectionFailure(t *testing.T) {
t.Setenv(cache.RedisStoreEnvVar, "redis://127.0.0.1:6379") t.Setenv(cache.RedisStoreEnvVar, "redis://127.0.0.1:6379")
_, err := cache.NewStore(10*time.Millisecond, 30*time.Millisecond) _, err := cache.NewStore(context.Background(), 10*time.Millisecond, 30*time.Millisecond)
if err == nil { if err == nil {
t.Fatal("getting redis cache store should return error") t.Fatal("getting redis cache store should return error")
} }
@ -65,7 +65,7 @@ func TestRedisStoreConnectionSuccess(t *testing.T) {
} }
t.Setenv(cache.RedisStoreEnvVar, redisURL) t.Setenv(cache.RedisStoreEnvVar, redisURL)
redisStore, err := cache.NewStore(100*time.Millisecond, 300*time.Millisecond) redisStore, err := cache.NewStore(context.Background(), 100*time.Millisecond, 300*time.Millisecond)
if err != nil { if err != nil {
t.Fatalf("couldn't create redis store: %s", err) t.Fatalf("couldn't create redis store: %s", err)
} }

4
management/server/user_test.go
View File

@ -516,7 +516,7 @@ func TestUser_InviteNewUser(t *testing.T) {
cacheLoading: map[string]chan struct{}{}, cacheLoading: map[string]chan struct{}{},
} }
cs, err := nbcache.NewStore(nbcache.DefaultIDPCacheExpirationMax, nbcache.DefaultIDPCacheCleanupInterval) cs, err := nbcache.NewStore(context.Background(), nbcache.DefaultIDPCacheExpirationMax, nbcache.DefaultIDPCacheCleanupInterval)
require.NoError(t, err) require.NoError(t, err)
am.cacheManager = nbcache.NewAccountUserDataCache(am.loadAccount, cs) am.cacheManager = nbcache.NewAccountUserDataCache(am.loadAccount, cs)
@ -1094,7 +1094,7 @@ func TestDefaultAccountManager_ExternalCache(t *testing.T) {
cacheLoading: map[string]chan struct{}{}, cacheLoading: map[string]chan struct{}{},
} }
cacheStore, err := nbcache.NewStore(nbcache.DefaultIDPCacheExpirationMax, nbcache.DefaultIDPCacheCleanupInterval) cacheStore, err := nbcache.NewStore(context.Background(), nbcache.DefaultIDPCacheExpirationMax, nbcache.DefaultIDPCacheCleanupInterval)
assert.NoError(t, err) assert.NoError(t, err)
am.externalCacheManager = nbcache.NewUserDataCache(cacheStore) am.externalCacheManager = nbcache.NewUserDataCache(cacheStore)
am.cacheManager = nbcache.NewAccountUserDataCache(am.loadAccount, cacheStore) am.cacheManager = nbcache.NewAccountUserDataCache(am.loadAccount, cacheStore)