refactor: db cache batch refactor and batch consume message. (#2325)

* refactor: cmd update.

* refactor: msg transfer refactor.

* refactor: msg transfer refactor.

* refactor: msg transfer refactor.

* fix: read prometheus port when flag set to enable and prevent failure during startup.

* fix: notification has counted unread counts bug fix.

* fix: merge opensource code into local.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* refactor: delete message and message batch use lua.

* fix: add protective measures against memory overflow.

pkg/common/storage/cache/cachekey/msg.go

@@ -31,10 +31,6 @@ const (
 	reactionNotification = "EX_NOTIFICATION_"
 )
 
-func GetAllMessageCacheKey(conversationID string) string {
-	return messageCache + conversationID + "_*"
-}
-
 func GetMessageCacheKey(conversationID string, seq int64) string {
 	return messageCache + conversationID + "_" + strconv.Itoa(int(seq))
 }

pkg/common/storage/cache/conversation.go

@@ -52,9 +52,6 @@ type ConversationCache interface {
 	// GetUserAllHasReadSeqs(ctx context.Context, ownerUserID string) (map[string]int64, error)
 	DelUserAllHasReadSeqs(ownerUserID string, conversationIDs ...string) ConversationCache
 
-	GetConversationsByConversationID(ctx context.Context,
-		conversationIDs []string) ([]*relationtb.Conversation, error)
-	DelConversationByConversationID(conversationIDs ...string) ConversationCache
 	GetConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) ([]string, error)
 	DelConversationNotReceiveMessageUserIDs(conversationIDs ...string) ConversationCache
 }

pkg/common/storage/cache/msg.go

@@ -23,13 +23,8 @@ import (
 
 type MsgCache interface {
 	GetMessagesBySeq(ctx context.Context, conversationID string, seqs []int64) (seqMsg []*sdkws.MsgData, failedSeqList []int64, err error)
-	SetMessageToCache(ctx context.Context, conversationID string, msgs []*sdkws.MsgData) (int, error)
-	UserDeleteMsgs(ctx context.Context, conversationID string, seqs []int64, userID string) error
-	DelUserDeleteMsgsList(ctx context.Context, conversationID string, seqs []int64)
-	DeleteMessages(ctx context.Context, conversationID string, seqs []int64) error
-	GetUserDelList(ctx context.Context, userID, conversationID string) (seqs []int64, err error)
-	CleanUpOneConversationAllMsg(ctx context.Context, conversationID string) error
-	DelMsgFromCache(ctx context.Context, userID string, seqList []int64) error
+	SetMessagesToCache(ctx context.Context, conversationID string, msgs []*sdkws.MsgData) (int, error)
+	DeleteMessagesFromCache(ctx context.Context, conversationID string, seqs []int64) error
 	SetSendMsgStatus(ctx context.Context, id string, status int32) error
 	GetSendMsgStatus(ctx context.Context, id string) (int32, error)
 	JudgeMessageReactionExist(ctx context.Context, clientMsgID string, sessionType int32) (bool, error)

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

@@ -62,17 +62,13 @@ func (c *BatchDeleterRedis) ChainExecDel(ctx context.Context) error {
 func (c *BatchDeleterRedis) execDel(ctx context.Context, keys []string) error {
 	if len(keys) > 0 {
 		log.ZDebug(ctx, "delete cache", "topic", c.redisPubTopics, "keys", keys)
-		slotMapKeys, err := groupKeysBySlot(ctx, c.redisClient, keys)
+		// Batch delete keys
+		err := ProcessKeysBySlot(ctx, c.redisClient, keys, func(ctx context.Context, slot int64, keys []string) error {
+			return c.rocksClient.TagAsDeletedBatch2(ctx, keys)
+		})
 		if err != nil {
 			return err
 		}
-		// Batch delete keys
-		for slot, singleSlotKeys := range slotMapKeys {
-			if err := c.rocksClient.TagAsDeletedBatch2(ctx, singleSlotKeys); err != nil {
-				log.ZWarn(ctx, "Batch delete cache failed", err, "slot", slot, "keys", singleSlotKeys)
-				continue
-			}
-		}
 		// Publish the keys that have been deleted to Redis to update the local cache information of other nodes
 		if len(c.redisPubTopics) > 0 && len(keys) > 0 {
 			keysByTopic := localcache.GetPublishKeysByTopic(c.redisPubTopics, keys)
@@ -117,37 +113,6 @@ func GetRocksCacheOptions() *rockscache.Options {
 	return &opts
 }
 
-// groupKeysBySlot groups keys by their Redis cluster hash slots.
-func groupKeysBySlot(ctx context.Context, redisClient redis.UniversalClient, keys []string) (map[int64][]string, error) {
-	slots := make(map[int64][]string)
-	clusterClient, isCluster := redisClient.(*redis.ClusterClient)
-	if isCluster {
-		pipe := clusterClient.Pipeline()
-		cmds := make([]*redis.IntCmd, len(keys))
-		for i, key := range keys {
-			cmds[i] = pipe.ClusterKeySlot(ctx, key)
-		}
-		_, err := pipe.Exec(ctx)
-		if err != nil {
-			return nil, errs.WrapMsg(err, "get slot err")
-		}
-
-		for i, cmd := range cmds {
-			slot, err := cmd.Result()
-			if err != nil {
-				log.ZWarn(ctx, "some key get slot err", err, "key", keys[i])
-				continue
-			}
-			slots[slot] = append(slots[slot], keys[i])
-		}
-	} else {
-		// If not a cluster client, put all keys in the same slot (0)
-		slots[0] = keys
-	}
-
-	return slots, nil
-}
-
 func getCache[T any](ctx context.Context, rcClient *rockscache.Client, key string, expire time.Duration, fn func(ctx context.Context) (T, error)) (T, error) {
 	var t T
 	var write bool

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

@@ -222,14 +222,6 @@ func (c *ConversationRedisCache) DelUserAllHasReadSeqs(ownerUserID string, conve
 	return cache
 }
 
-func (c *ConversationRedisCache) GetConversationsByConversationID(ctx context.Context, conversationIDs []string) ([]*model.Conversation, error) {
-	panic("implement me")
-}
-
-func (c *ConversationRedisCache) DelConversationByConversationID(conversationIDs ...string) cache.ConversationCache {
-	panic("implement me")
-}
-
 func (c *ConversationRedisCache) GetConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) ([]string, error) {
 	return getCache(ctx, c.rcClient, c.getConversationNotReceiveMessageUserIDsKey(conversationID), c.expireTime, func(ctx context.Context) ([]string, error) {
 		return c.conversationDB.GetConversationNotReceiveMessageUserIDs(ctx, conversationID)

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

@@ -0,0 +1,125 @@
+package redis
+
+import (
+	"context"
+	"fmt"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
+	"github.com/redis/go-redis/v9"
+)
+
+var (
+	setBatchWithCommonExpireScript = redis.NewScript(`
+local expire = tonumber(ARGV[1])
+for i, key in ipairs(KEYS) do
+    redis.call('SET', key, ARGV[i + 1])
+    redis.call('EXPIRE', key, expire)
+end
+return #KEYS
+`)
+
+	setBatchWithIndividualExpireScript = redis.NewScript(`
+local n = #KEYS
+for i = 1, n do
+    redis.call('SET', KEYS[i], ARGV[i])
+    redis.call('EXPIRE', KEYS[i], ARGV[i + n])
+end
+return n
+`)
+
+	deleteBatchScript = redis.NewScript(`
+for i, key in ipairs(KEYS) do
+    redis.call('DEL', key)
+end
+return #KEYS
+`)
+
+	getBatchScript = redis.NewScript(`
+local values = {}
+for i, key in ipairs(KEYS) do
+    local value = redis.call('GET', key)
+    table.insert(values, value)
+end
+return values
+`)
+)
+
+func callLua(ctx context.Context, rdb redis.Scripter, script *redis.Script, keys []string, args []any) (any, error) {
+	log.ZDebug(ctx, "callLua args", "scriptHash", script.Hash(), "keys", keys, "args", args)
+	r := script.EvalSha(ctx, rdb, keys, args)
+	if redis.HasErrorPrefix(r.Err(), "NOSCRIPT") {
+		if err := script.Load(ctx, rdb).Err(); err != nil {
+			r = script.Eval(ctx, rdb, keys, args)
+		} else {
+			r = script.EvalSha(ctx, rdb, keys, args)
+		}
+	}
+	v, err := r.Result()
+	if err == redis.Nil {
+		err = nil
+	}
+	return v, errs.WrapMsg(err, "call lua err", "scriptHash", script.Hash(), "keys", keys, "args", args)
+}
+
+func LuaSetBatchWithCommonExpire(ctx context.Context, rdb redis.Scripter, keys []string, values []string, expire int) error {
+	// Check if the lengths of keys and values match
+	if len(keys) != len(values) {
+		return errs.New("keys and values length mismatch").Wrap()
+	}
+
+	// Ensure allocation size does not overflow
+	maxAllowedLen := (1 << 31) - 1 // 2GB limit (maximum address space for 32-bit systems)
+
+	if len(values) > maxAllowedLen-1 {
+		return fmt.Errorf("values length is too large, causing overflow")
+	}
+	var vals = make([]any, 0, 1+len(values))
+	vals = append(vals, expire)
+	for _, v := range values {
+		vals = append(vals, v)
+	}
+	_, err := callLua(ctx, rdb, setBatchWithCommonExpireScript, keys, vals)
+	return err
+}
+
+func LuaSetBatchWithIndividualExpire(ctx context.Context, rdb redis.Scripter, keys []string, values []string, expires []int) error {
+	// Check if the lengths of keys, values, and expires match
+	if len(keys) != len(values) || len(keys) != len(expires) {
+		return errs.New("keys and values length mismatch").Wrap()
+	}
+
+	// Ensure the allocation size does not overflow
+	maxAllowedLen := (1 << 31) - 1 // 2GB limit (maximum address space for 32-bit systems)
+
+	if len(values) > maxAllowedLen-1 {
+		return errs.New(fmt.Sprintf("values length %d exceeds the maximum allowed length %d", len(values), maxAllowedLen-1)).Wrap()
+	}
+	var vals = make([]any, 0, len(values)+len(expires))
+	for _, v := range values {
+		vals = append(vals, v)
+	}
+	for _, ex := range expires {
+		vals = append(vals, ex)
+	}
+	_, err := callLua(ctx, rdb, setBatchWithIndividualExpireScript, keys, vals)
+	return err
+}
+
+func LuaDeleteBatch(ctx context.Context, rdb redis.Scripter, keys []string) error {
+	_, err := callLua(ctx, rdb, deleteBatchScript, keys, nil)
+	return err
+}
+
+func LuaGetBatch(ctx context.Context, rdb redis.Scripter, keys []string) ([]any, error) {
+	v, err := callLua(ctx, rdb, getBatchScript, keys, nil)
+	if err != nil {
+		return nil, err
+	}
+	values, ok := v.([]any)
+	if !ok {
+		return nil, servererrs.ErrArgs.WrapMsg("invalid lua get batch result")
+	}
+	return values, nil
+
+}

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

@@ -0,0 +1,75 @@
+package redis
+
+import (
+	"context"
+	"github.com/go-redis/redismock/v9"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestLuaSetBatchWithCommonExpire(t *testing.T) {
+	rdb, mock := redismock.NewClientMock()
+	ctx := context.Background()
+
+	keys := []string{"key1", "key2"}
+	values := []string{"value1", "value2"}
+	expire := 10
+
+	mock.ExpectEvalSha(setBatchWithCommonExpireScript.Hash(), keys, []any{expire, "value1", "value2"}).SetVal(int64(len(keys)))
+
+	err := LuaSetBatchWithCommonExpire(ctx, rdb, keys, values, expire)
+	require.NoError(t, err)
+	assert.NoError(t, mock.ExpectationsWereMet())
+}
+
+func TestLuaSetBatchWithIndividualExpire(t *testing.T) {
+	rdb, mock := redismock.NewClientMock()
+	ctx := context.Background()
+
+	keys := []string{"key1", "key2"}
+	values := []string{"value1", "value2"}
+	expires := []int{10, 20}
+
+	args := make([]any, 0, len(values)+len(expires))
+	for _, v := range values {
+		args = append(args, v)
+	}
+	for _, ex := range expires {
+		args = append(args, ex)
+	}
+
+	mock.ExpectEvalSha(setBatchWithIndividualExpireScript.Hash(), keys, args).SetVal(int64(len(keys)))
+
+	err := LuaSetBatchWithIndividualExpire(ctx, rdb, keys, values, expires)
+	require.NoError(t, err)
+	assert.NoError(t, mock.ExpectationsWereMet())
+}
+
+func TestLuaDeleteBatch(t *testing.T) {
+	rdb, mock := redismock.NewClientMock()
+	ctx := context.Background()
+
+	keys := []string{"key1", "key2"}
+
+	mock.ExpectEvalSha(deleteBatchScript.Hash(), keys, []any{}).SetVal(int64(len(keys)))
+
+	err := LuaDeleteBatch(ctx, rdb, keys)
+	require.NoError(t, err)
+	assert.NoError(t, mock.ExpectationsWereMet())
+}
+
+func TestLuaGetBatch(t *testing.T) {
+	rdb, mock := redismock.NewClientMock()
+	ctx := context.Background()
+
+	keys := []string{"key1", "key2"}
+	expectedValues := []any{"value1", "value2"}
+
+	mock.ExpectEvalSha(getBatchScript.Hash(), keys, []any{}).SetVal(expectedValues)
+
+	values, err := LuaGetBatch(ctx, rdb, keys)
+	require.NoError(t, err)
+	assert.NoError(t, mock.ExpectationsWereMet())
+	assert.Equal(t, expectedValues, values)
+}

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

@@ -1,15 +0,0 @@
-// Copyright © 2023 OpenIM. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package redis

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

@@ -16,37 +16,25 @@ package redis
 
 import (
 	"context"
-	"errors"
-	"github.com/gogo/protobuf/jsonpb"
 	"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/open-im-server/v3/pkg/msgprocessor"
-	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/utils/stringutil"
+	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/redis/go-redis/v9"
-	"golang.org/x/sync/errgroup"
 	"time"
-)
+) //
 
-const msgCacheTimeout = 86400 * time.Second
+// msgCacheTimeout is  expiration time of message cache, 86400 seconds
+const msgCacheTimeout = 86400
 
-var concurrentLimit = 3
-
-func NewMsgCache(client redis.UniversalClient, redisEnablePipeline bool) cache.MsgCache {
-	return &msgCache{rdb: client, msgCacheTimeout: msgCacheTimeout, redisEnablePipeline: redisEnablePipeline}
+func NewMsgCache(client redis.UniversalClient) cache.MsgCache {
+	return &msgCache{rdb: client}
 }
 
 type msgCache struct {
-	rdb                 redis.UniversalClient
-	msgCacheTimeout     time.Duration
-	redisEnablePipeline bool
-}
-
-func (c *msgCache) getAllMessageCacheKey(conversationID string) string {
-	return cachekey.GetAllMessageCacheKey(conversationID)
+	rdb redis.UniversalClient
 }
 
 func (c *msgCache) getMessageCacheKey(conversationID string, seq int64) string {
@@ -72,218 +60,41 @@ func (c *msgCache) getMessageReactionExPrefix(clientMsgID string, sessionType in
 	return cachekey.GetMessageReactionExKey(clientMsgID, sessionType)
 }
 
-func (c *msgCache) SetMessageToCache(ctx context.Context, conversationID string, msgs []*sdkws.MsgData) (int, error) {
-	if c.redisEnablePipeline {
-		return c.PipeSetMessageToCache(ctx, conversationID, msgs)
-	}
-	return c.ParallelSetMessageToCache(ctx, conversationID, msgs)
-}
-
-func (c *msgCache) PipeSetMessageToCache(ctx context.Context, conversationID string, msgs []*sdkws.MsgData) (int, error) {
-	pipe := c.rdb.Pipeline()
-	for _, msg := range msgs {
-		s, err := msgprocessor.Pb2String(msg)
-		if err != nil {
-			return 0, err
-		}
-
-		key := c.getMessageCacheKey(conversationID, msg.Seq)
-		_ = pipe.Set(ctx, key, s, c.msgCacheTimeout)
-	}
-
-	results, err := pipe.Exec(ctx)
-	if err != nil {
-		return 0, errs.Wrap(err)
-	}
-
-	for _, res := range results {
-		if res.Err() != nil {
-			return 0, errs.Wrap(err)
-		}
-	}
-
-	return len(msgs), nil
-}
-
-func (c *msgCache) ParallelSetMessageToCache(ctx context.Context, conversationID string, msgs []*sdkws.MsgData) (int, error) {
-	wg := errgroup.Group{}
-	wg.SetLimit(concurrentLimit)
-
-	for _, msg := range msgs {
-		msg := msg // closure safe var
-		wg.Go(func() error {
-			s, err := msgprocessor.Pb2String(msg)
-			if err != nil {
-				return errs.Wrap(err)
-			}
-
-			key := c.getMessageCacheKey(conversationID, msg.Seq)
-			if err := c.rdb.Set(ctx, key, s, c.msgCacheTimeout).Err(); err != nil {
-				return errs.Wrap(err)
-			}
-			return nil
-		})
-	}
-
-	err := wg.Wait()
-	if err != nil {
-		return 0, errs.WrapMsg(err, "wg.Wait failed")
-	}
-
-	return len(msgs), nil
-}
-
-func (c *msgCache) UserDeleteMsgs(ctx context.Context, conversationID string, seqs []int64, userID string) error {
-	for _, seq := range seqs {
-		delUserListKey := c.getMessageDelUserListKey(conversationID, seq)
-		userDelListKey := c.getUserDelList(conversationID, userID)
-		err := c.rdb.SAdd(ctx, delUserListKey, userID).Err()
-		if err != nil {
-			return errs.Wrap(err)
-		}
-		err = c.rdb.SAdd(ctx, userDelListKey, seq).Err()
-		if err != nil {
-			return errs.Wrap(err)
-		}
-		if err := c.rdb.Expire(ctx, delUserListKey, c.msgCacheTimeout).Err(); err != nil {
-			return errs.Wrap(err)
-		}
-		if err := c.rdb.Expire(ctx, userDelListKey, c.msgCacheTimeout).Err(); err != nil {
-			return errs.Wrap(err)
-		}
-	}
-
-	return nil
-}
-
-func (c *msgCache) GetUserDelList(ctx context.Context, userID, conversationID string) (seqs []int64, err error) {
-	result, err := c.rdb.SMembers(ctx, c.getUserDelList(conversationID, userID)).Result()
-	if err != nil {
-		return nil, errs.Wrap(err)
-	}
-	seqs = make([]int64, len(result))
-	for i, v := range result {
-		seqs[i] = stringutil.StringToInt64(v)
-	}
-
-	return seqs, nil
-}
-
-func (c *msgCache) DelUserDeleteMsgsList(ctx context.Context, conversationID string, seqs []int64) {
-	for _, seq := range seqs {
-		delUsers, err := c.rdb.SMembers(ctx, c.getMessageDelUserListKey(conversationID, seq)).Result()
-		if err != nil {
-			log.ZWarn(ctx, "DelUserDeleteMsgsList failed", err, "conversationID", conversationID, "seq", seq)
-
-			continue
-		}
-		if len(delUsers) > 0 {
-			var failedFlag bool
-			for _, userID := range delUsers {
-				err = c.rdb.SRem(ctx, c.getUserDelList(conversationID, userID), seq).Err()
+func (c *msgCache) SetMessagesToCache(ctx context.Context, conversationID string, msgs []*sdkws.MsgData) (int, error) {
+	msgMap := datautil.SliceToMap(msgs, func(msg *sdkws.MsgData) string {
+		return c.getMessageCacheKey(conversationID, msg.Seq)
+	})
+	keys := datautil.Slice(msgs, func(msg *sdkws.MsgData) string {
+		return c.getMessageCacheKey(conversationID, msg.Seq)
+	})
+	err := ProcessKeysBySlot(ctx, c.rdb, keys, func(ctx context.Context, slot int64, keys []string) error {
+		var values []string
+		for _, key := range keys {
+			if msg, ok := msgMap[key]; ok {
+				s, err := msgprocessor.Pb2String(msg)
 				if err != nil {
-					failedFlag = true
-					log.ZWarn(ctx, "DelUserDeleteMsgsList failed", err, "conversationID", conversationID, "seq", seq, "userID", userID)
-				}
-			}
-			if !failedFlag {
-				if err := c.rdb.Del(ctx, c.getMessageDelUserListKey(conversationID, seq)).Err(); err != nil {
-					log.ZWarn(ctx, "DelUserDeleteMsgsList failed", err, "conversationID", conversationID, "seq", seq)
+					return err
 				}
+				values = append(values, s)
 			}
 		}
-	}
-}
-
-func (c *msgCache) DeleteMessages(ctx context.Context, conversationID string, seqs []int64) error {
-	if c.redisEnablePipeline {
-		return c.PipeDeleteMessages(ctx, conversationID, seqs)
-	}
-
-	return c.ParallelDeleteMessages(ctx, conversationID, seqs)
-}
-
-func (c *msgCache) ParallelDeleteMessages(ctx context.Context, conversationID string, seqs []int64) error {
-	wg := errgroup.Group{}
-	wg.SetLimit(concurrentLimit)
-
-	for _, seq := range seqs {
-		seq := seq
-		wg.Go(func() error {
-			err := c.rdb.Del(ctx, c.getMessageCacheKey(conversationID, seq)).Err()
-			if err != nil {
-				return errs.Wrap(err)
-			}
-			return nil
-		})
-	}
-
-	return wg.Wait()
-}
-
-func (c *msgCache) PipeDeleteMessages(ctx context.Context, conversationID string, seqs []int64) error {
-	pipe := c.rdb.Pipeline()
-	for _, seq := range seqs {
-		_ = pipe.Del(ctx, c.getMessageCacheKey(conversationID, seq))
-	}
-
-	results, err := pipe.Exec(ctx)
+		return LuaSetBatchWithCommonExpire(ctx, c.rdb, keys, values, msgCacheTimeout)
+	})
 	if err != nil {
-		return errs.WrapMsg(err, "pipe.del")
+		return 0, err
 	}
-
-	for _, res := range results {
-		if res.Err() != nil {
-			return errs.Wrap(err)
-		}
-	}
-
-	return nil
+	return len(msgs), nil
 }
 
-func (c *msgCache) CleanUpOneConversationAllMsg(ctx context.Context, conversationID string) error {
-	vals, err := c.rdb.Keys(ctx, c.getAllMessageCacheKey(conversationID)).Result()
-	if errors.Is(err, redis.Nil) {
-		return nil
-	}
-	if err != nil {
-		return errs.Wrap(err)
-	}
-	for _, v := range vals {
-		if err := c.rdb.Del(ctx, v).Err(); err != nil {
-			return errs.Wrap(err)
-		}
-	}
-	return nil
-}
-
-func (c *msgCache) DelMsgFromCache(ctx context.Context, userID string, seqs []int64) error {
+func (c *msgCache) DeleteMessagesFromCache(ctx context.Context, conversationID string, seqs []int64) error {
+	var keys []string
 	for _, seq := range seqs {
-		key := c.getMessageCacheKey(userID, seq)
-		result, err := c.rdb.Get(ctx, key).Result()
-		if err != nil {
-			if errors.Is(err, redis.Nil) {
-				continue
-			}
-
-			return errs.Wrap(err)
-		}
-		var msg sdkws.MsgData
-		err = jsonpb.UnmarshalString(result, &msg)
-		if err != nil {
-			return err
-		}
-		msg.Status = constant.MsgDeleted
-		s, err := msgprocessor.Pb2String(&msg)
-		if err != nil {
-			return errs.Wrap(err)
-		}
-		if err := c.rdb.Set(ctx, key, s, c.msgCacheTimeout).Err(); err != nil {
-			return errs.Wrap(err)
-		}
+		keys = append(keys, c.getMessageCacheKey(conversationID, seq))
 	}
 
-	return nil
+	return ProcessKeysBySlot(ctx, c.rdb, keys, func(ctx context.Context, slot int64, keys []string) error {
+		return LuaDeleteBatch(ctx, c.rdb, keys)
+	})
 }
 
 func (c *msgCache) SetSendMsgStatus(ctx context.Context, id string, status int32) error {
@@ -338,102 +149,39 @@ func (c *msgCache) DeleteOneMessageKey(ctx context.Context, clientMsgID string,
 }
 
 func (c *msgCache) GetMessagesBySeq(ctx context.Context, conversationID string, seqs []int64) (seqMsgs []*sdkws.MsgData, failedSeqs []int64, err error) {
-	if c.redisEnablePipeline {
-		return c.PipeGetMessagesBySeq(ctx, conversationID, seqs)
-	}
-
-	return c.ParallelGetMessagesBySeq(ctx, conversationID, seqs)
-}
-
-func (c *msgCache) PipeGetMessagesBySeq(ctx context.Context, conversationID string, seqs []int64) (seqMsgs []*sdkws.MsgData, failedSeqs []int64, err error) {
-	pipe := c.rdb.Pipeline()
-
-	results := []*redis.StringCmd{}
+	var keys []string
+	keySeqMap := make(map[string]int64, 10)
 	for _, seq := range seqs {
-		results = append(results, pipe.Get(ctx, c.getMessageCacheKey(conversationID, seq)))
+		key := c.getMessageCacheKey(conversationID, seq)
+		keys = append(keys, key)
+		keySeqMap[key] = seq
 	}
+	err = ProcessKeysBySlot(ctx, c.rdb, keys, func(ctx context.Context, slot int64, keys []string) error {
+		result, err := LuaGetBatch(ctx, c.rdb, keys)
+		if err != nil {
+			return err
+		}
+		for i, value := range result {
+			seq := keySeqMap[keys[i]]
+			if value == nil {
+				failedSeqs = append(failedSeqs, seq)
+				continue
+			}
 
-	_, err = pipe.Exec(ctx)
-	if err != nil && err != redis.Nil {
-		return seqMsgs, failedSeqs, errs.WrapMsg(err, "pipe.get")
+			msg := &sdkws.MsgData{}
+			msgString, ok := value.(string)
+			if !ok || msgprocessor.String2Pb(msgString, msg) != nil {
+				failedSeqs = append(failedSeqs, seq)
+				continue
+			}
+			seqMsgs = append(seqMsgs, msg)
+
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, nil, err
 	}
+	return seqMsgs, failedSeqs, nil
 
-	for idx, res := range results {
-		seq := seqs[idx]
-		if res.Err() != nil {
-			log.ZError(ctx, "GetMessagesBySeq failed", err, "conversationID", conversationID, "seq", seq, "err", res.Err())
-			failedSeqs = append(failedSeqs, seq)
-			continue
-		}
-
-		msg := sdkws.MsgData{}
-		if err = msgprocessor.String2Pb(res.Val(), &msg); err != nil {
-			log.ZError(ctx, "GetMessagesBySeq Unmarshal failed", err, "res", res, "conversationID", conversationID, "seq", seq)
-			failedSeqs = append(failedSeqs, seq)
-			continue
-		}
-
-		if msg.Status == constant.MsgDeleted {
-			failedSeqs = append(failedSeqs, seq)
-			continue
-		}
-
-		seqMsgs = append(seqMsgs, &msg)
-	}
-
-	return
-}
-
-func (c *msgCache) ParallelGetMessagesBySeq(ctx context.Context, conversationID string, seqs []int64) (seqMsgs []*sdkws.MsgData, failedSeqs []int64, err error) {
-	type entry struct {
-		err error
-		msg *sdkws.MsgData
-	}
-
-	wg := errgroup.Group{}
-	wg.SetLimit(concurrentLimit)
-
-	results := make([]entry, len(seqs)) // set slice len/cap to length of seqs.
-	for idx, seq := range seqs {
-		// closure safe var
-		idx := idx
-		seq := seq
-
-		wg.Go(func() error {
-			res, err := c.rdb.Get(ctx, c.getMessageCacheKey(conversationID, seq)).Result()
-			if err != nil {
-				log.ZError(ctx, "GetMessagesBySeq failed", err, "conversationID", conversationID, "seq", seq)
-				results[idx] = entry{err: err}
-				return nil
-			}
-
-			msg := sdkws.MsgData{}
-			if err = msgprocessor.String2Pb(res, &msg); err != nil {
-				log.ZError(ctx, "GetMessagesBySeq Unmarshal failed", err, "res", res, "conversationID", conversationID, "seq", seq)
-				results[idx] = entry{err: err}
-				return nil
-			}
-
-			if msg.Status == constant.MsgDeleted {
-				results[idx] = entry{err: err}
-				return nil
-			}
-
-			results[idx] = entry{msg: &msg}
-			return nil
-		})
-	}
-
-	_ = wg.Wait()
-
-	for idx, res := range results {
-		if res.err != nil {
-			failedSeqs = append(failedSeqs, seqs[idx])
-			continue
-		}
-
-		seqMsgs = append(seqMsgs, res.msg)
-	}
-
-	return
 }

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

@@ -4,14 +4,13 @@
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
+//	http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-
 package redis
 
 import (
@@ -20,381 +19,115 @@ import (
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
-	"math/rand"
+	"google.golang.org/protobuf/proto"
 	"testing"
 )
 
-func TestParallelSetMessageToCache(t *testing.T) {
-	var (
-		cid      = fmt.Sprintf("cid-%v", rand.Int63())
-		seqFirst = rand.Int63()
-		msgs     = []*sdkws.MsgData{}
-	)
-
-	for i := 0; i < 100; i++ {
-		msgs = append(msgs, &sdkws.MsgData{
-			Seq: seqFirst + int64(i),
+func Test_msgCache_SetMessagesToCache(t *testing.T) {
+	type fields struct {
+		rdb redis.UniversalClient
+	}
+	type args struct {
+		ctx            context.Context
+		conversationID string
+		msgs           []*sdkws.MsgData
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    int
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{"test1", fields{rdb: redis.NewClient(&redis.Options{Addr: "localhost:16379", Username: "", Password: "openIM123", DB: 0})}, args{context.Background(),
+			"cid", []*sdkws.MsgData{{Seq: 1}, {Seq: 2}, {Seq: 3}}}, 3, assert.NoError},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &msgCache{
+				rdb: tt.fields.rdb,
+			}
+			got, err := c.SetMessagesToCache(tt.args.ctx, tt.args.conversationID, tt.args.msgs)
+			if !tt.wantErr(t, err, fmt.Sprintf("SetMessagesToCache(%v, %v, %v)", tt.args.ctx, tt.args.conversationID, tt.args.msgs)) {
+				return
+			}
+			assert.Equalf(t, tt.want, got, "SetMessagesToCache(%v, %v, %v)", tt.args.ctx, tt.args.conversationID, tt.args.msgs)
 		})
 	}
-
-	testParallelSetMessageToCache(t, cid, msgs)
 }
 
-func testParallelSetMessageToCache(t *testing.T, cid string, msgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	ret, err := cacher.ParallelSetMessageToCache(context.Background(), cid, msgs)
-	assert.Nil(t, err)
-	assert.Equal(t, len(msgs), ret)
-
-	// validate
-	for _, msg := range msgs {
-		key := cacher.getMessageCacheKey(cid, msg.Seq)
-		val, err := rdb.Exists(context.Background(), key).Result()
-		assert.Nil(t, err)
-		assert.EqualValues(t, 1, val)
+func Test_msgCache_GetMessagesBySeq(t *testing.T) {
+	type fields struct {
+		rdb redis.UniversalClient
 	}
-}
-
-func TestPipeSetMessageToCache(t *testing.T) {
-	var (
-		cid      = fmt.Sprintf("cid-%v", rand.Int63())
-		seqFirst = rand.Int63()
-		msgs     = []*sdkws.MsgData{}
-	)
-
-	for i := 0; i < 100; i++ {
-		msgs = append(msgs, &sdkws.MsgData{
-			Seq: seqFirst + int64(i),
+	type args struct {
+		ctx            context.Context
+		conversationID string
+		seqs           []int64
+	}
+	var failedSeq []int64
+	tests := []struct {
+		name           string
+		fields         fields
+		args           args
+		wantSeqMsgs    []*sdkws.MsgData
+		wantFailedSeqs []int64
+		wantErr        assert.ErrorAssertionFunc
+	}{
+		{"test1", fields{rdb: redis.NewClient(&redis.Options{Addr: "localhost:16379", Password: "openIM123", DB: 0})},
+			args{context.Background(), "cid", []int64{1, 2, 3}},
+			[]*sdkws.MsgData{{Seq: 1}, {Seq: 2}, {Seq: 3}}, failedSeq, assert.NoError},
+		{"test2", fields{rdb: redis.NewClient(&redis.Options{Addr: "localhost:16379", Password: "openIM123", DB: 0})},
+			args{context.Background(), "cid", []int64{4, 5, 6}},
+			nil, []int64{4, 5, 6}, assert.NoError},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &msgCache{
+				rdb: tt.fields.rdb,
+			}
+			gotSeqMsgs, gotFailedSeqs, err := c.GetMessagesBySeq(tt.args.ctx, tt.args.conversationID, tt.args.seqs)
+			if !tt.wantErr(t, err, fmt.Sprintf("GetMessagesBySeq(%v, %v, %v)", tt.args.ctx, tt.args.conversationID, tt.args.seqs)) {
+				return
+			}
+			equalMsgDataSlices(t, tt.wantSeqMsgs, gotSeqMsgs)
+			assert.Equalf(t, tt.wantFailedSeqs, gotFailedSeqs, "GetMessagesBySeq(%v, %v, %v)", tt.args.ctx, tt.args.conversationID, tt.args.seqs)
 		})
 	}
-
-	testPipeSetMessageToCache(t, cid, msgs)
 }
 
-func testPipeSetMessageToCache(t *testing.T, cid string, msgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	ret, err := cacher.PipeSetMessageToCache(context.Background(), cid, msgs)
-	assert.Nil(t, err)
-	assert.Equal(t, len(msgs), ret)
-
-	// validate
-	for _, msg := range msgs {
-		key := cacher.getMessageCacheKey(cid, msg.Seq)
-		val, err := rdb.Exists(context.Background(), key).Result()
-		assert.Nil(t, err)
-		assert.EqualValues(t, 1, val)
+func equalMsgDataSlices(t *testing.T, expected, actual []*sdkws.MsgData) {
+	assert.Equal(t, len(expected), len(actual), "Slices have different lengths")
+	for i := range expected {
+		assert.True(t, proto.Equal(expected[i], actual[i]), "Element %d not equal: expected %v, got %v", i, expected[i], actual[i])
 	}
 }
 
-func TestGetMessagesBySeq(t *testing.T) {
-	var (
-		cid      = fmt.Sprintf("cid-%v", rand.Int63())
-		seqFirst = rand.Int63()
-		msgs     = []*sdkws.MsgData{}
-	)
-
-	seqs := []int64{}
-	for i := 0; i < 100; i++ {
-		msgs = append(msgs, &sdkws.MsgData{
-			Seq:    seqFirst + int64(i),
-			SendID: fmt.Sprintf("fake-sendid-%v", i),
+func Test_msgCache_DeleteMessagesFromCache(t *testing.T) {
+	type fields struct {
+		rdb redis.UniversalClient
+	}
+	type args struct {
+		ctx            context.Context
+		conversationID string
+		seqs           []int64
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{"test1", fields{rdb: redis.NewClient(&redis.Options{Addr: "localhost:16379", Password: "openIM123"})},
+			args{context.Background(), "cid", []int64{1, 2, 3}}, assert.NoError},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &msgCache{
+				rdb: tt.fields.rdb,
+			}
+			tt.wantErr(t, c.DeleteMessagesFromCache(tt.args.ctx, tt.args.conversationID, tt.args.seqs),
+				fmt.Sprintf("DeleteMessagesFromCache(%v, %v, %v)", tt.args.ctx, tt.args.conversationID, tt.args.seqs))
 		})
-		seqs = append(seqs, seqFirst+int64(i))
-	}
-
-	// set data to cache
-	testPipeSetMessageToCache(t, cid, msgs)
-
-	// get data from cache with parallet mode
-	testParallelGetMessagesBySeq(t, cid, seqs, msgs)
-
-	// get data from cache with pipeline mode
-	testPipeGetMessagesBySeq(t, cid, seqs, msgs)
-}
-
-func testParallelGetMessagesBySeq(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	respMsgs, failedSeqs, err := cacher.ParallelGetMessagesBySeq(context.Background(), cid, seqs)
-	assert.Nil(t, err)
-	assert.Equal(t, 0, len(failedSeqs))
-	assert.Equal(t, len(respMsgs), len(seqs))
-
-	// validate
-	for idx, msg := range respMsgs {
-		assert.Equal(t, msg.Seq, inputMsgs[idx].Seq)
-		assert.Equal(t, msg.SendID, inputMsgs[idx].SendID)
-	}
-}
-
-func testPipeGetMessagesBySeq(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	respMsgs, failedSeqs, err := cacher.PipeGetMessagesBySeq(context.Background(), cid, seqs)
-	assert.Nil(t, err)
-	assert.Equal(t, 0, len(failedSeqs))
-	assert.Equal(t, len(respMsgs), len(seqs))
-
-	// validate
-	for idx, msg := range respMsgs {
-		assert.Equal(t, msg.Seq, inputMsgs[idx].Seq)
-		assert.Equal(t, msg.SendID, inputMsgs[idx].SendID)
-	}
-}
-
-func TestGetMessagesBySeqWithEmptySeqs(t *testing.T) {
-	var (
-		cid            = fmt.Sprintf("cid-%v", rand.Int63())
-		seqFirst int64 = 0
-		msgs           = []*sdkws.MsgData{}
-	)
-
-	seqs := []int64{}
-	for i := 0; i < 100; i++ {
-		msgs = append(msgs, &sdkws.MsgData{
-			Seq:    seqFirst + int64(i),
-			SendID: fmt.Sprintf("fake-sendid-%v", i),
-		})
-		seqs = append(seqs, seqFirst+int64(i))
-	}
-
-	// don't set cache, only get data from cache.
-
-	// get data from cache with parallet mode
-	testParallelGetMessagesBySeqWithEmptry(t, cid, seqs, msgs)
-
-	// get data from cache with pipeline mode
-	testPipeGetMessagesBySeqWithEmptry(t, cid, seqs, msgs)
-}
-
-func testParallelGetMessagesBySeqWithEmptry(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	respMsgs, failedSeqs, err := cacher.ParallelGetMessagesBySeq(context.Background(), cid, seqs)
-	assert.Nil(t, err)
-	assert.Equal(t, len(seqs), len(failedSeqs))
-	assert.Equal(t, 0, len(respMsgs))
-}
-
-func testPipeGetMessagesBySeqWithEmptry(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	respMsgs, failedSeqs, err := cacher.PipeGetMessagesBySeq(context.Background(), cid, seqs)
-	assert.Equal(t, err, redis.Nil)
-	assert.Equal(t, len(seqs), len(failedSeqs))
-	assert.Equal(t, 0, len(respMsgs))
-}
-
-func TestGetMessagesBySeqWithLostHalfSeqs(t *testing.T) {
-	var (
-		cid            = fmt.Sprintf("cid-%v", rand.Int63())
-		seqFirst int64 = 0
-		msgs           = []*sdkws.MsgData{}
-	)
-
-	seqs := []int64{}
-	for i := 0; i < 100; i++ {
-		msgs = append(msgs, &sdkws.MsgData{
-			Seq:    seqFirst + int64(i),
-			SendID: fmt.Sprintf("fake-sendid-%v", i),
-		})
-		seqs = append(seqs, seqFirst+int64(i))
-	}
-
-	// Only set half the number of messages.
-	testParallelSetMessageToCache(t, cid, msgs[:50])
-
-	// get data from cache with parallet mode
-	testParallelGetMessagesBySeqWithLostHalfSeqs(t, cid, seqs, msgs)
-
-	// get data from cache with pipeline mode
-	testPipeGetMessagesBySeqWithLostHalfSeqs(t, cid, seqs, msgs)
-}
-
-func testParallelGetMessagesBySeqWithLostHalfSeqs(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	respMsgs, failedSeqs, err := cacher.ParallelGetMessagesBySeq(context.Background(), cid, seqs)
-	assert.Nil(t, err)
-	assert.Equal(t, len(seqs)/2, len(failedSeqs))
-	assert.Equal(t, len(seqs)/2, len(respMsgs))
-
-	for idx, msg := range respMsgs {
-		assert.Equal(t, msg.Seq, seqs[idx])
-	}
-}
-
-func testPipeGetMessagesBySeqWithLostHalfSeqs(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	respMsgs, failedSeqs, err := cacher.PipeGetMessagesBySeq(context.Background(), cid, seqs)
-	assert.Nil(t, err)
-	assert.Equal(t, len(seqs)/2, len(failedSeqs))
-	assert.Equal(t, len(seqs)/2, len(respMsgs))
-
-	for idx, msg := range respMsgs {
-		assert.Equal(t, msg.Seq, seqs[idx])
-	}
-}
-
-func TestPipeDeleteMessages(t *testing.T) {
-	var (
-		cid      = fmt.Sprintf("cid-%v", rand.Int63())
-		seqFirst = rand.Int63()
-		msgs     = []*sdkws.MsgData{}
-	)
-
-	var seqs []int64
-	for i := 0; i < 100; i++ {
-		msgs = append(msgs, &sdkws.MsgData{
-			Seq: seqFirst + int64(i),
-		})
-		seqs = append(seqs, msgs[i].Seq)
-	}
-
-	testPipeSetMessageToCache(t, cid, msgs)
-	testPipeDeleteMessagesOK(t, cid, seqs, msgs)
-
-	// set again
-	testPipeSetMessageToCache(t, cid, msgs)
-	testPipeDeleteMessagesMix(t, cid, seqs[:90], msgs)
-}
-
-func testPipeDeleteMessagesOK(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	err := cacher.PipeDeleteMessages(context.Background(), cid, seqs)
-	assert.Nil(t, err)
-
-	// validate
-	for _, msg := range inputMsgs {
-		key := cacher.getMessageCacheKey(cid, msg.Seq)
-		val := rdb.Exists(context.Background(), key).Val()
-		assert.EqualValues(t, 0, val)
-	}
-}
-
-func testPipeDeleteMessagesMix(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	err := cacher.PipeDeleteMessages(context.Background(), cid, seqs)
-	assert.Nil(t, err)
-
-	// validate
-	for idx, msg := range inputMsgs {
-		key := cacher.getMessageCacheKey(cid, msg.Seq)
-		val, err := rdb.Exists(context.Background(), key).Result()
-		assert.Nil(t, err)
-		if idx < 90 {
-			assert.EqualValues(t, 0, val) // not exists
-			continue
-		}
-
-		assert.EqualValues(t, 1, val) // exists
-	}
-}
-
-func TestParallelDeleteMessages(t *testing.T) {
-	var (
-		cid      = fmt.Sprintf("cid-%v", rand.Int63())
-		seqFirst = rand.Int63()
-		msgs     = []*sdkws.MsgData{}
-	)
-
-	var seqs []int64
-	for i := 0; i < 100; i++ {
-		msgs = append(msgs, &sdkws.MsgData{
-			Seq: seqFirst + int64(i),
-		})
-		seqs = append(seqs, msgs[i].Seq)
-	}
-
-	randSeqs := []int64{}
-	for i := seqFirst + 100; i < seqFirst+200; i++ {
-		randSeqs = append(randSeqs, i)
-	}
-
-	testParallelSetMessageToCache(t, cid, msgs)
-	testParallelDeleteMessagesOK(t, cid, seqs, msgs)
-
-	// set again
-	testParallelSetMessageToCache(t, cid, msgs)
-	testParallelDeleteMessagesMix(t, cid, seqs[:90], msgs, 90)
-	testParallelDeleteMessagesOK(t, cid, seqs[90:], msgs[:90])
-
-	// set again
-	testParallelSetMessageToCache(t, cid, msgs)
-	testParallelDeleteMessagesMix(t, cid, randSeqs, msgs, 0)
-}
-
-func testParallelDeleteMessagesOK(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	err := cacher.PipeDeleteMessages(context.Background(), cid, seqs)
-	assert.Nil(t, err)
-
-	// validate
-	for _, msg := range inputMsgs {
-		key := cacher.getMessageCacheKey(cid, msg.Seq)
-		val := rdb.Exists(context.Background(), key).Val()
-		assert.EqualValues(t, 0, val)
-	}
-}
-
-func testParallelDeleteMessagesMix(t *testing.T, cid string, seqs []int64, inputMsgs []*sdkws.MsgData, lessValNonExists int) {
-	rdb := redis.NewClient(&redis.Options{})
-	defer rdb.Close()
-
-	cacher := msgCache{rdb: rdb}
-
-	err := cacher.PipeDeleteMessages(context.Background(), cid, seqs)
-	assert.Nil(t, err)
-
-	// validate
-	for idx, msg := range inputMsgs {
-		key := cacher.getMessageCacheKey(cid, msg.Seq)
-		val, err := rdb.Exists(context.Background(), key).Result()
-		assert.Nil(t, err)
-		if idx < lessValNonExists {
-			assert.EqualValues(t, 0, val) // not exists
-			continue
-		}
-
-		assert.EqualValues(t, 1, val) // exists
 	}
 }

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

@@ -0,0 +1,197 @@
+package redis
+
+import (
+	"context"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
+	"github.com/redis/go-redis/v9"
+	"golang.org/x/sync/errgroup"
+)
+
+const (
+	defaultBatchSize       = 50
+	defaultConcurrentLimit = 3
+)
+
+// RedisShardManager is a class for sharding and processing keys
+type RedisShardManager struct {
+	redisClient redis.UniversalClient
+	config      *Config
+}
+type Config struct {
+	batchSize       int
+	continueOnError bool
+	concurrentLimit int
+}
+
+// Option is a function type for configuring Config
+type Option func(c *Config)
+
+// NewRedisShardManager creates a new RedisShardManager instance
+func NewRedisShardManager(redisClient redis.UniversalClient, opts ...Option) *RedisShardManager {
+	config := &Config{
+		batchSize:       defaultBatchSize, // Default batch size is 50 keys
+		continueOnError: false,
+		concurrentLimit: defaultConcurrentLimit, // Default concurrent limit is 3
+	}
+	for _, opt := range opts {
+		opt(config)
+	}
+	rsm := &RedisShardManager{
+		redisClient: redisClient,
+		config:      config,
+	}
+	return rsm
+}
+
+// WithBatchSize sets the number of keys to process per batch
+func WithBatchSize(size int) Option {
+	return func(c *Config) {
+		c.batchSize = size
+	}
+}
+
+// WithContinueOnError sets whether to continue processing on error
+func WithContinueOnError(continueOnError bool) Option {
+	return func(c *Config) {
+		c.continueOnError = continueOnError
+	}
+}
+
+// WithConcurrentLimit sets the concurrency limit
+func WithConcurrentLimit(limit int) Option {
+	return func(c *Config) {
+		c.concurrentLimit = limit
+	}
+}
+
+// ProcessKeysBySlot groups keys by their Redis cluster hash slots and processes them using the provided function.
+func (rsm *RedisShardManager) ProcessKeysBySlot(
+	ctx context.Context,
+	keys []string,
+	processFunc func(ctx context.Context, slot int64, keys []string) error,
+) error {
+
+	// Group keys by slot
+	slots, err := groupKeysBySlot(ctx, rsm.redisClient, keys)
+	if err != nil {
+		return err
+	}
+
+	g, ctx := errgroup.WithContext(ctx)
+	g.SetLimit(rsm.config.concurrentLimit)
+
+	// Process keys in each slot using the provided function
+	for slot, singleSlotKeys := range slots {
+		batches := splitIntoBatches(singleSlotKeys, rsm.config.batchSize)
+		for _, batch := range batches {
+			slot, batch := slot, batch // Avoid closure capture issue
+			g.Go(func() error {
+				err := processFunc(ctx, slot, batch)
+				if err != nil {
+					log.ZWarn(ctx, "Batch processFunc failed", err, "slot", slot, "keys", batch)
+					if !rsm.config.continueOnError {
+						return err
+					}
+				}
+				return nil
+			})
+		}
+	}
+
+	if err := g.Wait(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// groupKeysBySlot groups keys by their Redis cluster hash slots.
+func groupKeysBySlot(ctx context.Context, redisClient redis.UniversalClient, keys []string) (map[int64][]string, error) {
+	slots := make(map[int64][]string)
+	clusterClient, isCluster := redisClient.(*redis.ClusterClient)
+	if isCluster {
+		pipe := clusterClient.Pipeline()
+		cmds := make([]*redis.IntCmd, len(keys))
+		for i, key := range keys {
+			cmds[i] = pipe.ClusterKeySlot(ctx, key)
+		}
+		_, err := pipe.Exec(ctx)
+		if err != nil {
+			return nil, errs.WrapMsg(err, "get slot err")
+		}
+
+		for i, cmd := range cmds {
+			slot, err := cmd.Result()
+			if err != nil {
+				log.ZWarn(ctx, "some key get slot err", err, "key", keys[i])
+				return nil, errs.WrapMsg(err, "get slot err", "key", keys[i])
+			}
+			slots[slot] = append(slots[slot], keys[i])
+		}
+	} else {
+		// If not a cluster client, put all keys in the same slot (0)
+		slots[0] = keys
+	}
+
+	return slots, nil
+}
+
+// splitIntoBatches splits keys into batches of the specified size
+func splitIntoBatches(keys []string, batchSize int) [][]string {
+	var batches [][]string
+	for batchSize < len(keys) {
+		keys, batches = keys[batchSize:], append(batches, keys[0:batchSize:batchSize])
+	}
+	return append(batches, keys)
+}
+
+// ProcessKeysBySlot groups keys by their Redis cluster hash slots and processes them using the provided function.
+func ProcessKeysBySlot(
+	ctx context.Context,
+	redisClient redis.UniversalClient,
+	keys []string,
+	processFunc func(ctx context.Context, slot int64, keys []string) error,
+	opts ...Option,
+) error {
+
+	config := &Config{
+		batchSize:       defaultBatchSize,
+		continueOnError: false,
+		concurrentLimit: defaultConcurrentLimit,
+	}
+	for _, opt := range opts {
+		opt(config)
+	}
+
+	// Group keys by slot
+	slots, err := groupKeysBySlot(ctx, redisClient, keys)
+	if err != nil {
+		return err
+	}
+
+	g, ctx := errgroup.WithContext(ctx)
+	g.SetLimit(config.concurrentLimit)
+
+	// Process keys in each slot using the provided function
+	for slot, singleSlotKeys := range slots {
+		batches := splitIntoBatches(singleSlotKeys, config.batchSize)
+		for _, batch := range batches {
+			slot, batch := slot, batch // Avoid closure capture issue
+			g.Go(func() error {
+				err := processFunc(ctx, slot, batch)
+				if err != nil {
+					log.ZWarn(ctx, "Batch processFunc failed", err, "slot", slot, "keys", batch)
+					if !config.continueOnError {
+						return err
+					}
+				}
+				return nil
+			})
+		}
+	}
+
+	if err := g.Wait(); err != nil {
+		return err
+	}
+	return nil
+}

pkg/common/storage/cache/user.go

@@ -16,15 +16,15 @@ package cache
 
 import (
 	"context"
-	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/protocol/user"
 )
 
 type UserCache interface {
 	BatchDeleter
 	CloneUserCache() UserCache
-	GetUserInfo(ctx context.Context, userID string) (userInfo *relationtb.User, err error)
-	GetUsersInfo(ctx context.Context, userIDs []string) ([]*relationtb.User, error)
+	GetUserInfo(ctx context.Context, userID string) (userInfo *model.User, err error)
+	GetUsersInfo(ctx context.Context, userIDs []string) ([]*model.User, error)
 	DelUsersInfo(userIDs ...string) UserCache
 	GetUserGlobalRecvMsgOpt(ctx context.Context, userID string) (opt int, err error)
 	DelUsersGlobalRecvMsgOpt(userIDs ...string) UserCache