Fix: Refactor Redis counters and context usage

Refactor Redis read/write counters to unify logic and eliminate redundant increments. Additionally, modify Redis functions to use context consistently, enhancing maintainability and context management across the codebase.

Signed-off-by: Christian Roessner <[email protected]>

Author: Christian Roessner

server/backend/cache.go

@@ -26,6 +26,7 @@ import (
 	"github.com/croessner/nauthilus/server/global"
 	"github.com/croessner/nauthilus/server/log"
 	"github.com/croessner/nauthilus/server/rediscli"
+	"github.com/croessner/nauthilus/server/stats"
 	"github.com/croessner/nauthilus/server/util"
 	"github.com/go-kit/log/level"
 	"github.com/redis/go-redis/v9"
@@ -61,6 +62,8 @@ type RedisCache interface {
 func LookupUserAccountFromRedis(ctx context.Context, username string) (accountName string, err error) {
 	key := config.LoadableConfig.Server.Redis.Prefix + global.RedisUserHashKey
 
+	defer stats.RedisReadCounter.Inc()
+
 	accountName, err = rediscli.ReadHandle.HGet(ctx, key, username).Result()
 	if err != nil {
 		if !errors.Is(err, redis.Nil) {
@@ -81,6 +84,8 @@ func LookupUserAccountFromRedis(ctx context.Context, username string) (accountNa
 func LoadCacheFromRedis[T RedisCache](ctx context.Context, key string, cache **T) (isRedisErr bool, err error) {
 	var redisValue []byte
 
+	defer stats.RedisReadCounter.Inc()
+
 	if redisValue, err = rediscli.ReadHandle.Get(ctx, key).Bytes(); err != nil {
 		if errors.Is(err, redis.Nil) {
 			return true, nil
@@ -108,7 +113,7 @@ func LoadCacheFromRedis[T RedisCache](ctx context.Context, key string, cache **T
 
 // SaveUserDataToRedis is a generic routine to store a cache object on Redis. The type is a RedisCache, which is a
 // union.
-func SaveUserDataToRedis[T RedisCache](ctx context.Context, guid string, key string, ttl uint, cache *T) error {
+func SaveUserDataToRedis[T RedisCache](ctx context.Context, guid string, key string, ttl uint, cache *T) {
 	var result string
 
 	util.DebugModule(
@@ -124,9 +129,11 @@ func SaveUserDataToRedis[T RedisCache](ctx context.Context, guid string, key str
 			global.LogKeyMsg, err,
 		)
 
-		return err
+		return
 	}
 
+	defer stats.RedisWriteCounter.Inc()
+
 	//nolint:lll // Ignore
 	if result, err = rediscli.WriteHandle.Set(ctx, key, redisValue, time.Duration(ttl)*time.Second).Result(); err != nil {
 		level.Error(log.Logger).Log(
@@ -140,7 +147,7 @@ func SaveUserDataToRedis[T RedisCache](ctx context.Context, guid string, key str
 		global.LogKeyGUID, guid,
 		"redis", result)
 
-	return err
+	return
 }
 
 // GetCacheNames returns the set of cache names for the requested protocol and cache backends.
@@ -207,6 +214,8 @@ func GetWebAuthnFromRedis(ctx context.Context, uniqueUserId string) (user *User,
 
 	key := "as_webauthn:user:" + uniqueUserId
 
+	defer stats.RedisReadCounter.Inc()
+
 	if redisValue, err = rediscli.ReadHandle.Get(ctx, key).Bytes(); err != nil {
 		level.Error(log.Logger).Log(global.LogKeyMsg, err)
 
@@ -241,6 +250,8 @@ func SaveWebAuthnToRedis(ctx context.Context, user *User, ttl uint) error {
 
 	key := "as_webauthn:user:" + user.Id
 
+	defer stats.RedisWriteCounter.Inc()
+
 	//nolint:lll // Ignore
 	if result, err = rediscli.WriteHandle.Set(ctx, key, redisValue, time.Duration(ttl)*time.Second).Result(); err != nil {
 		level.Error(log.Logger).Log(global.LogKeyMsg, err)

server/core/auth.go

@@ -17,6 +17,7 @@ package core
 
 import (
 	"bytes"
+	"context"
 	"encoding/base64"
 	stderrors "errors"
 	"fmt"
@@ -1116,6 +1117,43 @@ func (a *AuthState) setStatusCodes(service string) error {
 	return nil
 }
 
+// getUserAccountFromCache fetches the user account name from Redis cache using the provided username.
+// Logs errors and increments Redis read counter. Returns an empty string if the account name is not found or an error occurs.
+func getUserAccountFromCache(ctx context.Context, username string, guid string) (accountName string) {
+	var err error
+
+	accountName, err = backend.LookupUserAccountFromRedis(ctx, username)
+	if err != nil || accountName == "" {
+		if err != nil {
+			level.Error(log.Logger).Log(global.LogKeyGUID, guid, global.LogKeyMsg, err)
+		}
+
+		return ""
+	}
+
+	return accountName
+}
+
+// refreshUserAccount updates the user account information from the cache.
+// It sets the account field and attributes if they are nil and the account name is found.
+func (a *AuthState) refreshUserAccount() (accountName string) {
+	accountName = getUserAccountFromCache(a.HTTPClientContext, a.Username, *a.GUID)
+	if accountName == "" {
+		return
+	}
+
+	if a.AccountField == nil && a.Attributes == nil {
+		accountField := global.MetaUserAccount
+		attributes := make(backend.DatabaseResult)
+
+		a.AccountField = &accountField
+		attributes[global.MetaUserAccount] = []any{accountName}
+		a.Attributes = attributes
+	}
+
+	return
+}
+
 // handleFeatures iterates through the list of enabled features and returns true, if a feature returned positive.
 func (a *AuthState) handleFeatures(ctx *gin.Context) (authResult global.AuthResult) {
 	// Helper function that sends an action request and waits for it to be finished. Features may change the Lua context.
@@ -1571,11 +1609,7 @@ func (a *AuthState) postVerificationProcesses(ctx *gin.Context, useCache bool, b
 							Attributes: a.Attributes,
 						}
 
-						go func() {
-							if err := backend.SaveUserDataToRedis(a.HTTPClientContext, *a.GUID, redisUserKey, config.LoadableConfig.Server.Redis.PosCacheTTL, ppc); err == nil {
-								stats.RedisWriteCounter.Inc()
-							}
-						}()
+						go backend.SaveUserDataToRedis(a.HTTPClientContext, *a.GUID, redisUserKey, config.LoadableConfig.Server.Redis.PosCacheTTL, ppc)
 					}
 				}
 			}
@@ -1843,10 +1877,9 @@ func (a *AuthState) updateUserAccountInRedis() (accountName string, err error) {
 
 		accountName = strings.Join(accounts, ":")
 
+		defer stats.RedisWriteCounter.Inc()
+
 		err = rediscli.WriteHandle.HSet(a.HTTPClientContext, key, a.Username, accountName).Err()
-		if err == nil {
-			stats.RedisWriteCounter.Inc()
-		}
 	}
 
 	return