feat: implement auth local cache. (#3533)

* feat: add auth local cache.

* feat: implement auth local cache.

* feat: improve auth localcache.

pkg/common/cmd/auth.go

@@ -40,6 +40,7 @@ func NewAuthRpcCmd() *AuthRpcCmd {
 		config.RedisConfigFileName:      &authConfig.RedisConfig,
 		config.MongodbConfigFileName:    &authConfig.MongoConfig,
 		config.ShareFileName:            &authConfig.Share,
+		config.LocalCacheConfigFileName: &authConfig.LocalCacheConfig,
 		config.DiscoveryConfigFilename:  &authConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))

pkg/common/config/config.go

@@ -43,6 +43,7 @@ type CacheConfig struct {
 }
 
 type LocalCache struct {
+	Auth         CacheConfig `yaml:"auth"`
 	User         CacheConfig `yaml:"user"`
 	Group        CacheConfig `yaml:"group"`
 	Friend       CacheConfig `yaml:"friend"`

pkg/common/convert/auth.go

@@ -0,0 +1,25 @@
+package convert
+
+func TokenMapDB2Pb(tokenMapDB map[string]int) map[string]int32 {
+    if tokenMapDB == nil {
+        return nil
+    }
+    
+    tokenMapPB := make(map[string]int32, len(tokenMapDB))
+    for k, v := range tokenMapDB {
+        tokenMapPB[k] = int32(v)
+    }
+    return tokenMapPB
+}
+
+func TokenMapPb2DB(tokenMapPB map[string]int32) map[string]int {
+    if tokenMapPB == nil {
+        return nil
+    }
+    
+    tokenMapDB := make(map[string]int, len(tokenMapPB))
+    for k, v := range tokenMapPB {
+        tokenMapDB[k] = int(v)
+    }
+    return tokenMapDB
+}

pkg/common/storage/cache/redis/token.go

@@ -2,13 +2,16 @@ package redis
 
 import (
 	"context"
+	"encoding/json"
 	"strconv"
 	"sync"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/redis/go-redis/v9"
 )
@@ -16,16 +19,26 @@ import (
 type tokenCache struct {
 	rdb          redis.UniversalClient
 	accessExpire time.Duration
+	localCache   *config.LocalCache
 }
 
-func NewTokenCacheModel(rdb redis.UniversalClient, accessExpire int64) cache.TokenModel {
-	c := &tokenCache{rdb: rdb}
+func NewTokenCacheModel(rdb redis.UniversalClient, localCache *config.LocalCache, accessExpire int64) cache.TokenModel {
+	c := &tokenCache{rdb: rdb, localCache: localCache}
 	c.accessExpire = c.getExpireTime(accessExpire)
 	return c
 }
 
 func (c *tokenCache) SetTokenFlag(ctx context.Context, userID string, platformID int, token string, flag int) error {
-	return errs.Wrap(c.rdb.HSet(ctx, cachekey.GetTokenKey(userID, platformID), token, flag).Err())
+	key := cachekey.GetTokenKey(userID, platformID)
+	if err := c.rdb.HSet(ctx, key, token, flag).Err(); err != nil {
+		return errs.Wrap(err)
+	}
+
+	if c.localCache != nil {
+		c.removeLocalTokenCache(ctx, key)
+	}
+
+	return nil
 }
 
 // SetTokenFlagEx set token and flag with expire time
@@ -37,6 +50,11 @@ func (c *tokenCache) SetTokenFlagEx(ctx context.Context, userID string, platform
 	if err := c.rdb.Expire(ctx, key, c.accessExpire).Err(); err != nil {
 		return errs.Wrap(err)
 	}
+
+	if c.localCache != nil {
+		c.removeLocalTokenCache(ctx, key)
+	}
+
 	return nil
 }
 
@@ -106,7 +124,17 @@ func (c *tokenCache) SetTokenMapByUidPid(ctx context.Context, userID string, pla
 	for k, v := range m {
 		mm[k] = v
 	}
-	return errs.Wrap(c.rdb.HSet(ctx, cachekey.GetTokenKey(userID, platformID), mm).Err())
+
+	err := c.rdb.HSet(ctx, cachekey.GetTokenKey(userID, platformID), mm).Err()
+	if err != nil {
+		return errs.Wrap(err)
+	}
+
+	if c.localCache != nil {
+		c.removeLocalTokenCache(ctx, cachekey.GetTokenKey(userID, platformID))
+	}
+
+	return nil
 }
 
 func (c *tokenCache) BatchSetTokenMapByUidPid(ctx context.Context, tokens map[string]map[string]any) error {
@@ -124,11 +152,23 @@ func (c *tokenCache) BatchSetTokenMapByUidPid(ctx context.Context, tokens map[st
 	}); err != nil {
 		return err
 	}
+
+	if c.localCache != nil {
+		c.removeLocalTokenCache(ctx, keys...)
+	}
 	return nil
 }
 
 func (c *tokenCache) DeleteTokenByUidPid(ctx context.Context, userID string, platformID int, fields []string) error {
-	return errs.Wrap(c.rdb.HDel(ctx, cachekey.GetTokenKey(userID, platformID), fields...).Err())
+	key := cachekey.GetTokenKey(userID, platformID)
+	if err := c.rdb.HDel(ctx, key, fields...).Err(); err != nil {
+		return errs.Wrap(err)
+	}
+
+	if c.localCache != nil {
+		c.removeLocalTokenCache(ctx, key)
+	}
+	return nil
 }
 
 func (c *tokenCache) getExpireTime(t int64) time.Duration {
@@ -161,6 +201,11 @@ func (c *tokenCache) DeleteTokenByTokenMap(ctx context.Context, userID string, t
 		return err
 	}
 
+	// Remove local cache for the token
+	if c.localCache != nil {
+		c.removeLocalTokenCache(ctx, keys...)
+	}
+
 	return nil
 }
 
@@ -175,5 +220,29 @@ func (c *tokenCache) DeleteAndSetTemporary(ctx context.Context, userID string, p
 	if err := c.rdb.HDel(ctx, key, fields...).Err(); err != nil {
 		return errs.Wrap(err)
 	}
+
+	if c.localCache != nil {
+		c.removeLocalTokenCache(ctx, key)
+	}
 	return nil
 }
+
+func (c *tokenCache) removeLocalTokenCache(ctx context.Context, keys ...string) {
+	if len(keys) == 0 {
+		return
+	}
+
+	topic := c.localCache.Auth.Topic
+	if topic == "" {
+		return
+	}
+
+	data, err := json.Marshal(keys)
+	if err != nil {
+		log.ZWarn(ctx, "keys json marshal failed", err, "topic", topic, "keys", keys)
+	} else {
+		if err := c.rdb.Publish(ctx, topic, string(data)).Err(); err != nil {
+			log.ZWarn(ctx, "redis publish cache delete error", err, "topic", topic, "keys", keys)
+		}
+	}
+}

pkg/common/storage/controller/group.go

@@ -194,7 +194,6 @@ func (g *groupDatabase) CreateGroup(ctx context.Context, groups []*model.Group,
 			}
 			for _, group := range groups {
 				c = c.DelGroupsInfo(group.GroupID).
-					DelGroupMembersHash(group.GroupID).
 					DelGroupMembersHash(group.GroupID).
 					DelGroupsMemberNum(group.GroupID).
 					DelGroupMemberIDs(group.GroupID).