Merge remote-tracking branch 'origin/errcode' into errcode

# Conflicts:
#	internal/utils/convert.go

internal/rpc/cache/cache.go

@@ -1,145 +0,0 @@
-package cache
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	rocksCache "Open_IM/pkg/common/db/rocks_cache"
-	"Open_IM/pkg/common/log"
-	promePkg "Open_IM/pkg/common/prometheus"
-	pbCache "Open_IM/pkg/proto/cache"
-	"Open_IM/pkg/utils"
-	"context"
-	"github.com/OpenIMSDK/getcdv3"
-	"net"
-	"strconv"
-	"strings"
-
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-	"google.golang.org/grpc"
-)
-
-type cacheServer struct {
-	rpcPort         int
-	rpcRegisterName string
-	etcdSchema      string
-	etcdAddr        []string
-}
-
-func NewCacheServer(port int) *cacheServer {
-	log.NewPrivateLog(constant.LogFileName)
-	return &cacheServer{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImCacheName,
-		etcdSchema:      config.Config.Etcd.EtcdSchema,
-		etcdAddr:        config.Config.Etcd.EtcdAddr,
-	}
-}
-
-func (s *cacheServer) Run() {
-	log.NewInfo("0", "cacheServer rpc start ")
-	listenIP := ""
-	if config.Config.ListenIP == "" {
-		listenIP = "0.0.0.0"
-	} else {
-		listenIP = config.Config.ListenIP
-	}
-	address := listenIP + ":" + strconv.Itoa(s.rpcPort)
-	//listener network
-	listener, err := net.Listen("tcp", address)
-	if err != nil {
-		panic("listening err:" + err.Error() + s.rpcRegisterName)
-	}
-	log.NewInfo("0", "listen network success, ", address, listener)
-	defer listener.Close()
-	//grpc server
-	var grpcOpts []grpc.ServerOption
-	if config.Config.Prometheus.Enable {
-		promePkg.NewGrpcRequestCounter()
-		promePkg.NewGrpcRequestFailedCounter()
-		promePkg.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(promePkg.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	pbCache.RegisterCacheServer(srv, s)
-
-	rpcRegisterIP := config.Config.RpcRegisterIP
-	if config.Config.RpcRegisterIP == "" {
-		rpcRegisterIP, err = utils.GetLocalIP()
-		if err != nil {
-			log.Error("", "GetLocalIP failed ", err.Error())
-		}
-	}
-	log.NewInfo("", "rpcRegisterIP", rpcRegisterIP)
-	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10, "")
-	if err != nil {
-		log.NewError("0", "RegisterEtcd failed ", err.Error())
-		panic(utils.Wrap(err, "register cache module  rpc to etcd err"))
-	}
-	go rocksCache.DelKeys()
-	err = srv.Serve(listener)
-	if err != nil {
-		log.NewError("0", "Serve failed ", err.Error())
-		return
-	}
-	log.NewInfo("0", "message cms rpc success")
-}
-
-func (s *cacheServer) GetFriendIDListFromCache(ctx context.Context, req *pbCache.GetFriendIDListFromCacheReq) (resp *pbCache.GetFriendIDListFromCacheResp, err error) {
-	resp = &pbCache.GetFriendIDListFromCacheResp{}
-	friendIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.UserID)
-	if err != nil {
-		return
-	}
-	resp.UserIDList = friendIDList
-	return
-}
-
-// this is for dtm call
-func (s *cacheServer) DelFriendIDListFromCache(ctx context.Context, req *pbCache.DelFriendIDListFromCacheReq) (resp *pbCache.DelFriendIDListFromCacheResp, err error) {
-	resp = &pbCache.DelFriendIDListFromCacheResp{}
-	if err := rocksCache.DelFriendIDListFromCache(ctx, req.UserID); err != nil {
-		return
-	}
-	return
-}
-
-func (s *cacheServer) GetBlackIDListFromCache(ctx context.Context, req *pbCache.GetBlackIDListFromCacheReq) (resp *pbCache.GetBlackIDListFromCacheResp, err error) {
-	resp = &pbCache.GetBlackIDListFromCacheResp{}
-	blackUserIDList, err := rocksCache.GetBlackListFromCache(ctx, req.UserID)
-	if err != nil {
-		return
-	}
-	resp.UserIDList = blackUserIDList
-	return
-}
-
-func (s *cacheServer) DelBlackIDListFromCache(ctx context.Context, req *pbCache.DelBlackIDListFromCacheReq) (resp *pbCache.DelBlackIDListFromCacheResp, err error) {
-	resp = &pbCache.DelBlackIDListFromCacheResp{}
-	if err := rocksCache.DelBlackIDListFromCache(ctx, req.UserID); err != nil {
-		return
-	}
-	return resp, nil
-}
-
-func (s *cacheServer) GetGroupMemberIDListFromCache(ctx context.Context, req *pbCache.GetGroupMemberIDListFromCacheReq) (resp *pbCache.GetGroupMemberIDListFromCacheResp, err error) {
-	resp = &pbCache.GetGroupMemberIDListFromCacheResp{}
-	userIDList, err := rocksCache.GetGroupMemberIDListFromCache(ctx, req.GroupID)
-	if err != nil {
-		return
-	}
-	resp.UserIDList = userIDList
-	return
-}
-
-func (s *cacheServer) DelGroupMemberIDListFromCache(ctx context.Context, req *pbCache.DelGroupMemberIDListFromCacheReq) (resp *pbCache.DelGroupMemberIDListFromCacheResp, err error) {
-	resp = &pbCache.DelGroupMemberIDListFromCacheResp{}
-	if err := rocksCache.DelGroupMemberIDListFromCache(ctx, req.GroupID); err != nil {
-		return resp, nil
-	}
-	return resp, nil
-}

internal/rpc/group/group.go

@@ -58,6 +58,7 @@ func NewGroupServer(port int) *groupServer {
 	var mysql relation.Mysql
 	var mongo unrelation.Mongo
 	var groupModel relation.Group
+	var redis cache.RedisClient
 	err := mysql.InitConn().AutoMigrateModel(&groupModel)
 	if err != nil {
 		panic("db init err:" + err.Error())
@@ -68,8 +69,9 @@ func NewGroupServer(port int) *groupServer {
 		panic("db init err:" + "conn is nil")
 	}
 	mongo.InitMongo()
+	redis.InitRedis()
 	mongo.CreateSuperGroupIndex()
-	g.GroupInterface = controller.NewGroupController(groupModel.DB, cache.InitRedis(), mongo.DB)
+	g.GroupInterface = controller.NewGroupController(groupModel.DB, redis.GetClient(), mongo.GetClient())
 	return &g
 }
 
@@ -166,6 +168,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if err := callbackBeforeCreateGroup(ctx, req); err != nil {
 		return nil, err
 	}
+	var groupInfo relation.Group
+	utils.CopyStructFields(&groupInfo, req.GroupInfo)
+
 	groupInfo, err := (&cp.PBGroup{req.GroupInfo}).Convert()
 	groupInfo.GroupID = genGroupID(ctx, req.GroupInfo.GroupID)
 	if req.GroupInfo.GroupType != constant.SuperGroup {

internal/utils/convert.go

@@ -1,7 +1,7 @@
 package utils
 
 import (
-	imdb "Open_IM/pkg/common/db/relation"
+	"Open_IM/pkg/common/db/relation"
 	sdk "Open_IM/pkg/proto/sdk_ws"
 	utils2 "Open_IM/pkg/utils"
 	utils "github.com/OpenIMSDK/open_utils"
@@ -20,7 +20,7 @@ func getNumberOfGroupMember(groupID string) (int32, error) {
 }
 
 type DBFriend struct {
-	*imdb.Friend
+	*relation.Friend
 }
 
 type PBFriend struct {
@@ -41,8 +41,8 @@ func (db *DBFriend) convert() (*sdk.FriendInfo, error) {
 	return pbFriend, nil
 }
 
-func (pb *PBFriend) Convert() (*imdb.Friend, error) {
-	dbFriend := &imdb.Friend{}
+func (pb *PBFriend) Convert() (*relation.Friend, error) {
+	dbFriend := &relation.Friend{}
 	utils2.CopyStructFields(dbFriend, pb)
 	dbFriend.FriendUserID = pb.FriendUser.UserID
 	dbFriend.CreateTime = utils2.UnixSecondToTime(int64(pb.CreateTime))
@@ -50,15 +50,15 @@ func (pb *PBFriend) Convert() (*imdb.Friend, error) {
 }
 
 type DBFriendRequest struct {
-	*imdb.FriendRequest
+	*relation.FriendRequest
 }
 
 type PBFriendRequest struct {
 	*sdk.FriendRequest
 }
 
-func (pb *PBFriendRequest) Convert() (*imdb.FriendRequest, error) {
-	dbFriendRequest := &imdb.FriendRequest{}
+func (pb *PBFriendRequest) Convert() (*relation.FriendRequest, error) {
+	dbFriendRequest := &relation.FriendRequest{}
 	utils.CopyStructFields(dbFriendRequest, pb)
 	dbFriendRequest.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
 	dbFriendRequest.HandleTime = utils.UnixSecondToTime(int64(pb.HandleTime))
@@ -87,15 +87,15 @@ func (db *DBFriendRequest) Convert() (*sdk.FriendRequest, error) {
 }
 
 type DBBlack struct {
-	*imdb.Black
+	*relation.Black
 }
 
 type PBBlack struct {
 	*sdk.BlackInfo
 }
 
-func (pb *PBBlack) Convert() (*imdb.Black, error) {
-	dbBlack := &imdb.Black{}
+func (pb *PBBlack) Convert() (*relation.Black, error) {
+	dbBlack := &relation.Black{}
 	dbBlack.BlockUserID = pb.BlackUserInfo.UserID
 	dbBlack.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
 	return dbBlack, nil
@@ -113,17 +113,17 @@ func (db *DBBlack) Convert() (*sdk.BlackInfo, error) {
 }
 
 type DBGroup struct {
-	*imdb.Group
+	*relation.Group
 }
 
 type PBGroup struct {
 	*sdk.GroupInfo
 }
 
-func (pb *PBGroup) Convert() (*imdb.Group, error) {
-	dst := &imdb.Group{}
-	utils.CopyStructFields(dst, pb)
-	return dst, nil
+func (pb *PBGroup) Convert() *relation.Group {
+	dst := &relation.Group{}
+	_ = utils.CopyStructFields(dst, pb)
+	return dst
 }
 func (db *DBGroup) Convert() (*sdk.GroupInfo, error) {
 	dst := &sdk.GroupInfo{}
@@ -148,15 +148,15 @@ func (db *DBGroup) Convert() (*sdk.GroupInfo, error) {
 }
 
 type DBGroupMember struct {
-	*imdb.GroupMember
+	*relation.GroupMember
 }
 
 type PBGroupMember struct {
 	*sdk.GroupMemberFullInfo
 }
 
-func (pb *PBGroupMember) Convert() (*imdb.GroupMember, error) {
-	dst := &imdb.GroupMember{}
+func (pb *PBGroupMember) Convert() (*relation.GroupMember, error) {
+	dst := &relation.GroupMember{}
 	utils.CopyStructFields(dst, pb)
 	dst.JoinTime = utils.UnixSecondToTime(int64(pb.JoinTime))
 	dst.MuteEndTime = utils.UnixSecondToTime(int64(pb.MuteEndTime))
@@ -184,15 +184,15 @@ func (db *DBGroupMember) Convert() (*sdk.GroupMemberFullInfo, error) {
 }
 
 type DBGroupRequest struct {
-	*imdb.GroupRequest
+	*relation.GroupRequest
 }
 
 type PBGroupRequest struct {
 	*sdk.GroupRequest
 }
 
-func (pb *PBGroupRequest) Convert() (*imdb.GroupRequest, error) {
-	dst := &imdb.GroupRequest{}
+func (pb *PBGroupRequest) Convert() (*relation.GroupRequest, error) {
+	dst := &relation.GroupRequest{}
 	utils.CopyStructFields(dst, pb)
 	dst.ReqTime = utils.UnixSecondToTime(int64(pb.ReqTime))
 	dst.HandledTime = utils.UnixSecondToTime(int64(pb.HandleTime))
@@ -207,23 +207,15 @@ func (db *DBGroupRequest) Convert() (*sdk.GroupRequest, error) {
 }
 
 type DBUser struct {
-	*imdb.User
-}
-
-func NewDBUser(user *imdb.User) *DBUser {
-	return &DBUser{User: user}
+	*relation.User
 }
 
 type PBUser struct {
 	*sdk.UserInfo
 }
 
-func NewPBUser(userInfo *sdk.UserInfo) *PBUser {
-	return &PBUser{UserInfo: userInfo}
-}
-
-func (pb *PBUser) Convert() (*imdb.User, error) {
-	dst := &imdb.User{}
+func (pb *PBUser) Convert() (*relation.User, error) {
+	dst := &relation.User{}
 	utils.CopyStructFields(dst, pb)
 	dst.Birth = utils.UnixSecondToTime(pb.Birthday)
 	dst.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))