You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
554 lines
16 KiB
554 lines
16 KiB
// 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 cache
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/OpenIMSDK/tools/log"
|
|
|
|
"github.com/dtm-labs/rockscache"
|
|
"github.com/redis/go-redis/v9"
|
|
|
|
"github.com/OpenIMSDK/tools/utils"
|
|
|
|
relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
|
|
unrelationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/unrelation"
|
|
)
|
|
|
|
const (
|
|
groupExpireTime = time.Second * 60 * 60 * 12
|
|
groupInfoKey = "GROUP_INFO:"
|
|
groupMemberIDsKey = "GROUP_MEMBER_IDS:"
|
|
groupMembersHashKey = "GROUP_MEMBERS_HASH2:"
|
|
groupMemberInfoKey = "GROUP_MEMBER_INFO:"
|
|
joinedSuperGroupsKey = "JOIN_SUPER_GROUPS:"
|
|
SuperGroupMemberIDsKey = "SUPER_GROUP_MEMBER_IDS:"
|
|
joinedGroupsKey = "JOIN_GROUPS_KEY:"
|
|
groupMemberNumKey = "GROUP_MEMBER_NUM_CACHE:"
|
|
)
|
|
|
|
type GroupCache interface {
|
|
metaCache
|
|
NewCache() GroupCache
|
|
GetGroupsInfo(ctx context.Context, groupIDs []string) (groups []*relationtb.GroupModel, err error)
|
|
GetGroupInfo(ctx context.Context, groupID string) (group *relationtb.GroupModel, err error)
|
|
DelGroupsInfo(groupIDs ...string) GroupCache
|
|
|
|
GetJoinedSuperGroupIDs(ctx context.Context, userID string) (joinedSuperGroupIDs []string, err error)
|
|
DelJoinedSuperGroupIDs(userIDs ...string) GroupCache
|
|
GetSuperGroupMemberIDs(ctx context.Context, groupIDs ...string) (models []*unrelationtb.SuperGroupModel, err error)
|
|
DelSuperGroupMemberIDs(groupIDs ...string) GroupCache
|
|
|
|
GetGroupMembersHash(ctx context.Context, groupID string) (hashCode uint64, err error)
|
|
GetGroupMemberHashMap(ctx context.Context, groupIDs []string) (map[string]*relationtb.GroupSimpleUserID, error)
|
|
DelGroupMembersHash(groupID string) GroupCache
|
|
|
|
GetGroupMemberIDs(ctx context.Context, groupID string) (groupMemberIDs []string, err error)
|
|
GetGroupsMemberIDs(ctx context.Context, groupIDs []string) (groupMemberIDs map[string][]string, err error)
|
|
|
|
DelGroupMemberIDs(groupID string) GroupCache
|
|
|
|
GetJoinedGroupIDs(ctx context.Context, userID string) (joinedGroupIDs []string, err error)
|
|
DelJoinedGroupID(userID ...string) GroupCache
|
|
|
|
GetGroupMemberInfo(
|
|
ctx context.Context,
|
|
groupID, userID string,
|
|
) (groupMember *relationtb.GroupMemberModel, err error)
|
|
GetGroupMembersInfo(
|
|
ctx context.Context,
|
|
groupID string,
|
|
userID []string,
|
|
) (groupMembers []*relationtb.GroupMemberModel, err error)
|
|
GetAllGroupMembersInfo(ctx context.Context, groupID string) (groupMembers []*relationtb.GroupMemberModel, err error)
|
|
GetGroupMembersPage(
|
|
ctx context.Context,
|
|
groupID string,
|
|
userID []string,
|
|
showNumber, pageNumber int32,
|
|
) (total uint32, groupMembers []*relationtb.GroupMemberModel, err error)
|
|
|
|
DelGroupMembersInfo(groupID string, userID ...string) GroupCache
|
|
|
|
GetGroupMemberNum(ctx context.Context, groupID string) (memberNum int64, err error)
|
|
DelGroupsMemberNum(groupID ...string) GroupCache
|
|
}
|
|
|
|
type GroupCacheRedis struct {
|
|
metaCache
|
|
groupDB relationtb.GroupModelInterface
|
|
groupMemberDB relationtb.GroupMemberModelInterface
|
|
groupRequestDB relationtb.GroupRequestModelInterface
|
|
mongoDB unrelationtb.SuperGroupModelInterface
|
|
expireTime time.Duration
|
|
rcClient *rockscache.Client
|
|
hashCode func(ctx context.Context, groupID string) (uint64, error)
|
|
}
|
|
|
|
func NewGroupCacheRedis(
|
|
rdb redis.UniversalClient,
|
|
groupDB relationtb.GroupModelInterface,
|
|
groupMemberDB relationtb.GroupMemberModelInterface,
|
|
groupRequestDB relationtb.GroupRequestModelInterface,
|
|
mongoClient unrelationtb.SuperGroupModelInterface,
|
|
hashCode func(ctx context.Context, groupID string) (uint64, error),
|
|
opts rockscache.Options,
|
|
) GroupCache {
|
|
rcClient := rockscache.NewClient(rdb, opts)
|
|
return &GroupCacheRedis{
|
|
rcClient: rcClient, expireTime: groupExpireTime,
|
|
groupDB: groupDB, groupMemberDB: groupMemberDB, groupRequestDB: groupRequestDB,
|
|
mongoDB: mongoClient,
|
|
hashCode: hashCode,
|
|
metaCache: NewMetaCacheRedis(rcClient),
|
|
}
|
|
}
|
|
|
|
func (g *GroupCacheRedis) NewCache() GroupCache {
|
|
return &GroupCacheRedis{
|
|
rcClient: g.rcClient,
|
|
expireTime: g.expireTime,
|
|
groupDB: g.groupDB,
|
|
groupMemberDB: g.groupMemberDB,
|
|
groupRequestDB: g.groupRequestDB,
|
|
mongoDB: g.mongoDB,
|
|
metaCache: NewMetaCacheRedis(g.rcClient, g.metaCache.GetPreDelKeys()...),
|
|
}
|
|
}
|
|
|
|
func (g *GroupCacheRedis) getGroupInfoKey(groupID string) string {
|
|
return groupInfoKey + groupID
|
|
}
|
|
|
|
func (g *GroupCacheRedis) getJoinedSuperGroupsIDKey(userID string) string {
|
|
return joinedSuperGroupsKey + userID
|
|
}
|
|
|
|
func (g *GroupCacheRedis) getJoinedGroupsKey(userID string) string {
|
|
return joinedGroupsKey + userID
|
|
}
|
|
|
|
func (g *GroupCacheRedis) getSuperGroupMemberIDsKey(groupID string) string {
|
|
return SuperGroupMemberIDsKey + groupID
|
|
}
|
|
|
|
func (g *GroupCacheRedis) getGroupMembersHashKey(groupID string) string {
|
|
return groupMembersHashKey + groupID
|
|
}
|
|
|
|
func (g *GroupCacheRedis) getGroupMemberIDsKey(groupID string) string {
|
|
return groupMemberIDsKey + groupID
|
|
}
|
|
|
|
func (g *GroupCacheRedis) getGroupMemberInfoKey(groupID, userID string) string {
|
|
return groupMemberInfoKey + groupID + "-" + userID
|
|
}
|
|
|
|
func (g *GroupCacheRedis) getGroupMemberNumKey(groupID string) string {
|
|
return groupMemberNumKey + groupID
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetGroupIndex(group *relationtb.GroupModel, keys []string) (int, error) {
|
|
key := g.getGroupInfoKey(group.GroupID)
|
|
for i, _key := range keys {
|
|
if _key == key {
|
|
return i, nil
|
|
}
|
|
}
|
|
return 0, errIndex
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetGroupMemberIndex(groupMember *relationtb.GroupMemberModel, keys []string) (int, error) {
|
|
key := g.getGroupMemberInfoKey(groupMember.GroupID, groupMember.UserID)
|
|
for i, _key := range keys {
|
|
if _key == key {
|
|
return i, nil
|
|
}
|
|
}
|
|
return 0, errIndex
|
|
}
|
|
|
|
// / groupInfo.
|
|
func (g *GroupCacheRedis) GetGroupsInfo(
|
|
ctx context.Context,
|
|
groupIDs []string,
|
|
) (groups []*relationtb.GroupModel, err error) {
|
|
var keys []string
|
|
for _, group := range groupIDs {
|
|
keys = append(keys, g.getGroupInfoKey(group))
|
|
}
|
|
return batchGetCache(
|
|
ctx,
|
|
g.rcClient,
|
|
keys,
|
|
g.expireTime,
|
|
g.GetGroupIndex,
|
|
func(ctx context.Context) ([]*relationtb.GroupModel, error) {
|
|
return g.groupDB.Find(ctx, groupIDs)
|
|
},
|
|
)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetGroupInfo(ctx context.Context, groupID string) (group *relationtb.GroupModel, err error) {
|
|
return getCache(
|
|
ctx,
|
|
g.rcClient,
|
|
g.getGroupInfoKey(groupID),
|
|
g.expireTime,
|
|
func(ctx context.Context) (*relationtb.GroupModel, error) {
|
|
return g.groupDB.Take(ctx, groupID)
|
|
},
|
|
)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) DelGroupsInfo(groupIDs ...string) GroupCache {
|
|
new := g.NewCache()
|
|
var keys []string
|
|
for _, groupID := range groupIDs {
|
|
keys = append(keys, g.getGroupInfoKey(groupID))
|
|
}
|
|
new.AddKeys(keys...)
|
|
return new
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetJoinedSuperGroupIDs(
|
|
ctx context.Context,
|
|
userID string,
|
|
) (joinedSuperGroupIDs []string, err error) {
|
|
return getCache(
|
|
ctx,
|
|
g.rcClient,
|
|
g.getJoinedSuperGroupsIDKey(userID),
|
|
g.expireTime,
|
|
func(ctx context.Context) ([]string, error) {
|
|
userGroup, err := g.mongoDB.GetSuperGroupByUserID(ctx, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return userGroup.GroupIDs, nil
|
|
},
|
|
)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetSuperGroupMemberIDs(
|
|
ctx context.Context,
|
|
groupIDs ...string,
|
|
) (models []*unrelationtb.SuperGroupModel, err error) {
|
|
var keys []string
|
|
for _, group := range groupIDs {
|
|
keys = append(keys, g.getSuperGroupMemberIDsKey(group))
|
|
}
|
|
return batchGetCache(
|
|
ctx,
|
|
g.rcClient,
|
|
keys,
|
|
g.expireTime,
|
|
func(model *unrelationtb.SuperGroupModel, keys []string) (int, error) {
|
|
for i, key := range keys {
|
|
if g.getSuperGroupMemberIDsKey(model.GroupID) == key {
|
|
return i, nil
|
|
}
|
|
}
|
|
return 0, errIndex
|
|
},
|
|
func(ctx context.Context) ([]*unrelationtb.SuperGroupModel, error) {
|
|
return g.mongoDB.FindSuperGroup(ctx, groupIDs)
|
|
},
|
|
)
|
|
}
|
|
|
|
// userJoinSuperGroup.
|
|
func (g *GroupCacheRedis) DelJoinedSuperGroupIDs(userIDs ...string) GroupCache {
|
|
new := g.NewCache()
|
|
var keys []string
|
|
for _, userID := range userIDs {
|
|
keys = append(keys, g.getJoinedSuperGroupsIDKey(userID))
|
|
}
|
|
new.AddKeys(keys...)
|
|
return new
|
|
}
|
|
|
|
func (g *GroupCacheRedis) DelSuperGroupMemberIDs(groupIDs ...string) GroupCache {
|
|
new := g.NewCache()
|
|
var keys []string
|
|
for _, groupID := range groupIDs {
|
|
keys = append(keys, g.getSuperGroupMemberIDsKey(groupID))
|
|
}
|
|
new.AddKeys(keys...)
|
|
return new
|
|
}
|
|
|
|
// groupMembersHash.
|
|
func (g *GroupCacheRedis) GetGroupMembersHash(ctx context.Context, groupID string) (hashCode uint64, err error) {
|
|
return getCache(ctx, g.rcClient, g.getGroupMembersHashKey(groupID), g.expireTime, func(ctx context.Context) (uint64, error) {
|
|
return g.hashCode(ctx, groupID)
|
|
})
|
|
|
|
//return getCache(ctx, g.rcClient, g.getGroupMembersHashKey(groupID), g.expireTime,
|
|
// func(ctx context.Context) (uint64, error) {
|
|
// userIDs, err := g.GetGroupMemberIDs(ctx, groupID)
|
|
// if err != nil {
|
|
// return 0, err
|
|
// }
|
|
// log.ZInfo(ctx, "GetGroupMembersHash", "groupID", groupID, "userIDs", userIDs)
|
|
// var members []*relationtb.GroupMemberModel
|
|
// if len(userIDs) > 0 {
|
|
// members, err = g.GetGroupMembersInfo(ctx, groupID, userIDs)
|
|
// if err != nil {
|
|
// return 0, err
|
|
// }
|
|
// utils.Sort(userIDs, true)
|
|
// }
|
|
// memberMap := make(map[string]*relationtb.GroupMemberModel)
|
|
// for i, member := range members {
|
|
// memberMap[member.UserID] = members[i]
|
|
// }
|
|
// data := make([]string, 0, len(members)*11)
|
|
// for _, userID := range userIDs {
|
|
// member, ok := memberMap[userID]
|
|
// if !ok {
|
|
// continue
|
|
// }
|
|
// data = append(data,
|
|
// member.GroupID,
|
|
// member.UserID,
|
|
// member.Nickname,
|
|
// member.FaceURL,
|
|
// strconv.Itoa(int(member.RoleLevel)),
|
|
// strconv.FormatInt(member.JoinTime.UnixMilli(), 10),
|
|
// strconv.Itoa(int(member.JoinSource)),
|
|
// member.InviterUserID,
|
|
// member.OperatorUserID,
|
|
// strconv.FormatInt(member.MuteEndTime.UnixMilli(), 10),
|
|
// member.Ex,
|
|
// )
|
|
// }
|
|
// log.ZInfo(ctx, "hash data info", "userIDs.len", len(userIDs), "hash.data.len", len(data))
|
|
// log.ZInfo(ctx, "json hash data", "groupID", groupID, "data", data)
|
|
// val, err := json.Marshal(data)
|
|
// if err != nil {
|
|
// return 0, err
|
|
// }
|
|
// sum := md5.Sum(val)
|
|
// code := binary.BigEndian.Uint64(sum[:])
|
|
// log.ZInfo(ctx, "GetGroupMembersHash", "groupID", groupID, "hashCode", code, "num", len(members))
|
|
// return code, nil
|
|
// },
|
|
//)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetGroupMemberHashMap(
|
|
ctx context.Context,
|
|
groupIDs []string,
|
|
) (map[string]*relationtb.GroupSimpleUserID, error) {
|
|
res := make(map[string]*relationtb.GroupSimpleUserID)
|
|
for _, groupID := range groupIDs {
|
|
hash, err := g.GetGroupMembersHash(ctx, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
log.ZInfo(ctx, "GetGroupMemberHashMap", "groupID", groupID, "hash", hash)
|
|
num, err := g.GetGroupMemberNum(ctx, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res[groupID] = &relationtb.GroupSimpleUserID{Hash: hash, MemberNum: uint32(num)}
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (g *GroupCacheRedis) DelGroupMembersHash(groupID string) GroupCache {
|
|
cache := g.NewCache()
|
|
cache.AddKeys(g.getGroupMembersHashKey(groupID))
|
|
return cache
|
|
}
|
|
|
|
// groupMemberIDs.
|
|
func (g *GroupCacheRedis) GetGroupMemberIDs(ctx context.Context, groupID string) (groupMemberIDs []string, err error) {
|
|
return getCache(
|
|
ctx,
|
|
g.rcClient,
|
|
g.getGroupMemberIDsKey(groupID),
|
|
g.expireTime,
|
|
func(ctx context.Context) ([]string, error) {
|
|
return g.groupMemberDB.FindMemberUserID(ctx, groupID)
|
|
},
|
|
)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetGroupsMemberIDs(ctx context.Context, groupIDs []string) (map[string][]string, error) {
|
|
m := make(map[string][]string)
|
|
for _, groupID := range groupIDs {
|
|
userIDs, err := g.GetGroupMemberIDs(ctx, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
m[groupID] = userIDs
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (g *GroupCacheRedis) DelGroupMemberIDs(groupID string) GroupCache {
|
|
cache := g.NewCache()
|
|
cache.AddKeys(g.getGroupMemberIDsKey(groupID))
|
|
return cache
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetJoinedGroupIDs(ctx context.Context, userID string) (joinedGroupIDs []string, err error) {
|
|
return getCache(
|
|
ctx,
|
|
g.rcClient,
|
|
g.getJoinedGroupsKey(userID),
|
|
g.expireTime,
|
|
func(ctx context.Context) ([]string, error) {
|
|
return g.groupMemberDB.FindUserJoinedGroupID(ctx, userID)
|
|
},
|
|
)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) DelJoinedGroupID(userIDs ...string) GroupCache {
|
|
var keys []string
|
|
for _, userID := range userIDs {
|
|
keys = append(keys, g.getJoinedGroupsKey(userID))
|
|
}
|
|
cache := g.NewCache()
|
|
cache.AddKeys(keys...)
|
|
return cache
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetGroupMemberInfo(
|
|
ctx context.Context,
|
|
groupID, userID string,
|
|
) (groupMember *relationtb.GroupMemberModel, err error) {
|
|
return getCache(
|
|
ctx,
|
|
g.rcClient,
|
|
g.getGroupMemberInfoKey(groupID, userID),
|
|
g.expireTime,
|
|
func(ctx context.Context) (*relationtb.GroupMemberModel, error) {
|
|
return g.groupMemberDB.Take(ctx, groupID, userID)
|
|
},
|
|
)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetGroupMembersInfo(
|
|
ctx context.Context,
|
|
groupID string,
|
|
userIDs []string,
|
|
) ([]*relationtb.GroupMemberModel, error) {
|
|
var keys []string
|
|
for _, userID := range userIDs {
|
|
keys = append(keys, g.getGroupMemberInfoKey(groupID, userID))
|
|
}
|
|
return batchGetCache(
|
|
ctx,
|
|
g.rcClient,
|
|
keys,
|
|
g.expireTime,
|
|
g.GetGroupMemberIndex,
|
|
func(ctx context.Context) ([]*relationtb.GroupMemberModel, error) {
|
|
return g.groupMemberDB.Find(ctx, []string{groupID}, userIDs, nil)
|
|
},
|
|
)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetGroupMembersPage(
|
|
ctx context.Context,
|
|
groupID string,
|
|
userIDs []string,
|
|
showNumber, pageNumber int32,
|
|
) (total uint32, groupMembers []*relationtb.GroupMemberModel, err error) {
|
|
groupMemberIDs, err := g.GetGroupMemberIDs(ctx, groupID)
|
|
if err != nil {
|
|
return 0, nil, err
|
|
}
|
|
if userIDs != nil {
|
|
userIDs = utils.BothExist(userIDs, groupMemberIDs)
|
|
} else {
|
|
userIDs = groupMemberIDs
|
|
}
|
|
groupMembers, err = g.GetGroupMembersInfo(ctx, groupID, utils.Paginate(userIDs, int(showNumber), int(showNumber)))
|
|
return uint32(len(userIDs)), groupMembers, err
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetAllGroupMembersInfo(
|
|
ctx context.Context,
|
|
groupID string,
|
|
) (groupMembers []*relationtb.GroupMemberModel, err error) {
|
|
groupMemberIDs, err := g.GetGroupMemberIDs(ctx, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return g.GetGroupMembersInfo(ctx, groupID, groupMemberIDs)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetAllGroupMemberInfo(
|
|
ctx context.Context,
|
|
groupID string,
|
|
) ([]*relationtb.GroupMemberModel, error) {
|
|
groupMemberIDs, err := g.GetGroupMemberIDs(ctx, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var keys []string
|
|
for _, groupMemberID := range groupMemberIDs {
|
|
keys = append(keys, g.getGroupMemberInfoKey(groupID, groupMemberID))
|
|
}
|
|
return batchGetCache(
|
|
ctx,
|
|
g.rcClient,
|
|
keys,
|
|
g.expireTime,
|
|
g.GetGroupMemberIndex,
|
|
func(ctx context.Context) ([]*relationtb.GroupMemberModel, error) {
|
|
return g.groupMemberDB.Find(ctx, []string{groupID}, groupMemberIDs, nil)
|
|
},
|
|
)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) DelGroupMembersInfo(groupID string, userIDs ...string) GroupCache {
|
|
var keys []string
|
|
for _, userID := range userIDs {
|
|
keys = append(keys, g.getGroupMemberInfoKey(groupID, userID))
|
|
}
|
|
cache := g.NewCache()
|
|
cache.AddKeys(keys...)
|
|
return cache
|
|
}
|
|
|
|
func (g *GroupCacheRedis) GetGroupMemberNum(ctx context.Context, groupID string) (memberNum int64, err error) {
|
|
return getCache(
|
|
ctx,
|
|
g.rcClient,
|
|
g.getGroupMemberNumKey(groupID),
|
|
g.expireTime,
|
|
func(ctx context.Context) (int64, error) {
|
|
return g.groupMemberDB.TakeGroupMemberNum(ctx, groupID)
|
|
},
|
|
)
|
|
}
|
|
|
|
func (g *GroupCacheRedis) DelGroupsMemberNum(groupID ...string) GroupCache {
|
|
var keys []string
|
|
for _, groupID := range groupID {
|
|
keys = append(keys, g.getGroupMemberNumKey(groupID))
|
|
}
|
|
cache := g.NewCache()
|
|
cache.AddKeys(keys...)
|
|
return cache
|
|
}
|