Update CHANGELOG for release v3.8.3-patch.7

CHANGELOG/CHANGELOG-3.8.md

@@ -1,70 +1,12 @@
-## [v3.8.3-patch.6](https://github.com/openimsdk/open-im-server/releases/tag/v3.8.3-patch.6) 	(2025-07-23)
-
-### Bug Fixes
-* fix: Add friend DB in notification sender [#3438](https://github.com/openimsdk/open-im-server/pull/3438)
-* fix: remove update version file workflows have new line in 3.8.3-patch branch. [#3452](https://github.com/openimsdk/open-im-server/pull/3452)
-* fix: s3 aws init [#3454](https://github.com/openimsdk/open-im-server/pull/3454)
-* fix: use safe submodule init in workflows in v3.8.3-patch. [#3469](https://github.com/openimsdk/open-im-server/pull/3469)
-
-**Full Changelog**: [v3.8.3-patch.5...v3.8.3-patch.6](https://github.com/openimsdk/open-im-server/compare/v3.8.3-patch.5...v3.8.3-patch.6)
-
-## [v3.8.3-patch.5](https://github.com/openimsdk/open-im-server/releases/tag/v3.8.3-patch.5) 	(2025-06-10)
+## [v3.8.3-patch.7](https://github.com/openimsdk/open-im-server/releases/tag/v3.8.3-patch.7) 	(2025-07-29)
 
 ### New Features
-* feat: optimize friend and group applications [#3396](https://github.com/openimsdk/open-im-server/pull/3396)
+* feat: add filtering for invalid messages and invalid conversations to… [#3483](https://github.com/openimsdk/open-im-server/pull/3483)
 
 ### Bug Fixes
-* fix: solve unocrrect invite notification [Created [#3219](https://github.com/openimsdk/open-im-server/pull/3219)
+* fix: correctly aggregate read seqs [#3482](https://github.com/openimsdk/open-im-server/pull/3482)
+* fix: import friends send notification in v3.8.3-patch [#3488](https://github.com/openimsdk/open-im-server/pull/3488)
+* fix: solve redis config db field in v3.8.3-patch [#3490](https://github.com/openimsdk/open-im-server/pull/3490)
 
-### Builds
-* build: update gomake version in dockerfile.[Patch branch] [#3416](https://github.com/openimsdk/open-im-server/pull/3416)
+**Full Changelog**: [v3.8.3-patch.6...v3.8.3-patch.7](https://github.com/openimsdk/open-im-server/compare/v3.8.3-patch.6...v3.8.3-patch.7)
 
-**Full Changelog**: [v3.8.3...v3.8.3-patch.5](https://github.com/openimsdk/open-im-server/compare/v3.8.3...v3.8.3-patch.5)
-
-## [v3.8.3-patch.4](https://github.com/openimsdk/open-im-server/releases/tag/v3.8.3-patch.4) 	(2025-03-13)
-
-### Bug Fixes
-* fix: solve unocrrect invite notificationfrom #3213
-
-**Full Changelog**: [v3.8.3-patch.3...v3.8.3-patch.4](https://github.com/openimsdk/open-im-server/compare/v3.8.3-patch.3...v3.8.3-patch.4)
-
-## [v3.8.3-patch.3](https://github.com/openimsdk/open-im-server/releases/tag/v3.8.3-patch.3) 	(2025-03-07)
-
-### New Features
-* feat: optimizing BatchGetIncrementalGroupMember #3180
-
-### Bug Fixes
-* fix: solve uncorrect notification when set group info #3172
-* fix: the sorting is wrong after canceling the administrator in group settings #3185
-* fix: solve uncorrect GroupMember enter group notification type. #3188
-
-### Refactors
-* refactor: change sendNotification to sendMessage to avoid ambiguity regarding message sending behavior. #3173
-
-**Full Changelog**: [v3.8.3-patch.2...v3.8.3-patch.3](https://github.com/openimsdk/open-im-server/compare/v3.8.3-patch.2...v3.8.3-patch.3)
-
-## [v3.8.3-patch.2](https://github.com/openimsdk/open-im-server/releases/tag/v3.8.3-patch.2) 	(2025-02-28)
-
-### Bug Fixes
-* fix: Offline push does not have a badge && Android offline push (#3146) [#3174](https://github.com/openimsdk/open-im-server/pull/3174)
-
-**Full Changelog**: [v3.8.3-patch.1...v3.8.3-patch.2](https://github.com/openimsdk/open-im-server/compare/v3.8.3-patch.1...v3.8.3-patch.2)
-
-## [v3.8.3-patch.1](https://github.com/openimsdk/open-im-server/releases/tag/v3.8.3-patch.1) 	(2025-02-25)
-
-### New Features
-* feat: add backup volume && optimize log print [Created [#3121](https://github.com/openimsdk/open-im-server/pull/3121)
-
-### Bug Fixes
-* fix: seq conversion failed without exiting [Created [#3120](https://github.com/openimsdk/open-im-server/pull/3120)
-* fix: check error in BatchSetTokenMapByUidPid [Created [#3123](https://github.com/openimsdk/open-im-server/pull/3123)
-* fix: DeleteDoc crash [Created [#3124](https://github.com/openimsdk/open-im-server/pull/3124)
-* fix: the abnormal message has no sending time, causing the SDK to be abnormal [Created [#3126](https://github.com/openimsdk/open-im-server/pull/3126)
-* fix: crash caused [#3127](https://github.com/openimsdk/open-im-server/pull/3127)
-* fix: the user sets the conversation timer cleanup timestamp unit incorrectly [Created [#3128](https://github.com/openimsdk/open-im-server/pull/3128)
-* fix: seq conversion not reading env in docker environment [Created [#3131](https://github.com/openimsdk/open-im-server/pull/3131)
-
-### Builds
-* build: improve workflows contents. [Created [#3125](https://github.com/openimsdk/open-im-server/pull/3125)
-
-**Full Changelog**: [v3.8.3-e-v1.1.5...v3.8.3-patch.1-e-v1.1.5](https://github.com/openimsdk/open-im-server-enterprise/compare/v3.8.3-e-v1.1.5...v3.8.3-patch.1-e-v1.1.5)

config/local-cache.yml

@@ -1,10 +1,3 @@
-auth:
-  topic: DELETE_CACHE_AUTH
-  slotNum: 100
-  slotSize: 2000
-  successExpire: 300
-  failedExpire: 5
-
 user:
   topic: DELETE_CACHE_USER
   slotNum: 100

docker-compose.yml

@@ -63,12 +63,7 @@ services:
     restart: always
     sysctls:
       net.core.somaxconn: 1024
-    command: >
-      redis-server
-      --requirepass openIM123
-      --appendonly yes
-      --aof-use-rdb-preamble yes
-      --save ""
+    command: redis-server /usr/local/redis/config/redis.conf --requirepass openIM123 --appendonly yes
     networks:
       - openim
 

go.mod

@@ -8,11 +8,11 @@ require (
 	github.com/gin-gonic/gin v1.9.1
 	github.com/go-playground/validator/v10 v10.20.0
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang-jwt/jwt/v4 v4.5.2
+	github.com/golang-jwt/jwt/v4 v4.5.1
 	github.com/gorilla/websocket v1.5.1
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/openimsdk/protocol v0.0.73-alpha.14
+	github.com/openimsdk/protocol v0.0.73-alpha.12
 	github.com/openimsdk/tools v0.0.50-alpha.97
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.18.0

go.sum

@@ -171,8 +171,8 @@ github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5x
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang-jwt/jwt/v4 v4.4.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
-github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI=
-github.com/golang-jwt/jwt/v4 v4.5.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
+github.com/golang-jwt/jwt/v4 v4.5.1 h1:JdqV9zKUdtaa9gdPlywC3aeoEsR681PlKC+4F5gQgeo=
+github.com/golang-jwt/jwt/v4 v4.5.1/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
@@ -347,8 +347,8 @@ github.com/onsi/gomega v1.25.0 h1:Vw7br2PCDYijJHSfBOWhov+8cAnUf8MfMaIOV323l6Y=
 github.com/onsi/gomega v1.25.0/go.mod h1:r+zV744Re+DiYCIPRlYOTxn0YkOLcAnW8k1xXdMPGhM=
 github.com/openimsdk/gomake v0.0.15-alpha.11 h1:PQudYDRESYeYlUYrrLLJhYIlUPO5x7FAx+o5El9U/Bw=
 github.com/openimsdk/gomake v0.0.15-alpha.11/go.mod h1:PndCozNc2IsQIciyn9mvEblYWZwJmAI+06z94EY+csI=
-github.com/openimsdk/protocol v0.0.73-alpha.14 h1:lv9wNiPRm6G7q74TfpMobKrSfeTaBlZ+Ps3O6UFPmaE=
-github.com/openimsdk/protocol v0.0.73-alpha.14/go.mod h1:WF7EuE55vQvpyUAzDXcqg+B+446xQyEba0X35lTINmw=
+github.com/openimsdk/protocol v0.0.73-alpha.12 h1:2NYawXeHChYUeSme6QJ9pOLh+Empce2WmwEtbP4JvKk=
+github.com/openimsdk/protocol v0.0.73-alpha.12/go.mod h1:WF7EuE55vQvpyUAzDXcqg+B+446xQyEba0X35lTINmw=
 github.com/openimsdk/tools v0.0.50-alpha.97 h1:6ik5w3PpgDG6VjSo3nb3FT/fxN3JX7iIARVxVu9g7VY=
 github.com/openimsdk/tools v0.0.50-alpha.97/go.mod h1:n2poR3asX1e1XZce4O+MOWAp+X02QJRFvhcLCXZdzRo=
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=

internal/api/msg.go

@@ -219,8 +219,6 @@ func (m *MessageApi) getSendMsgReq(c *gin.Context, req apistruct.SendMsg) (sendM
 		data = &apistruct.CustomElem{}
 	case constant.MarkdownText:
 		data = &apistruct.MarkdownTextElem{}
-	case constant.Quote:
-		data = &apistruct.QuoteElem{}
 	case constant.OANotification:
 		data = &apistruct.OANotificationElem{}
 		req.SessionType = constant.NotificationChatType

internal/api/router.go

@@ -97,11 +97,6 @@ func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, cf
 	case BestSpeed:
 		r.Use(gzip.Gzip(gzip.BestSpeed))
 	}
-	if config.Standalone() {
-		r.Use(func(c *gin.Context) {
-			c.Set(authverify.CtxAdminUserIDsKey, cfg.Share.IMAdminUser.UserIDs)
-		})
-	}
 	r.Use(api.GinLogger(), prommetricsGin(), gin.RecoveryWithWriter(gin.DefaultErrorWriter, mw.GinPanicErr), mw.CorsHandler(),
 		mw.GinParseOperationID(), GinParseToken(rpcli.NewAuthClient(authConn)), setGinIsAdmin(cfg.Share.IMAdminUser.UserIDs))
 

internal/rpc/auth/auth.go

@@ -18,13 +18,10 @@ import (
 	"context"
 	"errors"
 
-	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/mcache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
 	"github.com/openimsdk/open-im-server/v3/pkg/dbbuild"
-	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpccache"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
@@ -49,7 +46,6 @@ import (
 type authServer struct {
 	pbauth.UnimplementedAuthServer
 	authDatabase   controller.AuthDatabase
-	AuthLocalCache *rpccache.AuthLocalCache
 	RegisterCenter discovery.Conn
 	config         *Config
 	userClient     *rpcli.UserClient
@@ -57,12 +53,11 @@ type authServer struct {
 }
 
 type Config struct {
-	RpcConfig        config.Auth
-	RedisConfig      config.Redis
-	MongoConfig      config.Mongo
-	Share            config.Share
-	LocalCacheConfig config.LocalCache
-	Discovery        config.Discovery
+	RpcConfig   config.Auth
+	RedisConfig config.Redis
+	MongoConfig config.Mongo
+	Share       config.Share
+	Discovery   config.Discovery
 }
 
 func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server grpc.ServiceRegistrar) error {
@@ -83,19 +78,12 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 		}
 		token = mcache.NewTokenCacheModel(mc, config.RpcConfig.TokenPolicy.Expire)
 	} else {
-		token = redis2.NewTokenCacheModel(rdb, &config.LocalCacheConfig, config.RpcConfig.TokenPolicy.Expire)
+		token = redis2.NewTokenCacheModel(rdb, config.RpcConfig.TokenPolicy.Expire)
 	}
 	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
 	if err != nil {
 		return err
 	}
-	authConn, err := client.GetConn(ctx, config.Discovery.RpcService.Auth)
-	if err != nil {
-		return err
-	}
-
-	localcache.InitLocalCache(&config.LocalCacheConfig)
-
 	pbauth.RegisterAuthServer(server, &authServer{
 		RegisterCenter: client,
 		authDatabase: controller.NewAuthDatabase(
@@ -105,10 +93,9 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 			config.Share.MultiLogin,
 			config.Share.IMAdminUser.UserIDs,
 		),
-		AuthLocalCache: rpccache.NewAuthLocalCache(rpcli.NewAuthClient(authConn), &config.LocalCacheConfig, rdb),
-		config:         config,
-		userClient:     rpcli.NewUserClient(userConn),
-		adminUserIDs:   config.Share.IMAdminUser.UserIDs,
+		config:       config,
+		userClient:   rpcli.NewUserClient(userConn),
+		adminUserIDs: config.Share.IMAdminUser.UserIDs,
 	})
 	return nil
 }
@@ -134,7 +121,6 @@ func (s *authServer) GetAdminToken(ctx context.Context, req *pbauth.GetAdminToke
 	}
 
 	prommetrics.UserLoginCounter.Inc()
-
 	resp.Token = token
 	resp.ExpireTimeSeconds = s.config.RpcConfig.TokenPolicy.Expire * 24 * 60 * 60
 	return &resp, nil
@@ -165,34 +151,20 @@ func (s *authServer) GetUserToken(ctx context.Context, req *pbauth.GetUserTokenR
 	if err != nil {
 		return nil, err
 	}
-
 	resp.Token = token
 	resp.ExpireTimeSeconds = s.config.RpcConfig.TokenPolicy.Expire * 24 * 60 * 60
 	return &resp, nil
 }
 
-func (s *authServer) GetExistingToken(ctx context.Context, req *pbauth.GetExistingTokenReq) (*pbauth.GetExistingTokenResp, error) {
-	m, err := s.authDatabase.GetTokensWithoutError(ctx, req.UserID, int(req.PlatformID))
-	if err != nil {
-		return nil, err
-	}
-
-	return &pbauth.GetExistingTokenResp{
-		TokenStates: convert.TokenMapDB2Pb(m),
-	}, nil
-}
-
 func (s *authServer) parseToken(ctx context.Context, tokensString string) (claims *tokenverify.Claims, err error) {
 	claims, err = tokenverify.GetClaimFromToken(tokensString, authverify.Secret(s.config.Share.Secret))
 	if err != nil {
 		return nil, err
 	}
-
-	m, err := s.AuthLocalCache.GetExistingToken(ctx, claims.UserID, claims.PlatformID)
+	m, err := s.authDatabase.GetTokensWithoutError(ctx, claims.UserID, claims.PlatformID)
 	if err != nil {
 		return nil, err
 	}
-
 	if len(m) == 0 {
 		isAdmin := authverify.CheckUserIsAdmin(ctx, claims.UserID)
 		if isAdmin {

internal/rpc/conversation/conversation.go

@@ -132,7 +132,6 @@ func (c *conversationServer) GetConversation(ctx context.Context, req *pbconvers
 	return resp, nil
 }
 
-// Deprecated: Use `GetConversations` instead.
 func (c *conversationServer) GetSortedConversationList(ctx context.Context, req *pbconversation.GetSortedConversationListReq) (resp *pbconversation.GetSortedConversationListResp, err error) {
 	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
 		return nil, err
@@ -184,21 +183,9 @@ func (c *conversationServer) GetSortedConversationList(ctx context.Context, req
 
 	conversation_isPinTime := make(map[int64]string)
 	conversation_notPinTime := make(map[int64]string)
-
 	for _, v := range conversations {
 		conversationID := v.ConversationID
-		var time int64
-		if _, ok := conversationMsg[conversationID]; ok {
-			time = conversationMsg[conversationID].MsgInfo.LatestMsgRecvTime
-		} else {
-			conversationMsg[conversationID] = &pbconversation.ConversationElem{
-				ConversationID: conversationID,
-				IsPinned:       v.IsPinned,
-				MsgInfo:        nil,
-			}
-			time = v.CreateTime.UnixMilli()
-		}
-
+		time := conversationMsg[conversationID].MsgInfo.LatestMsgRecvTime
 		conversationMsg[conversationID].RecvMsgOpt = v.RecvMsgOpt
 		if v.IsPinned {
 			conversationMsg[conversationID].IsPinned = v.IsPinned

internal/rpc/group/sync.go

@@ -2,7 +2,6 @@ package group
 
 import (
 	"context"
-	"errors"
 
 	"github.com/openimsdk/open-im-server/v3/internal/rpc/incrversion"
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
@@ -12,7 +11,6 @@ import (
 	"github.com/openimsdk/protocol/constant"
 	pbgroup "github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/protocol/sdkws"
-	"github.com/openimsdk/tools/log"
 )
 
 const versionSyncLimit = 500
@@ -172,26 +170,19 @@ func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.
 func (g *groupServer) BatchGetIncrementalGroupMember(ctx context.Context, req *pbgroup.BatchGetIncrementalGroupMemberReq) (*pbgroup.BatchGetIncrementalGroupMemberResp, error) {
 	var num int
 	resp := make(map[string]*pbgroup.GetIncrementalGroupMemberResp)
-
 	for _, memberReq := range req.ReqList {
 		if _, ok := resp[memberReq.GroupID]; ok {
 			continue
 		}
 		memberResp, err := g.GetIncrementalGroupMember(ctx, memberReq)
 		if err != nil {
-			if errors.Is(err, servererrs.ErrDismissedAlready) {
-				log.ZWarn(ctx, "Failed to get incremental group member", err, "groupID", memberReq.GroupID, "request", memberReq)
-				continue
-			}
 			return nil, err
 		}
-
 		resp[memberReq.GroupID] = memberResp
 		num += len(memberResp.Insert) + len(memberResp.Update) + len(memberResp.Delete)
 		if num >= versionSyncLimit {
 			break
 		}
 	}
-
 	return &pbgroup.BatchGetIncrementalGroupMemberResp{RespList: resp}, nil
 }

pkg/common/cmd/auth.go

@@ -40,7 +40,6 @@ 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,7 +43,6 @@ 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

@@ -1,25 +0,0 @@
-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/mcache/msg_cache.go

@@ -24,7 +24,7 @@ var (
 
 func NewMsgCache(cache database.Cache, msgDocDatabase database.Msg) cache.MsgCache {
 	initMemMsgCache.Do(func() {
-		memMsgCache = lru.NewLazyLRU[string, *model.MsgInfoModel](1024*8, time.Hour, time.Second*10, localcache.EmptyTarget{}, nil)
+		memMsgCache = lru.NewLayLRU[string, *model.MsgInfoModel](1024*8, time.Hour, time.Second*10, localcache.EmptyTarget{}, nil)
 	})
 	return &msgCache{
 		cache:          cache,

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

@@ -2,16 +2,13 @@ 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"
 )
@@ -19,26 +16,16 @@ import (
 type tokenCache struct {
 	rdb          redis.UniversalClient
 	accessExpire time.Duration
-	localCache   *config.LocalCache
 }
 
-func NewTokenCacheModel(rdb redis.UniversalClient, localCache *config.LocalCache, accessExpire int64) cache.TokenModel {
-	c := &tokenCache{rdb: rdb, localCache: localCache}
+func NewTokenCacheModel(rdb redis.UniversalClient, accessExpire int64) cache.TokenModel {
+	c := &tokenCache{rdb: rdb}
 	c.accessExpire = c.getExpireTime(accessExpire)
 	return c
 }
 
 func (c *tokenCache) SetTokenFlag(ctx context.Context, userID string, platformID int, token string, flag int) error {
-	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
+	return errs.Wrap(c.rdb.HSet(ctx, cachekey.GetTokenKey(userID, platformID), token, flag).Err())
 }
 
 // SetTokenFlagEx set token and flag with expire time
@@ -50,11 +37,6 @@ 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
 }
 
@@ -124,17 +106,7 @@ func (c *tokenCache) SetTokenMapByUidPid(ctx context.Context, userID string, pla
 	for k, v := range m {
 		mm[k] = v
 	}
-
-	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
+	return errs.Wrap(c.rdb.HSet(ctx, cachekey.GetTokenKey(userID, platformID), mm).Err())
 }
 
 func (c *tokenCache) BatchSetTokenMapByUidPid(ctx context.Context, tokens map[string]map[string]any) error {
@@ -152,23 +124,11 @@ 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 {
-	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
+	return errs.Wrap(c.rdb.HDel(ctx, cachekey.GetTokenKey(userID, platformID), fields...).Err())
 }
 
 func (c *tokenCache) getExpireTime(t int64) time.Duration {
@@ -201,48 +161,20 @@ 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
 }
 
 func (c *tokenCache) DeleteAndSetTemporary(ctx context.Context, userID string, platformID int, fields []string) error {
+	key := cachekey.GetTokenKey(userID, platformID)
+	if err := c.rdb.HDel(ctx, key, fields...).Err(); err != nil {
+		return errs.Wrap(err)
+	}
 	for _, f := range fields {
 		k := cachekey.GetTemporaryTokenKey(userID, platformID, f)
 		if err := c.rdb.Set(ctx, k, "", time.Minute*5).Err(); err != nil {
 			return errs.Wrap(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) 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,6 +194,7 @@ 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).

pkg/common/storage/database/mgo/msg.go

@@ -5,11 +5,6 @@ import (
 	"fmt"
 	"time"
 
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/protocol/constant"
@@ -19,6 +14,10 @@ import (
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/openimsdk/tools/utils/jsonutil"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
 func NewMsgMongo(db *mongo.Database) (database.Msg, error) {
@@ -1155,7 +1154,7 @@ func (m *MsgMgo) findBeforeDocSendTime(ctx context.Context, docID string, limit
 	if err != nil {
 		return 0, 0, err
 	}
-	for i := len(res) - 1; i >= 0; i-- {
+	for i := len(res) - 1; i > 0; i-- {
 		v := res[i]
 		if v.Msgs != nil && v.Msgs.Msg != nil && v.Msgs.Msg.SendTime > 0 {
 			return v.Msgs.Msg.Seq, v.Msgs.Msg.SendTime, nil
@@ -1170,7 +1169,7 @@ func (m *MsgMgo) findBeforeSendTime(ctx context.Context, conversationID string,
 		limit := int64(-1)
 		if first {
 			first = false
-			limit = m.model.GetLimitForSingleDoc(seq)
+			limit = m.model.GetMsgIndex(seq)
 		}
 		docID := m.model.BuildDocIDByIndex(conversationID, i)
 		msgSeq, msgSendTime, err := m.findBeforeDocSendTime(ctx, docID, limit)

pkg/common/storage/model/msg.go

@@ -132,10 +132,6 @@ func (*MsgDocModel) GetMsgIndex(seq int64) int64 {
 	return (seq - 1) % singleGocMsgNum
 }
 
-func (*MsgDocModel) GetLimitForSingleDoc(seq int64) int64 {
-	return seq % singleGocMsgNum
-}
-
 func (*MsgDocModel) indexGen(conversationID string, seqSuffix int64) string {
 	return conversationID + ":" + strconv.FormatInt(seqSuffix, 10)
 }

pkg/localcache/cache.go

@@ -47,15 +47,15 @@ func New[V any](opts ...Option) Cache[V] {
 	if opt.localSlotNum > 0 && opt.localSlotSize > 0 {
 		createSimpleLRU := func() lru.LRU[string, V] {
 			if opt.expirationEvict {
-				return lru.NewExpirationLRU(opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
+				return lru.NewExpirationLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
 			} else {
-				return lru.NewLazyLRU(opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
+				return lru.NewLayLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
 			}
 		}
 		if opt.localSlotNum == 1 {
 			c.local = createSimpleLRU()
 		} else {
-			c.local = lru.NewSlotLRU(opt.localSlotNum, LRUStringHash, createSimpleLRU)
+			c.local = lru.NewSlotLRU[string, V](opt.localSlotNum, LRUStringHash, createSimpleLRU)
 		}
 		if opt.linkSlotNum > 0 {
 			c.link = link.New(opt.linkSlotNum)
@@ -71,8 +71,6 @@ type cache[V any] struct {
 }
 
 func (c *cache[V]) onEvict(key string, value V) {
-	_ = value
-
 	if c.link != nil {
 		lks := c.link.Del(key)
 		for k := range lks {

pkg/localcache/init.go

@@ -15,11 +15,10 @@
 package localcache
 
 import (
-	"strings"
-	"sync"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
+	"strings"
+	"sync"
 )
 
 var (
@@ -33,10 +32,6 @@ func InitLocalCache(localCache *config.LocalCache) {
 			Local config.CacheConfig
 			Keys  []string
 		}{
-			{
-				Local: localCache.Auth,
-				Keys:  []string{cachekey.UidPidToken},
-			},
 			{
 				Local: localCache.User,
 				Keys:  []string{cachekey.UserInfoKey, cachekey.UserGlobalRecvMsgOptKey},

pkg/localcache/lru/lru_lazy.go

@@ -21,25 +21,25 @@ import (
 	"github.com/hashicorp/golang-lru/v2/simplelru"
 )
 
-type lazyLruItem[V any] struct {
+type layLruItem[V any] struct {
 	lock    sync.Mutex
 	expires int64
 	err     error
 	value   V
 }
 
-func NewLazyLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) *LazyLRU[K, V] {
-	var cb simplelru.EvictCallback[K, *lazyLruItem[V]]
+func NewLayLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) *LayLRU[K, V] {
+	var cb simplelru.EvictCallback[K, *layLruItem[V]]
 	if onEvict != nil {
-		cb = func(key K, value *lazyLruItem[V]) {
+		cb = func(key K, value *layLruItem[V]) {
 			onEvict(key, value.value)
 		}
 	}
-	core, err := simplelru.NewLRU[K, *lazyLruItem[V]](size, cb)
+	core, err := simplelru.NewLRU[K, *layLruItem[V]](size, cb)
 	if err != nil {
 		panic(err)
 	}
-	return &LazyLRU[K, V]{
+	return &LayLRU[K, V]{
 		core:       core,
 		successTTL: successTTL,
 		failedTTL:  failedTTL,
@@ -47,15 +47,15 @@ func NewLazyLRU[K comparable, V any](size int, successTTL, failedTTL time.Durati
 	}
 }
 
-type LazyLRU[K comparable, V any] struct {
+type LayLRU[K comparable, V any] struct {
 	lock       sync.Mutex
-	core       *simplelru.LRU[K, *lazyLruItem[V]]
+	core       *simplelru.LRU[K, *layLruItem[V]]
 	successTTL time.Duration
 	failedTTL  time.Duration
 	target     Target
 }
 
-func (x *LazyLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
+func (x *LayLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
 	x.lock.Lock()
 	v, ok := x.core.Get(key)
 	if ok {
@@ -68,7 +68,7 @@ func (x *LazyLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
 			return value, err
 		}
 	} else {
-		v = &lazyLruItem[V]{}
+		v = &layLruItem[V]{}
 		x.core.Add(key, v)
 		v.lock.Lock()
 		x.lock.Unlock()
@@ -88,15 +88,15 @@ func (x *LazyLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
 	return v.value, v.err
 }
 
-func (x *LazyLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
+func (x *LayLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
 	var (
 		err  error
 		once sync.Once
 	)
 
 	res := make(map[K]V)
-	queries := make([]K, 0, len(keys))
-
+	queries := make([]K, 0)
+	setVs := make(map[K]*layLruItem[V])
 	for _, key := range keys {
 		x.lock.Lock()
 		v, ok := x.core.Get(key)
@@ -118,20 +118,14 @@ func (x *LazyLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)
 		}
 		queries = append(queries, key)
 	}
-
-	if len(queries) == 0 {
-		return res, err
-	}
-
-	values, fetchErr := fetch(queries)
-	if fetchErr != nil {
+	values, err1 := fetch(queries)
+	if err1 != nil {
 		once.Do(func() {
-			err = fetchErr
+			err = err1
 		})
 	}
-
 	for key, val := range values {
-		v := &lazyLruItem[V]{}
+		v := &layLruItem[V]{}
 		v.value = val
 
 		if err == nil {
@@ -141,7 +135,7 @@ func (x *LazyLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)
 			v.expires = time.Now().Add(x.failedTTL).UnixMilli()
 			x.target.IncrGetFailed()
 		}
-
+		setVs[key] = v
 		x.lock.Lock()
 		x.core.Add(key, v)
 		x.lock.Unlock()
@@ -151,29 +145,29 @@ func (x *LazyLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)
 	return res, err
 }
 
-//func (x *LazyLRU[K, V]) Has(key K) bool {
+//func (x *LayLRU[K, V]) Has(key K) bool {
 //	x.lock.Lock()
 //	defer x.lock.Unlock()
 //	return x.core.Contains(key)
 //}
 
-func (x *LazyLRU[K, V]) Set(key K, value V) {
+func (x *LayLRU[K, V]) Set(key K, value V) {
 	x.lock.Lock()
 	defer x.lock.Unlock()
-	x.core.Add(key, &lazyLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
+	x.core.Add(key, &layLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
 }
 
-func (x *LazyLRU[K, V]) SetHas(key K, value V) bool {
+func (x *LayLRU[K, V]) SetHas(key K, value V) bool {
 	x.lock.Lock()
 	defer x.lock.Unlock()
 	if x.core.Contains(key) {
-		x.core.Add(key, &lazyLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
+		x.core.Add(key, &layLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
 		return true
 	}
 	return false
 }
 
-func (x *LazyLRU[K, V]) Del(key K) bool {
+func (x *LayLRU[K, V]) Del(key K) bool {
 	x.lock.Lock()
 	ok := x.core.Remove(key)
 	x.lock.Unlock()
@@ -185,6 +179,6 @@ func (x *LazyLRU[K, V]) Del(key K) bool {
 	return ok
 }
 
-func (x *LazyLRU[K, V]) Stop() {
+func (x *LayLRU[K, V]) Stop() {
 
 }

pkg/localcache/lru/lru_slot.go

@@ -35,7 +35,7 @@ type slotLRU[K comparable, V any] struct {
 func (x *slotLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
 	var (
 		slotKeys = make(map[uint64][]K)
-		kVs       = make(map[K]V)
+		vs       = make(map[K]V)
 	)
 
 	for _, k := range keys {
@@ -49,10 +49,10 @@ func (x *slotLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)
 			return nil, err
 		}
 		for key, value := range batches {
-			kVs[key] = value
+			vs[key] = value
 		}
 	}
-	return kVs, nil
+	return vs, nil
 }
 
 func (x *slotLRU[K, V]) getIndex(k K) uint64 {

pkg/rpccache/auth.go

@@ -1,69 +0,0 @@
-package rpccache
-
-import (
-	"context"
-	"time"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
-	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
-	"github.com/openimsdk/protocol/auth"
-	"github.com/openimsdk/tools/log"
-	"github.com/redis/go-redis/v9"
-)
-
-func NewAuthLocalCache(client *rpcli.AuthClient, localCache *config.LocalCache, cli redis.UniversalClient) *AuthLocalCache {
-	lc := localCache.Auth
-	log.ZDebug(context.Background(), "AuthLocalCache", "topic", lc.Topic, "slotNum", lc.SlotNum, "slotSize", lc.SlotSize, "enable", lc.Enable())
-	x := &AuthLocalCache{
-		client: client,
-		local: localcache.New[[]byte](
-			localcache.WithLocalSlotNum(lc.SlotNum),
-			localcache.WithLocalSlotSize(lc.SlotSize),
-			localcache.WithLinkSlotNum(lc.SlotNum),
-			localcache.WithLocalSuccessTTL(lc.Success()),
-			localcache.WithLocalFailedTTL(lc.Failed()),
-		),
-	}
-	if lc.Enable() {
-		go subscriberRedisDeleteCache(context.Background(), cli, lc.Topic, x.local.DelLocal)
-	}
-	return x
-}
-
-type AuthLocalCache struct {
-	client *rpcli.AuthClient
-	local  localcache.Cache[[]byte]
-}
-
-func (a *AuthLocalCache) GetExistingToken(ctx context.Context, userID string, platformID int) (val map[string]int, err error) {
-	resp, err := a.getExistingToken(ctx, userID, platformID)
-	if err != nil {
-		return nil, err
-	}
-
-	res := convert.TokenMapPb2DB(resp.TokenStates)
-
-	return res, nil
-}
-
-func (a *AuthLocalCache) getExistingToken(ctx context.Context, userID string, platformID int) (val *auth.GetExistingTokenResp, err error) {
-	start := time.Now()
-	log.ZDebug(ctx, "AuthLocalCache GetExistingToken req", "userID", userID, "platformID", platformID)
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, "AuthLocalCache GetExistingToken error", err, "cost", time.Since(start), "userID", userID, "platformID", platformID)
-		} else {
-			log.ZDebug(ctx, "AuthLocalCache GetExistingToken resp", "cost", time.Since(start), "userID", userID, "platformID", platformID, "val", val)
-		}
-	}()
-
-	var cache cacheProto[auth.GetExistingTokenResp]
-
-	return cache.Unmarshal(a.local.Get(ctx, cachekey.GetTokenKey(userID, platformID), func(ctx context.Context) ([]byte, error) {
-		log.ZDebug(ctx, "AuthLocalCache GetExistingToken call rpc", "userID", userID, "platformID", platformID)
-		return cache.Marshal(a.client.AuthClient.GetExistingToken(ctx, &auth.GetExistingTokenReq{UserID: userID, PlatformID: int32(platformID)}))
-	}))
-}

pkg/rpccache/online.go

@@ -64,7 +64,7 @@ func NewOnlineCache(client *rpcli.UserClient, group *GroupLocalCache, rdb redis.
 	case false:
 		log.ZDebug(ctx, "fullUserCache is false")
 		x.lruCache = lru.NewSlotLRU(1024, localcache.LRUStringHash, func() lru.LRU[string, []int32] {
-			return lru.NewLazyLRU[string, []int32](2048, cachekey.OnlineExpire/2, time.Second*3, localcache.EmptyTarget{}, func(key string, value []int32) {})
+			return lru.NewLayLRU[string, []int32](2048, cachekey.OnlineExpire/2, time.Second*3, localcache.EmptyTarget{}, func(key string, value []int32) {})
 		})
 		x.CurrentPhase.Store(DoSubscribeOver)
 		x.Cond.Broadcast()