groupdb

pkg/common/db/cache/redis.go

@@ -0,0 +1,548 @@
+package cache
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	log2 "Open_IM/pkg/common/log"
+	pbChat "Open_IM/pkg/proto/msg"
+	pbRtc "Open_IM/pkg/proto/rtc"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"errors"
+	"fmt"
+	"strconv"
+	"time"
+
+	go_redis "github.com/go-redis/redis/v8"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+)
+
+const (
+	accountTempCode               = "ACCOUNT_TEMP_CODE"
+	resetPwdTempCode              = "RESET_PWD_TEMP_CODE"
+	userIncrSeq                   = "REDIS_USER_INCR_SEQ:" // user incr seq
+	appleDeviceToken              = "DEVICE_TOKEN"
+	userMinSeq                    = "REDIS_USER_MIN_SEQ:"
+	uidPidToken                   = "UID_PID_TOKEN_STATUS:"
+	conversationReceiveMessageOpt = "CON_RECV_MSG_OPT:"
+	getuiToken                    = "GETUI_TOKEN"
+	getuiTaskID                   = "GETUI_TASK_ID"
+	messageCache                  = "MESSAGE_CACHE:"
+	SignalCache                   = "SIGNAL_CACHE:"
+	SignalListCache               = "SIGNAL_LIST_CACHE:"
+	GlobalMsgRecvOpt              = "GLOBAL_MSG_RECV_OPT"
+	FcmToken                      = "FCM_TOKEN:"
+	groupUserMinSeq               = "GROUP_USER_MIN_SEQ:"
+	groupMaxSeq                   = "GROUP_MAX_SEQ:"
+	groupMinSeq                   = "GROUP_MIN_SEQ:"
+	sendMsgFailedFlag             = "SEND_MSG_FAILED_FLAG:"
+	userBadgeUnreadCountSum       = "USER_BADGE_UNREAD_COUNT_SUM:"
+	exTypeKeyLocker               = "EX_LOCK:"
+)
+
+func InitRedis(ctx context.Context) go_redis.UniversalClient {
+	var rdb go_redis.UniversalClient
+	var err error
+	if config.Config.Redis.EnableCluster {
+		rdb = go_redis.NewClusterClient(&go_redis.ClusterOptions{
+			Addrs:    config.Config.Redis.DBAddress,
+			Username: config.Config.Redis.DBUserName,
+			Password: config.Config.Redis.DBPassWord, // no password set
+			PoolSize: 50,
+		})
+		_, err = rdb.Ping(ctx).Result()
+		if err != nil {
+			fmt.Println("redis cluster failed address ", config.Config.Redis.DBAddress)
+			panic(err.Error() + " redis cluster " + config.Config.Redis.DBUserName + config.Config.Redis.DBPassWord)
+		}
+	} else {
+		rdb = go_redis.NewClient(&go_redis.Options{
+			Addr:     config.Config.Redis.DBAddress[0],
+			Username: config.Config.Redis.DBUserName,
+			Password: config.Config.Redis.DBPassWord, // no password set
+			DB:       0,                              // use default DB
+			PoolSize: 100,                            // 连接池大小
+		})
+		_, err = rdb.Ping(ctx).Result()
+		if err != nil {
+			panic(err.Error() + " redis " + config.Config.Redis.DBAddress[0] + config.Config.Redis.DBUserName + config.Config.Redis.DBPassWord)
+		}
+	}
+	return rdb
+}
+
+func NewRedisClient(rdb go_redis.UniversalClient) *RedisClient {
+	return &RedisClient{rdb: rdb}
+}
+
+type RedisClient struct {
+	rdb go_redis.UniversalClient
+}
+
+func (r *RedisClient) JudgeAccountEXISTS(account string) (bool, error) {
+	key := accountTempCode + account
+	n, err := r.rdb.Exists(context.Background(), key).Result()
+	if n > 0 {
+		return true, err
+	} else {
+		return false, err
+	}
+}
+
+func (r *RedisClient) SetAccountCode(account string, code, ttl int) (err error) {
+	key := accountTempCode + account
+	return r.rdb.Set(context.Background(), key, code, time.Duration(ttl)*time.Second).Err()
+}
+func (r *RedisClient) GetAccountCode(account string) (string, error) {
+	key := accountTempCode + account
+	return r.rdb.Get(context.Background(), key).Result()
+}
+
+//Perform seq auto-increment operation of user messages
+func (r *RedisClient) IncrUserSeq(uid string) (uint64, error) {
+	key := userIncrSeq + uid
+	seq, err := r.rdb.Incr(context.Background(), key).Result()
+	return uint64(seq), err
+}
+
+//Get the largest Seq
+func (r *RedisClient) GetUserMaxSeq(uid string) (uint64, error) {
+	key := userIncrSeq + uid
+	seq, err := r.rdb.Get(context.Background(), key).Result()
+	return uint64(utils.StringToInt(seq)), err
+}
+
+//set the largest Seq
+func (r *RedisClient) SetUserMaxSeq(uid string, maxSeq uint64) error {
+	key := userIncrSeq + uid
+	return r.rdb.Set(context.Background(), key, maxSeq, 0).Err()
+}
+
+//Set the user's minimum seq
+func (r *RedisClient) SetUserMinSeq(uid string, minSeq uint32) (err error) {
+	key := userMinSeq + uid
+	return r.rdb.Set(context.Background(), key, minSeq, 0).Err()
+}
+
+//Get the smallest Seq
+func (r *RedisClient) GetUserMinSeq(uid string) (uint64, error) {
+	key := userMinSeq + uid
+	seq, err := r.rdb.Get(context.Background(), key).Result()
+	return uint64(utils.StringToInt(seq)), err
+}
+
+func (r *RedisClient) SetGroupUserMinSeq(groupID, userID string, minSeq uint64) (err error) {
+	key := groupUserMinSeq + "g:" + groupID + "u:" + userID
+	return r.rdb.Set(context.Background(), key, minSeq, 0).Err()
+}
+func (r *RedisClient) GetGroupUserMinSeq(groupID, userID string) (uint64, error) {
+	key := groupUserMinSeq + "g:" + groupID + "u:" + userID
+	seq, err := r.rdb.Get(context.Background(), key).Result()
+	return uint64(utils.StringToInt(seq)), err
+}
+
+func (r *RedisClient) GetGroupMaxSeq(groupID string) (uint64, error) {
+	key := groupMaxSeq + groupID
+	seq, err := r.rdb.Get(context.Background(), key).Result()
+	return uint64(utils.StringToInt(seq)), err
+}
+
+func (r *RedisClient) IncrGroupMaxSeq(groupID string) (uint64, error) {
+	key := groupMaxSeq + groupID
+	seq, err := r.rdb.Incr(context.Background(), key).Result()
+	return uint64(seq), err
+}
+
+func (r *RedisClient) SetGroupMaxSeq(groupID string, maxSeq uint64) error {
+	key := groupMaxSeq + groupID
+	return r.rdb.Set(context.Background(), key, maxSeq, 0).Err()
+}
+
+func (r *RedisClient) SetGroupMinSeq(groupID string, minSeq uint32) error {
+	key := groupMinSeq + groupID
+	return r.rdb.Set(context.Background(), key, minSeq, 0).Err()
+}
+
+//Store userid and platform class to redis
+func (r *RedisClient) AddTokenFlag(userID string, platformID int, token string, flag int) error {
+	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
+	log2.NewDebug("", "add token key is ", key)
+	return r.rdb.HSet(context.Background(), key, token, flag).Err()
+}
+
+func (r *RedisClient) GetTokenMapByUidPid(userID, platformID string) (map[string]int, error) {
+	key := uidPidToken + userID + ":" + platformID
+	log2.NewDebug("", "get token key is ", key)
+	m, err := r.rdb.HGetAll(context.Background(), key).Result()
+	mm := make(map[string]int)
+	for k, v := range m {
+		mm[k] = utils.StringToInt(v)
+	}
+	return mm, err
+}
+func (r *RedisClient) SetTokenMapByUidPid(userID string, platformID int, m map[string]int) error {
+	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
+	mm := make(map[string]interface{})
+	for k, v := range m {
+		mm[k] = v
+	}
+	return r.rdb.HSet(context.Background(), key, mm).Err()
+}
+func (r *RedisClient) DeleteTokenByUidPid(userID string, platformID int, fields []string) error {
+	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
+	return r.rdb.HDel(context.Background(), key, fields...).Err()
+}
+func (r *RedisClient) SetSingleConversationRecvMsgOpt(userID, conversationID string, opt int32) error {
+	key := conversationReceiveMessageOpt + userID
+	return r.rdb.HSet(context.Background(), key, conversationID, opt).Err()
+}
+
+func (r *RedisClient) GetSingleConversationRecvMsgOpt(userID, conversationID string) (int, error) {
+	key := conversationReceiveMessageOpt + userID
+	result, err := r.rdb.HGet(context.Background(), key, conversationID).Result()
+	return utils.StringToInt(result), err
+}
+func (r *RedisClient) SetUserGlobalMsgRecvOpt(userID string, opt int32) error {
+	key := conversationReceiveMessageOpt + userID
+	return r.rdb.HSet(context.Background(), key, GlobalMsgRecvOpt, opt).Err()
+}
+func (r *RedisClient) GetUserGlobalMsgRecvOpt(userID string) (int, error) {
+	key := conversationReceiveMessageOpt + userID
+	result, err := r.rdb.HGet(context.Background(), key, GlobalMsgRecvOpt).Result()
+	if err != nil {
+		if err == go_redis.Nil {
+			return 0, nil
+		} else {
+			return 0, err
+		}
+	}
+	return utils.StringToInt(result), err
+}
+func (r *RedisClient) GetMessageListBySeq(userID string, seqList []uint32, operationID string) (seqMsg []*pbCommon.MsgData, failedSeqList []uint32, errResult error) {
+	for _, v := range seqList {
+		//MESSAGE_CACHE:169.254.225.224_reliability1653387820_0_1
+		key := messageCache + userID + "_" + strconv.Itoa(int(v))
+		result, err := r.rdb.Get(context.Background(), key).Result()
+		if err != nil {
+			errResult = err
+			failedSeqList = append(failedSeqList, v)
+			log2.Debug(operationID, "redis get message error: ", err.Error(), v)
+		} else {
+			msg := pbCommon.MsgData{}
+			err = jsonpb.UnmarshalString(result, &msg)
+			if err != nil {
+				errResult = err
+				failedSeqList = append(failedSeqList, v)
+				log2.NewWarn(operationID, "Unmarshal err ", result, err.Error())
+			} else {
+				log2.NewDebug(operationID, "redis get msg is ", msg.String())
+				seqMsg = append(seqMsg, &msg)
+			}
+
+		}
+	}
+	return seqMsg, failedSeqList, errResult
+}
+
+func (r *RedisClient) SetMessageToCache(msgList []*pbChat.MsgDataToMQ, uid string, operationID string) (error, int) {
+	ctx := context.Background()
+	pipe := r.rdb.Pipeline()
+	var failedList []pbChat.MsgDataToMQ
+	for _, msg := range msgList {
+		key := messageCache + uid + "_" + strconv.Itoa(int(msg.MsgData.Seq))
+		s, err := utils.Pb2String(msg.MsgData)
+		if err != nil {
+			log2.NewWarn(operationID, utils.GetSelfFuncName(), "Pb2String failed", msg.MsgData.String(), uid, err.Error())
+			continue
+		}
+		log2.NewDebug(operationID, "convert string is ", s)
+		err = pipe.Set(ctx, key, s, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err()
+		//err = r.rdb.HMSet(context.Background(), "12", map[string]interface{}{"1": 2, "343": false}).Err()
+		if err != nil {
+			log2.NewWarn(operationID, utils.GetSelfFuncName(), "redis failed", "args:", key, *msg, uid, s, err.Error())
+			failedList = append(failedList, *msg)
+		}
+	}
+	if len(failedList) != 0 {
+		return errors.New(fmt.Sprintf("set msg to cache failed, failed lists: %q,%s", failedList, operationID)), len(failedList)
+	}
+	_, err := pipe.Exec(ctx)
+	return err, 0
+}
+func (r *RedisClient) DeleteMessageFromCache(msgList []*pbChat.MsgDataToMQ, uid string, operationID string) error {
+	ctx := context.Background()
+	for _, msg := range msgList {
+		key := messageCache + uid + "_" + strconv.Itoa(int(msg.MsgData.Seq))
+		err := r.rdb.Del(ctx, key).Err()
+		if err != nil {
+			log2.NewWarn(operationID, utils.GetSelfFuncName(), "redis failed", "args:", key, uid, err.Error(), msgList)
+		}
+	}
+	return nil
+}
+
+func (r *RedisClient) CleanUpOneUserAllMsgFromRedis(userID string, operationID string) error {
+	ctx := context.Background()
+	key := messageCache + userID + "_" + "*"
+	vals, err := r.rdb.Keys(ctx, key).Result()
+	log2.Debug(operationID, "vals: ", vals)
+	if err == go_redis.Nil {
+		return nil
+	}
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	for _, v := range vals {
+		err = r.rdb.Del(ctx, v).Err()
+	}
+	return nil
+}
+
+func (r *RedisClient) HandleSignalInfo(operationID string, msg *pbCommon.MsgData, pushToUserID string) (isSend bool, err error) {
+	req := &pbRtc.SignalReq{}
+	if err := proto.Unmarshal(msg.Content, req); err != nil {
+		return false, err
+	}
+	//log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "SignalReq: ", req.String())
+	var inviteeUserIDList []string
+	var isInviteSignal bool
+	switch signalInfo := req.Payload.(type) {
+	case *pbRtc.SignalReq_Invite:
+		inviteeUserIDList = signalInfo.Invite.Invitation.InviteeUserIDList
+		isInviteSignal = true
+	case *pbRtc.SignalReq_InviteInGroup:
+		inviteeUserIDList = signalInfo.InviteInGroup.Invitation.InviteeUserIDList
+		isInviteSignal = true
+		if !utils.IsContain(pushToUserID, inviteeUserIDList) {
+			return false, nil
+		}
+	case *pbRtc.SignalReq_HungUp, *pbRtc.SignalReq_Cancel, *pbRtc.SignalReq_Reject, *pbRtc.SignalReq_Accept:
+		return false, errors.New("signalInfo do not need offlinePush")
+	default:
+		log2.NewDebug(operationID, utils.GetSelfFuncName(), "req invalid type", string(msg.Content))
+		return false, nil
+	}
+	if isInviteSignal {
+		log2.NewDebug(operationID, utils.GetSelfFuncName(), "invite userID list:", inviteeUserIDList)
+		for _, userID := range inviteeUserIDList {
+			log2.NewInfo(operationID, utils.GetSelfFuncName(), "invite userID:", userID)
+			timeout, err := strconv.Atoi(config.Config.Rtc.SignalTimeout)
+			if err != nil {
+				return false, err
+			}
+			keyList := SignalListCache + userID
+			err = r.rdb.LPush(context.Background(), keyList, msg.ClientMsgID).Err()
+			if err != nil {
+				return false, err
+			}
+			err = r.rdb.Expire(context.Background(), keyList, time.Duration(timeout)*time.Second).Err()
+			if err != nil {
+				return false, err
+			}
+			key := SignalCache + msg.ClientMsgID
+			err = r.rdb.Set(context.Background(), key, msg.Content, time.Duration(timeout)*time.Second).Err()
+			if err != nil {
+				return false, err
+			}
+		}
+	}
+	return true, nil
+}
+
+func (r *RedisClient) GetSignalInfoFromCacheByClientMsgID(clientMsgID string) (invitationInfo *pbRtc.SignalInviteReq, err error) {
+	key := SignalCache + clientMsgID
+	invitationInfo = &pbRtc.SignalInviteReq{}
+	bytes, err := r.rdb.Get(context.Background(), key).Bytes()
+	if err != nil {
+		return nil, err
+	}
+	req := &pbRtc.SignalReq{}
+	if err = proto.Unmarshal(bytes, req); err != nil {
+		return nil, err
+	}
+	switch req2 := req.Payload.(type) {
+	case *pbRtc.SignalReq_Invite:
+		invitationInfo.Invitation = req2.Invite.Invitation
+		invitationInfo.OpUserID = req2.Invite.OpUserID
+	case *pbRtc.SignalReq_InviteInGroup:
+		invitationInfo.Invitation = req2.InviteInGroup.Invitation
+		invitationInfo.OpUserID = req2.InviteInGroup.OpUserID
+	}
+	return invitationInfo, err
+}
+
+func (r *RedisClient) GetAvailableSignalInvitationInfo(userID string) (invitationInfo *pbRtc.SignalInviteReq, err error) {
+	keyList := SignalListCache + userID
+	result := r.rdb.LPop(context.Background(), keyList)
+	if err = result.Err(); err != nil {
+		return nil, utils.Wrap(err, "GetAvailableSignalInvitationInfo failed")
+	}
+	key, err := result.Result()
+	if err != nil {
+		return nil, utils.Wrap(err, "GetAvailableSignalInvitationInfo failed")
+	}
+	log2.NewDebug("", utils.GetSelfFuncName(), result, result.String())
+	invitationInfo, err = r.GetSignalInfoFromCacheByClientMsgID(key)
+	if err != nil {
+		return nil, utils.Wrap(err, "GetSignalInfoFromCacheByClientMsgID")
+	}
+	err = r.DelUserSignalList(userID)
+	if err != nil {
+		return nil, utils.Wrap(err, "GetSignalInfoFromCacheByClientMsgID")
+	}
+	return invitationInfo, nil
+}
+
+func (r *RedisClient) DelUserSignalList(userID string) error {
+	keyList := SignalListCache + userID
+	err := r.rdb.Del(context.Background(), keyList).Err()
+	return err
+}
+
+func (r *RedisClient) DelMsgFromCache(uid string, seqList []uint32, operationID string) {
+	for _, seq := range seqList {
+		key := messageCache + uid + "_" + strconv.Itoa(int(seq))
+		result, err := r.rdb.Get(context.Background(), key).Result()
+		if err != nil {
+			if err == go_redis.Nil {
+				log2.NewDebug(operationID, utils.GetSelfFuncName(), err.Error(), "redis nil")
+			} else {
+				log2.NewError(operationID, utils.GetSelfFuncName(), err.Error(), key)
+			}
+			continue
+		}
+		var msg pbCommon.MsgData
+		if err := utils.String2Pb(result, &msg); err != nil {
+			log2.Error(operationID, utils.GetSelfFuncName(), "String2Pb failed", msg, result, key, err.Error())
+			continue
+		}
+		msg.Status = constant.MsgDeleted
+		s, err := utils.Pb2String(&msg)
+		if err != nil {
+			log2.Error(operationID, utils.GetSelfFuncName(), "Pb2String failed", msg, err.Error())
+			continue
+		}
+		if err := r.rdb.Set(context.Background(), key, s, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err(); err != nil {
+			log2.Error(operationID, utils.GetSelfFuncName(), "Set failed", err.Error())
+		}
+	}
+}
+
+func (r *RedisClient) SetGetuiToken(token string, expireTime int64) error {
+	return r.rdb.Set(context.Background(), getuiToken, token, time.Duration(expireTime)*time.Second).Err()
+}
+
+func (r *RedisClient) GetGetuiToken() (string, error) {
+	result, err := r.rdb.Get(context.Background(), getuiToken).Result()
+	return result, err
+}
+
+func (r *RedisClient) SetGetuiTaskID(taskID string, expireTime int64) error {
+	return r.rdb.Set(context.Background(), getuiTaskID, taskID, time.Duration(expireTime)*time.Second).Err()
+}
+
+func (r *RedisClient) GetGetuiTaskID() (string, error) {
+	result, err := r.rdb.Get(context.Background(), getuiTaskID).Result()
+	return result, err
+}
+
+func (r *RedisClient) SetSendMsgStatus(status int32, operationID string) error {
+	return r.rdb.Set(context.Background(), sendMsgFailedFlag+operationID, status, time.Hour*24).Err()
+}
+
+func (r *RedisClient) GetSendMsgStatus(operationID string) (int, error) {
+	result, err := r.rdb.Get(context.Background(), sendMsgFailedFlag+operationID).Result()
+	if err != nil {
+		return 0, err
+	}
+	status, err := strconv.Atoi(result)
+	return status, err
+}
+
+func (r *RedisClient) SetFcmToken(account string, platformID int, fcmToken string, expireTime int64) (err error) {
+	key := FcmToken + account + ":" + strconv.Itoa(platformID)
+	return r.rdb.Set(context.Background(), key, fcmToken, time.Duration(expireTime)*time.Second).Err()
+}
+
+func (r *RedisClient) GetFcmToken(account string, platformID int) (string, error) {
+	key := FcmToken + account + ":" + strconv.Itoa(platformID)
+	return r.rdb.Get(context.Background(), key).Result()
+}
+func (r *RedisClient) DelFcmToken(account string, platformID int) error {
+	key := FcmToken + account + ":" + strconv.Itoa(platformID)
+	return r.rdb.Del(context.Background(), key).Err()
+}
+func (r *RedisClient) IncrUserBadgeUnreadCountSum(uid string) (int, error) {
+	key := userBadgeUnreadCountSum + uid
+	seq, err := r.rdb.Incr(context.Background(), key).Result()
+	return int(seq), err
+}
+func (r *RedisClient) SetUserBadgeUnreadCountSum(uid string, value int) error {
+	key := userBadgeUnreadCountSum + uid
+	return r.rdb.Set(context.Background(), key, value, 0).Err()
+}
+func (r *RedisClient) GetUserBadgeUnreadCountSum(uid string) (int, error) {
+	key := userBadgeUnreadCountSum + uid
+	seq, err := r.rdb.Get(context.Background(), key).Result()
+	return utils.StringToInt(seq), err
+}
+func (r *RedisClient) JudgeMessageReactionEXISTS(clientMsgID string, sessionType int32) (bool, error) {
+	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+	n, err := r.rdb.Exists(context.Background(), key).Result()
+	if n > 0 {
+		return true, err
+	} else {
+		return false, err
+	}
+}
+
+func (r *RedisClient) GetOneMessageAllReactionList(clientMsgID string, sessionType int32) (map[string]string, error) {
+	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+	return r.rdb.HGetAll(context.Background(), key).Result()
+
+}
+func (r *RedisClient) DeleteOneMessageKey(clientMsgID string, sessionType int32, subKey string) error {
+	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+	return r.rdb.HDel(context.Background(), key, subKey).Err()
+
+}
+func (r *RedisClient) SetMessageReactionExpire(clientMsgID string, sessionType int32, expiration time.Duration) (bool, error) {
+	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+	return r.rdb.Expire(context.Background(), key, expiration).Result()
+}
+func (r *RedisClient) GetMessageTypeKeyValue(clientMsgID string, sessionType int32, typeKey string) (string, error) {
+	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+	result, err := r.rdb.HGet(context.Background(), key, typeKey).Result()
+	return result, err
+
+}
+func (r *RedisClient) SetMessageTypeKeyValue(clientMsgID string, sessionType int32, typeKey, value string) error {
+	key := getMessageReactionExPrefix(clientMsgID, sessionType)
+	return r.rdb.HSet(context.Background(), key, typeKey, value).Err()
+
+}
+func (r *RedisClient) LockMessageTypeKey(clientMsgID string, TypeKey string) error {
+	key := exTypeKeyLocker + clientMsgID + "_" + TypeKey
+	return r.rdb.SetNX(context.Background(), key, 1, time.Minute).Err()
+}
+func (r *RedisClient) UnLockMessageTypeKey(clientMsgID string, TypeKey string) error {
+	key := exTypeKeyLocker + clientMsgID + "_" + TypeKey
+	return r.rdb.Del(context.Background(), key).Err()
+
+}
+
+func getMessageReactionExPrefix(clientMsgID string, sessionType int32) string {
+	switch sessionType {
+	case constant.SingleChatType:
+		return "EX_SINGLE_" + clientMsgID
+	case constant.GroupChatType:
+		return "EX_GROUP_" + clientMsgID
+	case constant.SuperGroupChatType:
+		return "EX_SUPER_GROUP_" + clientMsgID
+	case constant.NotificationChatType:
+		return "EX_NOTIFICATION" + clientMsgID
+	}
+	return ""
+}

pkg/common/db/cache/redisModel_test.go

@@ -0,0 +1,142 @@
+package cache
+
+import (
+	"Open_IM/pkg/common/constant"
+	pbChat "Open_IM/pkg/proto/msg"
+	server_api_params "Open_IM/pkg/proto/sdk_ws"
+	"context"
+	"flag"
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func Test_SetTokenMapByUidPid(t *testing.T) {
+	m := make(map[string]int, 0)
+	m["test1"] = 1
+	m["test2"] = 2
+	m["2332"] = 4
+	err := DB.SetTokenMapByUidPid("1234", 2, m)
+	assert.Nil(t, err)
+
+}
+func Test_GetTokenMapByUidPid(t *testing.T) {
+	m, err := DB.GetTokenMapByUidPid("1234", "Android")
+	assert.Nil(t, err)
+	fmt.Println(m)
+}
+
+//func TestDataBases_GetMultiConversationMsgOpt(t *testing.T) {
+//	m, err := DB.GetMultiConversationMsgOpt("fg", []string{"user", "age", "color"})
+//	assert.Nil(t, err)
+//	fmt.Println(m)
+//}
+func Test_GetKeyTTL(t *testing.T) {
+	ctx := context.Background()
+	key := flag.String("key", "key", "key value")
+	flag.Parse()
+	ttl, err := DB.RDB.TTL(ctx, *key).Result()
+	assert.Nil(t, err)
+	fmt.Println(ttl)
+}
+func Test_HGetAll(t *testing.T) {
+	ctx := context.Background()
+	key := flag.String("key", "key", "key value")
+	flag.Parse()
+	ttl, err := DB.RDB.TTL(ctx, *key).Result()
+	assert.Nil(t, err)
+	fmt.Println(ttl)
+}
+
+func Test_NewSetMessageToCache(t *testing.T) {
+	var msg pbChat.MsgDataToMQ
+	m := make(map[string]bool)
+	var offlinePush server_api_params.OfflinePushInfo
+	offlinePush.Title = "3"
+	offlinePush.Ex = "34"
+	offlinePush.IOSPushSound = "+1"
+	offlinePush.IOSBadgeCount = true
+	m[constant.IsPersistent] = true
+	m[constant.IsHistory] = true
+	var data server_api_params.MsgData
+	uid := "test_uid"
+	data.Seq = 11
+	data.ClientMsgID = "23jwhjsdf"
+	data.SendID = "111"
+	data.RecvID = "222"
+	data.Content = []byte{1, 2, 3, 4, 5, 6, 7}
+	data.Seq = 1212
+	data.Options = m
+	data.OfflinePushInfo = &offlinePush
+	data.AtUserIDList = []string{"1212", "23232"}
+	msg.MsgData = &data
+	messageList := []*pbChat.MsgDataToMQ{&msg}
+	err, _ := DB.SetMessageToCache(messageList, uid, "cacheTest")
+	assert.Nil(t, err)
+
+}
+func Test_NewGetMessageListBySeq(t *testing.T) {
+	var msg pbChat.MsgDataToMQ
+	var data server_api_params.MsgData
+	uid := "test_uid"
+	data.Seq = 11
+	data.ClientMsgID = "23jwhjsdf"
+	msg.MsgData = &data
+
+	seqMsg, failedSeqList, err := DB.GetMessageListBySeq(uid, []uint32{1212}, "cacheTest")
+	assert.Nil(t, err)
+	fmt.Println(seqMsg, failedSeqList)
+
+}
+func Test_SetUserGlobalMsgRecvOpt(t *testing.T) {
+	var opt int32
+	uid := "test_uid"
+	opt = 1
+	err := DB.SetUserGlobalMsgRecvOpt(uid, opt)
+	assert.Nil(t, err)
+}
+func Test_GetUserGlobalMsgRecvOpt(t *testing.T) {
+	uid := "test_uid"
+	opt, err := DB.GetUserGlobalMsgRecvOpt(uid)
+	assert.Nil(t, err)
+	fmt.Println("get opt", opt)
+}
+func Test_JudgeAccountEXISTS(t *testing.T) {
+	uid := "test_uid"
+	b, err := DB.JudgeAccountEXISTS(uid)
+	assert.Nil(t, err)
+	fmt.Println(b)
+}
+func Test_SetAccountCode(t *testing.T) {
+	uid := "test_uid"
+	code := 666666
+	err := DB.SetAccountCode(uid, code, 100)
+	assert.Nil(t, err)
+}
+func Test_GetAccountCode(t *testing.T) {
+	uid := "test_uid"
+	code, err := DB.GetAccountCode(uid)
+	assert.Nil(t, err)
+	fmt.Println(code)
+}
+func Test_SetFcmToken(t *testing.T) {
+	uid := "test_uid"
+	token := "dfnWBtOjSj-XIZnUvDlegv:APA91bG09XTtiXfpE6U7gUVMOhnKcUkNCv4WHn0UZr2clUi-tS1jEH-HiCEW8GIAhjLIGcfUJ6NIKteC023ZxDH7J0PJ5sTxoup3fHDUPLU7KgQoZS4tPyFqCbZ6bRB7esDPEnD1n_s0"
+	platformID := 2
+	err := DB.SetFcmToken(uid, platformID, token, 0)
+	assert.Nil(t, err)
+}
+func Test_GetFcmToken(t *testing.T) {
+	uid := "test_uid"
+	platformID := 2
+	token, err := DB.GetFcmToken(uid, platformID)
+	assert.Nil(t, err)
+	fmt.Println("token is :", token)
+}
+
+//func Test_GetGroupMemberList(t *testing.T) {
+//	groupID := "3791742301"
+//	list, err := DB.GetGroupMemberIDListFromCache(groupID)
+//	assert.Nil(t, err)
+//	fmt.Println(list)
+//}

pkg/common/db/cache/rockscache.go

@@ -0,0 +1,649 @@
+package cache
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db/mongo"
+	"Open_IM/pkg/common/db/mysql"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/trace_log"
+	"Open_IM/pkg/utils"
+	"context"
+	"encoding/json"
+	"github.com/dtm-labs/rockscache"
+	"github.com/go-redis/redis/v8"
+	"math/big"
+	"sort"
+	"strconv"
+	"time"
+)
+
+const (
+	userInfoCache             = "USER_INFO_CACHE:"
+	friendRelationCache       = "FRIEND_RELATION_CACHE:"
+	blackListCache            = "BLACK_LIST_CACHE:"
+	groupCache                = "GROUP_CACHE:"
+	groupInfoCache            = "GROUP_INFO_CACHE:"
+	groupOwnerIDCache         = "GROUP_OWNER_ID:"
+	joinedGroupListCache      = "JOINED_GROUP_LIST_CACHE:"
+	groupMemberInfoCache      = "GROUP_MEMBER_INFO_CACHE:"
+	groupAllMemberInfoCache   = "GROUP_ALL_MEMBER_INFO_CACHE:"
+	allFriendInfoCache        = "ALL_FRIEND_INFO_CACHE:"
+	joinedSuperGroupListCache = "JOINED_SUPER_GROUP_LIST_CACHE:"
+	groupMemberListHashCache  = "GROUP_MEMBER_LIST_HASH_CACHE:"
+	groupMemberNumCache       = "GROUP_MEMBER_NUM_CACHE:"
+	conversationCache         = "CONVERSATION_CACHE:"
+	conversationIDListCache   = "CONVERSATION_ID_LIST_CACHE:"
+	extendMsgSetCache         = "EXTEND_MSG_SET_CACHE:"
+	extendMsgCache            = "EXTEND_MSG_CACHE:"
+)
+
+const scanCount = 3000
+
+type RcClient struct {
+	rdb        redis.UniversalClient
+	Cache      *rockscache.Client
+	ExpireTime time.Duration
+}
+
+func NewRcClient(rdb redis.UniversalClient, expireTime time.Duration, opts rockscache.Options) *RcClient {
+	return &RcClient{Cache: rockscache.NewClient(rdb, opts), ExpireTime: expireTime}
+}
+
+func (rc *RcClient) DelKeys() {
+	for _, key := range []string{groupCache, friendRelationCache, blackListCache, userInfoCache, groupInfoCache, groupOwnerIDCache, joinedGroupListCache,
+		groupMemberInfoCache, groupAllMemberInfoCache, allFriendInfoCache} {
+		fName := utils.GetSelfFuncName()
+		var cursor uint64
+		var n int
+		for {
+			var keys []string
+			var err error
+			keys, cursor, err = rc.rdb.Scan(context.Background(), cursor, key+"*", scanCount).Result()
+			if err != nil {
+				panic(err.Error())
+			}
+			n += len(keys)
+			// for each for redis cluster
+			for _, key := range keys {
+				if err = rc.rdb.Del(context.Background(), key).Err(); err != nil {
+					log.NewError("", fName, key, err.Error())
+					err = rc.rdb.Del(context.Background(), key).Err()
+					if err != nil {
+						panic(err.Error())
+					}
+				}
+			}
+			if cursor == 0 {
+				break
+			}
+		}
+	}
+}
+
+func (rc *RcClient) GetFriendIDListFromCache(ctx context.Context, userID string) (friendIDList []string, err error) {
+	getFriendIDList := func() (string, error) {
+		friendIDList, err := mysql.GetFriendIDListByUserID(userID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(friendIDList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friendIDList", friendIDList)
+	}()
+	friendIDListStr, err := db.DB.Rc.Fetch(friendRelationCache+userID, time.Second*30*60, getFriendIDList)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = json.Unmarshal([]byte(friendIDListStr), &friendIDList)
+	return friendIDList, utils.Wrap(err, "")
+}
+
+func DelFriendIDListFromCache(ctx context.Context, userID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+	}()
+	return db.DB.Rc.TagAsDeleted(friendRelationCache + userID)
+}
+
+func GetBlackListFromCache(ctx context.Context, userID string) (blackIDs []string, err error) {
+	getBlackIDList := func() (string, error) {
+		blackIDs, err := mysql.GetBlackIDListByUserID(userID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(blackIDs)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "blackIDList", blackIDs)
+	}()
+	blackIDListStr, err := db.DB.Rc.Fetch(blackListCache+userID, time.Second*30*60, getBlackIDList)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = json.Unmarshal([]byte(blackIDListStr), &blackIDs)
+	return blackIDs, utils.Wrap(err, "")
+}
+
+func DelBlackIDListFromCache(ctx context.Context, userID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ctx", ctx)
+	}()
+	return db.DB.Rc.TagAsDeleted(blackListCache + userID)
+}
+
+func GetJoinedGroupIDListFromCache(ctx context.Context, userID string) (joinedGroupList []string, err error) {
+	getJoinedGroupIDList := func() (string, error) {
+		joinedGroupList, err := mysql.GetJoinedGroupIDListByUserID(userID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(joinedGroupList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedGroupList", joinedGroupList)
+	}()
+	joinedGroupIDListStr, err := db.DB.Rc.Fetch(joinedGroupListCache+userID, time.Second*30*60, getJoinedGroupIDList)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = json.Unmarshal([]byte(joinedGroupIDListStr), &joinedGroupList)
+	return joinedGroupList, utils.Wrap(err, "")
+}
+
+func DelJoinedGroupIDListFromCache(ctx context.Context, userID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+	}()
+	return db.DB.Rc.TagAsDeleted(joinedGroupListCache + userID)
+}
+
+func GetGroupMemberIDListFromCache(ctx context.Context, groupID string) (groupMemberIDList []string, err error) {
+	f := func() (string, error) {
+		groupInfo, err := GetGroupInfoFromCache(ctx, groupID)
+		if err != nil {
+			return "", utils.Wrap(err, "GetGroupInfoFromCache failed")
+		}
+		var groupMemberIDList []string
+		if groupInfo.GroupType == constant.SuperGroup {
+			superGroup, err := db.DB.GetSuperGroup(groupID)
+			if err != nil {
+				return "", utils.Wrap(err, "")
+			}
+			groupMemberIDList = superGroup.MemberIDList
+		} else {
+			groupMemberIDList, err = mysql.GetGroupMemberIDListByGroupID(groupID)
+			if err != nil {
+				return "", utils.Wrap(err, "")
+			}
+		}
+		bytes, err := json.Marshal(groupMemberIDList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMemberIDList", groupMemberIDList)
+	}()
+	groupIDListStr, err := db.DB.Rc.Fetch(groupCache+groupID, time.Second*30*60, f)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = json.Unmarshal([]byte(groupIDListStr), &groupMemberIDList)
+	return groupMemberIDList, utils.Wrap(err, "")
+}
+
+func DelGroupMemberIDListFromCache(ctx context.Context, groupID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+	}()
+	return db.DB.Rc.TagAsDeleted(groupCache + groupID)
+}
+
+func GetUserInfoFromCache(ctx context.Context, userID string) (userInfo *mysql.User, err error) {
+	getUserInfo := func() (string, error) {
+		userInfo, err := mysql.GetUserByUserID(userID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(userInfo)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "userInfo", *userInfo)
+	}()
+	userInfoStr, err := db.DB.Rc.Fetch(userInfoCache+userID, time.Second*30*60, getUserInfo)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	userInfo = &mysql.User{}
+	err = json.Unmarshal([]byte(userInfoStr), userInfo)
+	return userInfo, utils.Wrap(err, "")
+}
+
+func GetUserInfoFromCacheBatch(ctx context.Context, userIDs []string) ([]*mysql.User, error) {
+	var users []*mysql.User
+	for _, userID := range userIDs {
+		user, err := GetUserInfoFromCache(ctx, userID)
+		if err != nil {
+			return nil, err
+		}
+		users = append(users, user)
+	}
+	return users, nil
+}
+
+func DelUserInfoFromCache(ctx context.Context, userID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+	}()
+	return db.DB.Rc.TagAsDeleted(userInfoCache + userID)
+}
+
+func GetGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (groupMember *mysql.GroupMember, err error) {
+	getGroupMemberInfo := func() (string, error) {
+		groupMemberInfo, err := mysql.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(groupMemberInfo)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
+	}()
+	groupMemberInfoStr, err := db.DB.Rc.Fetch(groupMemberInfoCache+groupID+"-"+userID, time.Second*30*60, getGroupMemberInfo)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	groupMember = &mysql.GroupMember{}
+	err = json.Unmarshal([]byte(groupMemberInfoStr), groupMember)
+	return groupMember, utils.Wrap(err, "")
+}
+
+func DelGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID)
+	}()
+	return db.DB.Rc.TagAsDeleted(groupMemberInfoCache + groupID + "-" + userID)
+}
+
+func GetGroupMembersInfoFromCache(ctx context.Context, count, offset int32, groupID string) (groupMembers []*mysql.GroupMember, err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "count", count, "offset", offset, "groupID", groupID, "groupMember", groupMembers)
+	}()
+	groupMemberIDList, err := GetGroupMemberIDListFromCache(ctx, groupID)
+	if err != nil {
+		return nil, err
+	}
+	if count < 0 || offset < 0 {
+		return nil, nil
+	}
+	var groupMemberList []*mysql.GroupMember
+	var start, stop int32
+	start = offset
+	stop = offset + count
+	l := int32(len(groupMemberIDList))
+	if start > stop {
+		return nil, nil
+	}
+	if start >= l {
+		return nil, nil
+	}
+	if count != 0 {
+		if stop >= l {
+			stop = l
+		}
+		groupMemberIDList = groupMemberIDList[start:stop]
+	} else {
+		if l < 1000 {
+			stop = l
+		} else {
+			stop = 1000
+		}
+		groupMemberIDList = groupMemberIDList[start:stop]
+	}
+	//log.NewDebug("", utils.GetSelfFuncName(), "ID list: ", groupMemberIDList)
+	for _, userID := range groupMemberIDList {
+		groupMember, err := GetGroupMemberInfoFromCache(ctx, groupID, userID)
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), err.Error(), groupID, userID)
+			continue
+		}
+		groupMembers = append(groupMembers, groupMember)
+	}
+	return groupMemberList, nil
+}
+
+func GetAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (groupMembers []*mysql.GroupMember, err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMembers", groupMembers)
+	}()
+	getGroupMemberInfo := func() (string, error) {
+		groupMembers, err := mysql.GetGroupMemberListByGroupID(groupID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(groupMembers)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	groupMembersStr, err := db.DB.Rc.Fetch(groupAllMemberInfoCache+groupID, time.Second*30*60, getGroupMemberInfo)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = json.Unmarshal([]byte(groupMembersStr), &groupMembers)
+	return groupMembers, utils.Wrap(err, "")
+}
+
+func DelAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+	}()
+	return db.DB.Rc.TagAsDeleted(groupAllMemberInfoCache + groupID)
+}
+
+func GetGroupInfoFromCache(ctx context.Context, groupID string) (groupInfo *mysql.Group, err error) {
+	getGroupInfo := func() (string, error) {
+		groupInfo, err := mysql.GetGroupInfoByGroupID(groupID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(groupInfo)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	groupInfo = &mysql.Group{}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupInfo", groupInfo)
+	}()
+	groupInfoStr, err := db.DB.Rc.Fetch(groupInfoCache+groupID, time.Second*30*60, getGroupInfo)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = json.Unmarshal([]byte(groupInfoStr), groupInfo)
+	return groupInfo, utils.Wrap(err, "")
+}
+
+func DelGroupInfoFromCache(ctx context.Context, groupID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+	}()
+	return db.DB.Rc.TagAsDeleted(groupInfoCache + groupID)
+}
+
+func GetAllFriendsInfoFromCache(ctx context.Context, userID string) (friends []*mysql.Friend, err error) {
+	getAllFriendInfo := func() (string, error) {
+		friendInfoList, err := mysql.GetFriendListByUserID(userID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(friendInfoList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friends", friends)
+	}()
+	allFriendInfoStr, err := db.DB.Rc.Fetch(allFriendInfoCache+userID, time.Second*30*60, getAllFriendInfo)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	err = json.Unmarshal([]byte(allFriendInfoStr), &friends)
+	return friends, utils.Wrap(err, "")
+}
+
+func DelAllFriendsInfoFromCache(ctx context.Context, userID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+	}()
+	return db.DB.Rc.TagAsDeleted(allFriendInfoCache + userID)
+}
+
+func GetJoinedSuperGroupListFromCache(ctx context.Context, userID string) (joinedSuperGroupIDs []string, err error) {
+	getJoinedSuperGroupIDList := func() (string, error) {
+		userToSuperGroup, err := db.DB.GetSuperGroupByUserID(userID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		bytes, err := json.Marshal(userToSuperGroup.GroupIDList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedSuperGroupIDs", joinedSuperGroupIDs)
+	}()
+	joinedSuperGroupListStr, err := db.DB.Rc.Fetch(joinedSuperGroupListCache+userID, time.Second*30*60, getJoinedSuperGroupIDList)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal([]byte(joinedSuperGroupListStr), &joinedSuperGroupIDs)
+	return joinedSuperGroupIDs, utils.Wrap(err, "")
+}
+
+func DelJoinedSuperGroupIDListFromCache(ctx context.Context, userID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+	}()
+	return db.DB.Rc.TagAsDeleted(joinedSuperGroupListCache + userID)
+}
+
+func GetGroupMemberListHashFromCache(ctx context.Context, groupID string) (hashCodeUint64 uint64, err error) {
+	generateHash := func() (string, error) {
+		groupInfo, err := GetGroupInfoFromCache(ctx, groupID)
+		if err != nil {
+			return "0", utils.Wrap(err, "GetGroupInfoFromCache failed")
+		}
+		if groupInfo.Status == constant.GroupStatusDismissed {
+			return "0", nil
+		}
+		groupMemberIDList, err := GetGroupMemberIDListFromCache(ctx, groupID)
+		if err != nil {
+			return "", utils.Wrap(err, "GetGroupMemberIDListFromCache failed")
+		}
+		sort.Strings(groupMemberIDList)
+		var all string
+		for _, v := range groupMemberIDList {
+			all += v
+		}
+		bi := big.NewInt(0)
+		bi.SetString(utils.Md5(all)[0:8], 16)
+		return strconv.Itoa(int(bi.Uint64())), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "hashCodeUint64", hashCodeUint64)
+	}()
+	hashCodeStr, err := db.DB.Rc.Fetch(groupMemberListHashCache+groupID, time.Second*30*60, generateHash)
+	if err != nil {
+		return 0, utils.Wrap(err, "fetch failed")
+	}
+	hashCode, err := strconv.Atoi(hashCodeStr)
+	return uint64(hashCode), err
+}
+
+func DelGroupMemberListHashFromCache(ctx context.Context, groupID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+	}()
+	return db.DB.Rc.TagAsDeleted(groupMemberListHashCache + groupID)
+}
+
+func GetGroupMemberNumFromCache(ctx context.Context, groupID string) (num int, err error) {
+	getGroupMemberNum := func() (string, error) {
+		num, err := mysql.GetGroupMemberNumByGroupID(groupID)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return strconv.Itoa(int(num)), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "num", num)
+	}()
+	groupMember, err := db.DB.Rc.Fetch(groupMemberNumCache+groupID, time.Second*30*60, getGroupMemberNum)
+	if err != nil {
+		return 0, utils.Wrap(err, "")
+	}
+	return strconv.Atoi(groupMember)
+}
+
+func DelGroupMemberNumFromCache(ctx context.Context, groupID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+	}()
+	return db.DB.Rc.TagAsDeleted(groupMemberNumCache + groupID)
+}
+
+func GetUserConversationIDListFromCache(ctx context.Context, userID string) (conversationIDs []string, err error) {
+	getConversationIDList := func() (string, error) {
+		conversationIDList, err := mysql.GetConversationIDListByUserID(userID)
+		if err != nil {
+			return "", utils.Wrap(err, "getConversationIDList failed")
+		}
+		log.NewDebug("", utils.GetSelfFuncName(), conversationIDList)
+		bytes, err := json.Marshal(conversationIDList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "conversationIDs", conversationIDs)
+	}()
+	conversationIDListStr, err := db.DB.Rc.Fetch(conversationIDListCache+userID, time.Second*30*60, getConversationIDList)
+	err = json.Unmarshal([]byte(conversationIDListStr), &conversationIDs)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	return conversationIDs, nil
+}
+
+func DelUserConversationIDListFromCache(ctx context.Context, userID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+	}()
+	return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationIDListCache+userID), "DelUserConversationIDListFromCache err")
+}
+
+func GetConversationFromCache(ctx context.Context, ownerUserID, conversationID string) (conversation *mysql.Conversation, err error) {
+	getConversation := func() (string, error) {
+		conversation, err := mysql.GetConversation(ownerUserID, conversationID)
+		if err != nil {
+			return "", utils.Wrap(err, "get failed")
+		}
+		bytes, err := json.Marshal(conversation)
+		if err != nil {
+			return "", utils.Wrap(err, "Marshal failed")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID, "conversation", *conversation)
+	}()
+	conversationStr, err := db.DB.Rc.Fetch(conversationCache+ownerUserID+":"+conversationID, time.Second*30*60, getConversation)
+	if err != nil {
+		return nil, utils.Wrap(err, "Fetch failed")
+	}
+	conversation = &mysql.Conversation{}
+	err = json.Unmarshal([]byte(conversationStr), &conversation)
+	return conversation, utils.Wrap(err, "Unmarshal failed")
+}
+
+func GetConversationsFromCache(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []mysql.Conversation, err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationIDs", conversationIDs, "conversations", conversations)
+	}()
+	for _, conversationID := range conversationIDs {
+		conversation, err := GetConversationFromCache(ctx, ownerUserID, conversationID)
+		if err != nil {
+			return nil, utils.Wrap(err, "GetConversationFromCache failed")
+		}
+		conversations = append(conversations, *conversation)
+	}
+	return conversations, nil
+}
+
+func GetUserAllConversationList(ctx context.Context, ownerUserID string) (conversations []mysql.Conversation, err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversations", conversations)
+	}()
+	IDList, err := GetUserConversationIDListFromCache(ctx, ownerUserID)
+	if err != nil {
+		return nil, err
+	}
+	var conversationList []mysql.Conversation
+	log.NewDebug("", utils.GetSelfFuncName(), IDList)
+	for _, conversationID := range IDList {
+		conversation, err := GetConversationFromCache(ctx, ownerUserID, conversationID)
+		if err != nil {
+			return nil, utils.Wrap(err, "GetConversationFromCache failed")
+		}
+		conversationList = append(conversationList, *conversation)
+	}
+	return conversationList, nil
+}
+
+func DelConversationFromCache(ctx context.Context, ownerUserID, conversationID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID)
+	}()
+	return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationCache+ownerUserID+":"+conversationID), "DelConversationFromCache err")
+}
+
+func GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, firstModifyTime int64) (extendMsg *mongo.ExtendMsg, err error) {
+	getExtendMsg := func() (string, error) {
+		extendMsg, err := db.DB.GetExtendMsg(sourceID, sessionType, clientMsgID, firstModifyTime)
+		if err != nil {
+			return "", utils.Wrap(err, "GetExtendMsgList failed")
+		}
+		bytes, err := json.Marshal(extendMsg)
+		if err != nil {
+			return "", utils.Wrap(err, "Marshal failed")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "sourceID", sourceID, "sessionType",
+			sessionType, "clientMsgID", clientMsgID, "firstModifyTime", firstModifyTime, "extendMsg", extendMsg)
+	}()
+	extendMsgStr, err := db.DB.Rc.Fetch(extendMsgCache+clientMsgID, time.Second*30*60, getExtendMsg)
+	if err != nil {
+		return nil, utils.Wrap(err, "Fetch failed")
+	}
+	extendMsg = &mongo.ExtendMsg{}
+	err = json.Unmarshal([]byte(extendMsgStr), extendMsg)
+	return extendMsg, utils.Wrap(err, "Unmarshal failed")
+}
+
+func DelExtendMsg(ctx context.Context, clientMsgID string) (err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "clientMsgID", clientMsgID)
+	}()
+	return utils.Wrap(db.DB.Rc.TagAsDeleted(extendMsgCache+clientMsgID), "DelExtendMsg err")
+}