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

internal/common/convert/convert.go

@@ -35,11 +35,25 @@ func NewPBFriend(friendInfo *sdk.FriendInfo) *PBFriend {
 }
 
 func (*PBFriend) PB2DB(friends []*sdk.FriendInfo) (DBFriends []*relation.FriendModel, err error) {
-
+	for _, v := range friends {
+		u, err := NewPBFriend(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		DBFriends = append(DBFriends, u)
+	}
+	return
 }
 
 func (*DBFriend) DB2PB(friends []*relation.FriendModel) (PBFriends []*sdk.FriendInfo, err error) {
-
+	for _, v := range friends {
+		u, err := NewDBFriend(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		PBFriends = append(PBFriends, u)
+	}
+	return
 }
 
 func (db *DBFriend) Convert() (*sdk.FriendInfo, error) {
@@ -81,11 +95,25 @@ func NewPBFriendRequest(friendRequest *sdk.FriendRequest) *PBFriendRequest {
 }
 
 func (*PBFriendRequest) PB2DB(friendRequests []*sdk.FriendRequest) (DBFriendRequests []*relation.FriendRequestModel, err error) {
-
+	for _, v := range friendRequests {
+		u, err := NewPBFriendRequest(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		DBFriendRequests = append(DBFriendRequests, u)
+	}
+	return
 }
 
 func (*DBFriendRequest) DB2PB(friendRequests []*relation.FriendRequestModel) (PBFriendRequests []*sdk.FriendRequest, err error) {
-
+	for _, v := range friendRequests {
+		u, err := NewDBFriendRequest(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		PBFriendRequests = append(PBFriendRequests, u)
+	}
+	return
 }
 
 func (pb *PBFriendRequest) Convert() (*relation.FriendRequestModel, error) {
@@ -122,11 +150,25 @@ type DBBlack struct {
 }
 
 func (*PBBlack) PB2DB(blacks []*sdk.BlackInfo) (DBBlacks []*relation.BlackModel, err error) {
-
+	for _, v := range blacks {
+		u, err := NewPBBlack(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		DBBlacks = append(DBBlacks, u)
+	}
+	return
 }
 
 func (*DBBlack) DB2PB(blacks []*relation.BlackModel) (PBBlacks []*sdk.BlackInfo, err error) {
-
+	for _, v := range blacks {
+		u, err := NewDBBlack(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		PBBlacks = append(PBBlacks, u)
+	}
+	return
 }
 
 func NewDBBlack(black *relation.BlackModel) *DBBlack {
@@ -164,11 +206,25 @@ type DBGroup struct {
 }
 
 func (*PBGroup) PB2DB(groups []*sdk.GroupInfo) (DBGroups []*relation.GroupModel, err error) {
-
+	for _, v := range groups {
+		u, err := NewPBGroup(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		DBGroups = append(DBGroups, u)
+	}
+	return
 }
 
 func (*DBGroup) DB2PB(groups []*relation.GroupModel) (PBGroups []*sdk.GroupInfo, err error) {
-
+	for _, v := range groups {
+		u, err := NewDBGroup(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		PBGroups = append(PBGroups, u)
+	}
+	return
 }
 
 func NewDBGroup(group *relation.GroupModel) *DBGroup {
@@ -183,10 +239,10 @@ func NewPBGroup(groupInfo *sdk.GroupInfo) *PBGroup {
 	return &PBGroup{GroupInfo: groupInfo}
 }
 
-func (pb *PBGroup) Convert() *relation.GroupModel {
+func (pb *PBGroup) Convert() (*relation.GroupModel, error) {
 	dst := &relation.GroupModel{}
-	_ = utils.CopyStructFields(dst, pb)
-	return dst
+	err := utils.CopyStructFields(dst, pb)
+	return dst, err
 }
 func (db *DBGroup) Convert() (*sdk.GroupInfo, error) {
 	dst := &sdk.GroupInfo{}
@@ -215,11 +271,25 @@ type DBGroupMember struct {
 }
 
 func (*PBGroupMember) PB2DB(groupMembers []*sdk.GroupMemberFullInfo) (DBGroupMembers []*relation.GroupMemberModel, err error) {
-
+	for _, v := range groupMembers {
+		u, err := NewPBGroupMember(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		DBGroupMembers = append(DBGroupMembers, u)
+	}
+	return
 }
 
 func (*DBGroupMember) DB2PB(groupMembers []*relation.GroupMemberModel) (PBGroupMembers []*sdk.GroupMemberFullInfo, err error) {
-
+	for _, v := range groupMembers {
+		u, err := NewDBGroupMember(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		PBGroupMembers = append(PBGroupMembers, u)
+	}
+	return
 }
 
 func NewDBGroupMember(groupMember *relation.GroupMemberModel) *DBGroupMember {
@@ -267,11 +337,25 @@ type DBGroupRequest struct {
 }
 
 func (*PBGroupRequest) PB2DB(groupRequests []*sdk.GroupRequest) (DBGroupRequests []*relation.GroupRequestModel, err error) {
-
+	for _, v := range groupRequests {
+		u, err := NewPBGroupRequest(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		DBGroupRequests = append(DBGroupRequests, u)
+	}
+	return
 }
 
 func (*DBGroupRequest) DB2PB(groupRequests []*relation.GroupRequestModel) (PBGroupRequests []*sdk.GroupRequest, err error) {
-
+	for _, v := range groupRequests {
+		u, err := NewDBGroupRequest(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		PBGroupRequests = append(PBGroupRequests, u)
+	}
+	return
 }
 
 func NewDBGroupRequest(groupRequest *relation.GroupRequestModel) *DBGroupRequest {

internal/common/network/ip.go

@@ -0,0 +1,23 @@
+package network
+
+import utils "github.com/OpenIMSDK/open_utils"
+
+func GetRpcRegisterIP(configIP string) (string, error) {
+	registerIP := configIP
+	if registerIP == "" {
+		ip, err := utils.GetLocalIP()
+		if err != nil {
+			return "", err
+		}
+		registerIP = ip
+	}
+	return registerIP, nil
+}
+
+func GetListenIP(configIP string) string {
+	if configIP == "" {
+		return "0.0.0.0"
+	} else {
+		return configIP
+	}
+}

internal/common/rpc_server/a.go

@@ -0,0 +1,46 @@
+package rpc_server
+
+import (
+	"Open_IM/internal/common/network"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	discoveryRegistry "Open_IM/pkg/discovery_registry"
+	"github.com/OpenIMSDK/openKeeper"
+	"net"
+	"strconv"
+)
+
+type RpcServer struct {
+	Port           int
+	RegisterName   string
+	RegisterCenter discoveryRegistry.SvcDiscoveryRegistry
+}
+
+func NewRpcServer(registerIPInConfig string, port int, registerName string, zkServers []string, zkRoot string) (*RpcServer, error) {
+	log.NewPrivateLog(constant.LogFileName)
+	s := &RpcServer{
+		Port:         port,
+		RegisterName: registerName,
+	}
+
+	zkClient, err := openKeeper.NewClient(zkServers, zkRoot, 10, "", "")
+	if err != nil {
+		return nil, err
+	}
+	registerIP, err := network.GetRpcRegisterIP(registerIPInConfig)
+	if err != nil {
+		return nil, err
+	}
+	err = zkClient.Register(s.RegisterName, registerIP, s.Port)
+	if err != nil {
+		return nil, err
+	}
+	s.RegisterCenter = zkClient
+	return s, nil
+}
+
+func GetTcpListen(listenIPInConfig string, port int) (net.Listener, string, error) {
+	address := network.GetListenIP(listenIPInConfig) + ":" + strconv.Itoa(port)
+	listener, err := net.Listen("tcp", address)
+	return listener, address, err
+}

internal/rpc/auth/auth.go

@@ -2,28 +2,63 @@ package auth
 
 import (
 	"Open_IM/internal/common/check"
+	"Open_IM/internal/common/rpc_server"
+	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/log"
 	promePkg "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/common/tracelog"
-	"Open_IM/pkg/getcdv3"
 	pbAuth "Open_IM/pkg/proto/auth"
 	pbRelay "Open_IM/pkg/proto/relay"
 	"Open_IM/pkg/utils"
 	"context"
-	"net"
-	"strconv"
-	"strings"
-
 	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-
-	"Open_IM/pkg/common/config"
-
 	"google.golang.org/grpc"
 )
 
+func NewRpcAuthServer(port int) *rpcAuth {
+	r, err := rpc_server.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImAuthName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+	if err != nil {
+		panic(err)
+	}
+	return &rpcAuth{
+		RpcServer: r,
+	}
+}
+
+func (s *rpcAuth) Run() {
+	operationID := utils.OperationIDGenerator()
+	log.NewInfo(operationID, "rpc auth start...")
+	listener, address, err := rpc_server.GetTcpListen(config.Config.ListenIP, s.Port)
+	if err != nil {
+		panic(err)
+	}
+	log.NewInfo(operationID, "listen network success ", listener, address)
+	var grpcOpts []grpc.ServerOption
+	if config.Config.Prometheus.Enable {
+		promePkg.NewGrpcRequestCounter()
+		promePkg.NewGrpcRequestFailedCounter()
+		promePkg.NewGrpcRequestSuccessCounter()
+		promePkg.NewUserRegisterCounter()
+		promePkg.NewUserLoginCounter()
+		grpcOpts = append(grpcOpts, []grpc.ServerOption{
+			// grpc.UnaryInterceptor(promePkg.UnaryServerInterceptorProme),
+			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
+			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
+		}...)
+	}
+	srv := grpc.NewServer(grpcOpts...)
+	defer srv.GracefulStop()
+	pbAuth.RegisterAuthServer(srv, s)
+	err = srv.Serve(listener)
+	if err != nil {
+		panic(err)
+	}
+	log.NewInfo(operationID, "rpc auth ok")
+}
+
 func (s *rpcAuth) UserToken(ctx context.Context, req *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
 	resp := pbAuth.UserTokenResp{}
 	if _, err := check.GetUsersInfo(ctx, req.UserID); err != nil {
@@ -85,7 +120,10 @@ func (s *rpcAuth) ForceLogout(ctx context.Context, req *pbAuth.ForceLogoutReq) (
 }
 
 func (s *rpcAuth) forceKickOff(ctx context.Context, userID string, platformID int32, operationID string) error {
-	grpcCons := rpc.GetDefaultGatewayConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), operationID)
+	grpcCons, err := s.RegisterCenter.GetConns(config.Config.RpcRegisterName.OpenImRelayName)
+	if err != nil {
+		return err
+	}
 	for _, v := range grpcCons {
 		client := pbRelay.NewRelayClient(v)
 		kickReq := &pbRelay.KickUserOfflineReq{OperationID: operationID, KickUserIDList: []string{userID}, PlatformID: platformID}
@@ -97,78 +135,6 @@ func (s *rpcAuth) forceKickOff(ctx context.Context, userID string, platformID in
 }
 
 type rpcAuth struct {
-	rpcPort         int
-	rpcRegisterName string
-	etcdSchema      string
-	etcdAddr        []string
+	*rpc_server.RpcServer
 	controller.AuthInterface
 }
-
-func NewRpcAuthServer(port int) *rpcAuth {
-	log.NewPrivateLog(constant.LogFileName)
-	return &rpcAuth{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImAuthName,
-		etcdSchema:      config.Config.Etcd.EtcdSchema,
-		etcdAddr:        config.Config.Etcd.EtcdAddr,
-	}
-}
-
-func (s *rpcAuth) Run() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, "rpc auth start...")
-
-	listenIP := ""
-	if config.Config.ListenIP == "" {
-		listenIP = "0.0.0.0"
-	} else {
-		listenIP = config.Config.ListenIP
-	}
-	address := listenIP + ":" + strconv.Itoa(s.rpcPort)
-	listener, err := net.Listen("tcp", address)
-	if err != nil {
-		panic("listening err:" + err.Error() + s.rpcRegisterName)
-	}
-	log.NewInfo(operationID, "listen network success, ", address, listener)
-	var grpcOpts []grpc.ServerOption
-	if config.Config.Prometheus.Enable {
-		promePkg.NewGrpcRequestCounter()
-		promePkg.NewGrpcRequestFailedCounter()
-		promePkg.NewGrpcRequestSuccessCounter()
-		promePkg.NewUserRegisterCounter()
-		promePkg.NewUserLoginCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(promePkg.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-
-	//service registers with etcd
-	pbAuth.RegisterAuthServer(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 = rpc.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10, "")
-	if err != nil {
-		log.NewError(operationID, "RegisterEtcd failed ", err.Error(),
-			s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName)
-		panic(utils.Wrap(err, "register auth module  rpc to etcd err"))
-
-	}
-	log.NewInfo(operationID, "RegisterAuthServer ok ", s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName)
-	err = srv.Serve(listener)
-	if err != nil {
-		log.NewError(operationID, "Serve failed ", err.Error())
-		return
-	}
-	log.NewInfo(operationID, "rpc auth ok")
-}

internal/rpc/friend/friend.go

@@ -1,78 +1,51 @@
 package friend
 
 import (
+	"Open_IM/internal/common/check"
 	"Open_IM/internal/common/convert"
+	"Open_IM/internal/common/rpc_server"
 	chat "Open_IM/internal/rpc/msg"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
-	relation2 "Open_IM/pkg/common/db/table/relation"
+	relationTb "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/middleware"
 	promePkg "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/common/tracelog"
 	pbFriend "Open_IM/pkg/proto/friend"
-	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
 	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-	"net"
-	"strconv"
-	"strings"
-
-	"Open_IM/internal/common/check"
-	"github.com/OpenIMSDK/getcdv3"
 	"google.golang.org/grpc"
 )
 
 type friendServer struct {
-	rpcPort         int
-	rpcRegisterName string
-	etcdSchema      string
-	etcdAddr        []string
+	*rpc_server.RpcServer
+
 	controller.FriendInterface
 	controller.BlackInterface
-
-	userRpc pbUser.UserClient
 }
 
 func NewFriendServer(port int) *friendServer {
-	log.NewPrivateLog(constant.LogFileName)
-	f := friendServer{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImFriendName,
-		etcdSchema:      config.Config.Etcd.EtcdSchema,
-		etcdAddr:        config.Config.Etcd.EtcdAddr,
-	}
-	ttl := 10
-	etcdClient, err := getcdv3.NewEtcdConn(config.Config.Etcd.EtcdSchema, strings.Join(f.etcdAddr, ","), config.Config.RpcRegisterIP, config.Config.Etcd.UserName, config.Config.Etcd.Password, port, ttl)
+	r, err := rpc_server.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImFriendName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
 	if err != nil {
-		panic("NewEtcdConn failed" + err.Error())
+		panic(err)
 	}
-	err = etcdClient.RegisterEtcd("", f.rpcRegisterName)
-	if err != nil {
-		panic("NewEtcdConn failed" + err.Error())
-	}
-
-	etcdClient.SetDefaultEtcdConfig(config.Config.RpcRegisterName.OpenImUserName, config.Config.RpcPort.OpenImUserPort)
-	conn := etcdClient.GetConn("", config.Config.RpcRegisterName.OpenImUserName)
-	f.userRpc = pbUser.NewUserClient(conn)
-
 	//mysql init
 	var mysql relation.Mysql
 	var model relation.FriendGorm
-	err = mysql.InitConn().AutoMigrateModel(&relation2.FriendModel{})
+	err = mysql.InitConn().AutoMigrateModel(&relationTb.FriendModel{})
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
-	err = mysql.InitConn().AutoMigrateModel(&relation2.FriendRequestModel{})
+	err = mysql.InitConn().AutoMigrateModel(&relationTb.FriendRequestModel{})
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
-
-	err = mysql.InitConn().AutoMigrateModel(&relation2.BlackModel{})
+	err = mysql.InitConn().AutoMigrateModel(&relationTb.BlackModel{})
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
@@ -81,28 +54,22 @@ func NewFriendServer(port int) *friendServer {
 	} else {
 		panic("db init err:" + "conn is nil")
 	}
-	f.FriendInterface = controller.NewFriendController(model.DB)
-	f.BlackInterface = controller.NewBlackController(model.DB)
-	return &f
+	return &friendServer{
+		RpcServer:       r,
+		FriendInterface: controller.NewFriendController(model.DB),
+		BlackInterface:  controller.NewBlackController(model.DB),
+	}
 }
 
 func (s *friendServer) Run() {
-	log.NewInfo("0", "friendServer run...")
-
-	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)
+	operationID := utils.OperationIDGenerator()
+	log.NewInfo(operationID, "friendServer run...")
+	listener, address, err := rpc_server.GetTcpListen(config.Config.ListenIP, s.Port)
 	if err != nil {
-		panic("listening err:" + err.Error() + s.rpcRegisterName)
+		panic(err)
 	}
-	log.NewInfo("0", "listen ok ", address)
+
+	log.NewInfo(operationID, "listen ok ", address)
 	defer listener.Close()
 	//grpc server
 	var grpcOpts []grpc.ServerOption
@@ -122,7 +89,7 @@ func (s *friendServer) Run() {
 	pbFriend.RegisterFriendServer(srv, s)
 	err = srv.Serve(listener)
 	if err != nil {
-		log.NewError("0", "Serve failed ", err.Error(), listener)
+		log.NewError(operationID, "Serve failed ", err.Error(), listener)
 		return
 	}
 }
@@ -166,7 +133,7 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *pbFriend.ImportFr
 		return nil, err
 	}
 
-	if utils.Contain(req.FriendUserIDs, req.OwnerUserID) {
+	if utils.Contain(req.OwnerUserID, req.FriendUserIDs...) {
 		return nil, constant.ErrCanNotAddYourself.Wrap()
 	}
 	if utils.Duplicate(req.FriendUserIDs) {
@@ -185,7 +152,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.Res
 	if err := check.Access(ctx, req.ToUserID); err != nil {
 		return nil, err
 	}
-	friendRequest := relation2.FriendRequestModel{FromUserID: req.FromUserID, ToUserID: req.ToUserID, HandleMsg: req.HandleMsg, HandleResult: req.HandleResult}
+	friendRequest := relationTb.FriendRequestModel{FromUserID: req.FromUserID, ToUserID: req.ToUserID, HandleMsg: req.HandleMsg, HandleResult: req.HandleResult}
 	if req.HandleResult == constant.FriendResponseAgree {
 		err := s.AgreeFriendRequest(ctx, &friendRequest)
 		if err != nil {
@@ -211,7 +178,7 @@ func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFri
 	if err := check.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
-	_, err = s.FindFriends(ctx, req.OwnerUserID, []string{req.FriendUserID})
+	_, err = s.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
 	if err != nil {
 		return nil, err
 	}
@@ -228,7 +195,7 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFri
 	if err := check.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
-	_, err = s.FindFriends(ctx, req.OwnerUserID, []string{req.FriendUserID})
+	_, err = s.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
 	if err != nil {
 		return nil, err
 	}
@@ -240,12 +207,12 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFri
 }
 
 // ok
-func (s *friendServer) GetDesignatedFriendsReq(ctx context.Context, req *pbFriend.GetDesignatedFriendsReq) (resp *pbFriend.GetDesignatedFriendsResp, err error) {
+func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbFriend.GetDesignatedFriendsReq) (resp *pbFriend.GetDesignatedFriendsResp, err error) {
 	resp = &pbFriend.GetDesignatedFriendsResp{}
 	if err := check.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	friends, total, err := s.FriendInterface.FindOwnerFriends(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	friends, total, err := s.FriendInterface.PageOwnerFriends(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
@@ -263,7 +230,7 @@ func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *pbF
 	if err := check.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	friendRequests, total, err := s.FriendInterface.FindFriendRequestToMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	friendRequests, total, err := s.FriendInterface.PageFriendRequestToMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
@@ -281,7 +248,7 @@ func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *p
 	if err := check.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	friendRequests, total, err := s.FriendInterface.FindFriendRequestFromMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	friendRequests, total, err := s.FriendInterface.PageFriendRequestFromMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
@@ -309,7 +276,7 @@ func (s *friendServer) GetPaginationFriends(ctx context.Context, req *pbFriend.G
 	if utils.Duplicate(req.FriendUserIDs) {
 		return nil, constant.ErrArgs.Wrap("friend userID repeated")
 	}
-	friends, err := s.FriendInterface.FindFriends(ctx, req.OwnerUserID, req.FriendUserIDs)
+	friends, err := s.FriendInterface.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
 	if err != nil {
 		return nil, err
 	}

internal/rpc/group/group.go

@@ -1,13 +1,14 @@
 package group
 
 import (
+	"Open_IM/internal/common/network"
 	chat "Open_IM/internal/rpc/msg"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/controller"
-	relation_conn "Open_IM/pkg/common/db/relation"
-	"Open_IM/pkg/common/db/table/relation"
+	"Open_IM/pkg/common/db/relation"
+	relationTb "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/db/unrelation"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/middleware"
@@ -20,7 +21,6 @@ import (
 	"Open_IM/pkg/utils"
 	"context"
 	"fmt"
-	"github.com/OpenIMSDK/getcdv3"
 	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
 	"math/big"
 	"net"
@@ -36,13 +36,10 @@ import (
 type groupServer struct {
 	rpcPort         int
 	rpcRegisterName string
-	etcdSchema      string
-	etcdAddr        []string
+	schema          string
+	zkAddr          []string
 	GroupInterface  controller.GroupInterface
-
-	etcdConn *getcdv3.EtcdConn
-	//userRpc         pbUser.UserClient
-	//conversationRpc pbConversation.ConversationClient
+	registerCenter  discoveryRegistry.SvcDiscoveryRegistry
 }
 
 func NewGroupServer(port int) *groupServer {
@@ -50,73 +47,48 @@ func NewGroupServer(port int) *groupServer {
 	g := groupServer{
 		rpcPort:         port,
 		rpcRegisterName: config.Config.RpcRegisterName.OpenImGroupName,
-		etcdSchema:      config.Config.Etcd.EtcdSchema,
-		etcdAddr:        config.Config.Etcd.EtcdAddr,
+		schema:          config.Config.Zookeeper.Schema,
+		zkAddr:          config.Config.Zookeeper.ZkAddr,
 	}
-	ttl := 10
-	etcdClient, err := getcdv3.NewEtcdConn(config.Config.Etcd.EtcdSchema, strings.Join(g.etcdAddr, ","), config.Config.RpcRegisterIP, config.Config.Etcd.UserName, config.Config.Etcd.Password, port, ttl)
-	if err != nil {
-		panic("NewEtcdConn failed" + err.Error())
-	}
-	err = etcdClient.RegisterEtcd("", g.rpcRegisterName)
-	if err != nil {
-		panic("NewEtcdConn failed" + err.Error())
-	}
-	etcdClient.SetDefaultEtcdConfig(config.Config.RpcRegisterName.OpenImUserName, config.Config.RpcPort.OpenImUserPort)
-	//conn := etcdClient.GetConn("", config.Config.RpcRegisterName.OpenImUserName)
-	//g.userRpc = pbUser.NewUserClient(conn)
-
-	etcdClient.SetDefaultEtcdConfig(config.Config.RpcRegisterName.OpenImConversationName, config.Config.RpcPort.OpenImConversationPort)
-	//conn = etcdClient.GetConn("", config.Config.RpcRegisterName.OpenImConversationName)
-	//g.conversationRpc = pbConversation.NewConversationClient(conn)
-
 	//mysql init
-	var mysql relation_conn.Mysql
+	var mysql relation.Mysql
 	var mongo unrelation.Mongo
-	var groupModel relation.GroupModel
+	var groupModel relationTb.GroupModel
 	var redis cache.RedisClient
-	err = mysql.InitConn().AutoMigrateModel(&groupModel)
+	err := mysql.InitConn().AutoMigrateModel(&groupModel)
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
-	if mysql.GormConn() != nil {
-		groupModel.DB = mysql.GormConn()
-	} else {
-		panic("db init err:" + "conn is nil")
-	}
 	mongo.InitMongo()
 	redis.InitRedis()
 	mongo.CreateSuperGroupIndex()
-	zkClient, err := openKeeper.NewClient([]string{"43.154.157.177:2181"}, config.Config.Etcd.EtcdSchema, 10, "", "")
+	zkClient, err := openKeeper.NewClient(config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema, 10, "", "")
 	if err != nil {
 		panic(err.Error())
 	}
-	registerIP, err := utils.GetRpcIP()
-	err = zkClient.Register(config.Config.RpcRegisterName.OpenImGroupName, registerIP, port)
+	registerIP, err := network.GetRpcRegisterIP(config.Config.RpcRegisterIP)
+	g.registerCenter = zkClient
+	err = g.registerCenter.Register(config.Config.RpcRegisterName.OpenImGroupName, registerIP, port)
 	if err != nil {
 		panic(err.Error())
 	}
-	var registerCenter discoveryRegistry.SvcDiscoveryRegistry = zkClient
-	conns, err := registerCenter.GetConns(config.Config.RpcRegisterName.OpenImConversationName)
+
+	//conns, err := g.registerCenter.GetConns(config.Config.RpcRegisterName.OpenImConversationName)
+
 	g.GroupInterface = controller.NewGroupInterface(controller.NewGroupDatabase(mysql.GormConn(), redis.GetClient(), mongo.GetClient()))
 	return &g
 }
 
 func (s *groupServer) Run() {
-	log.NewInfo("", "group rpc start ")
-	listenIP := ""
-	if config.Config.ListenIP == "" {
-		listenIP = "0.0.0.0"
-	} else {
-		listenIP = config.Config.ListenIP
-	}
-	address := listenIP + ":" + strconv.Itoa(s.rpcPort)
+	operationID := utils.OperationIDGenerator()
+	log.NewInfo(operationID, "group rpc start ")
+	address := network.GetListenIP(config.Config.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("", "listen network success, ", address, listener)
+	log.NewInfo(operationID, "listen network success, ", address, listener)
 
 	defer listener.Close()
 	//grpc server
@@ -141,28 +113,12 @@ func (s *groupServer) Run() {
 	defer srv.GracefulStop()
 	//Service registers with etcd
 	pbGroup.RegisterGroupServer(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("", "RegisterEtcd failed ", err.Error())
-		panic(utils.Wrap(err, "register group module  rpc to etcd err"))
-
-	}
-	log.Info("", "RegisterEtcd ", s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName)
 	err = srv.Serve(listener)
 	if err != nil {
-		log.NewError("", "Serve failed ", err.Error())
+		log.NewError(operationID, "Serve failed ", err.Error())
 		return
 	}
-	log.NewInfo("", "group rpc success")
+	log.NewInfo(operationID, "group rpc success")
 }
 
 func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error {
@@ -200,7 +156,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if err := callbackBeforeCreateGroup(ctx, req); err != nil {
 		return nil, err
 	}
-	var groupMembers []*relation.GroupMemberModel
+	var groupMembers []*relationTb.GroupMemberModel
 	group := PbToDBGroupInfo(req.GroupInfo)
 	group.GroupID = genGroupID(ctx, req.GroupInfo.GroupID)
 	joinGroup := func(userID string, roleLevel int32) error {
@@ -265,7 +221,7 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 	if len(members) == 0 {
 		return resp, nil
 	}
-	groupIDs := utils.Slice(members, func(e *relation.GroupMemberModel) string {
+	groupIDs := utils.Slice(members, func(e *relationTb.GroupMemberModel) string {
 		return e.GroupID
 	})
 	groups, err := s.GroupInterface.FindGroup(ctx, groupIDs)
@@ -280,12 +236,12 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 	if err != nil {
 		return nil, err
 	}
-	ownerMap := utils.SliceToMap(owners, func(e *relation.GroupMemberModel) string {
+	ownerMap := utils.SliceToMap(owners, func(e *relationTb.GroupMemberModel) string {
 		return e.GroupID
 	})
-	resp.Groups = utils.Slice(utils.Order(groupIDs, groups, func(group *relation.GroupModel) string {
+	resp.Groups = utils.Slice(utils.Order(groupIDs, groups, func(group *relationTb.GroupModel) string {
 		return group.GroupID
-	}), func(group *relation.GroupModel) *open_im_sdk.GroupInfo {
+	}), func(group *relationTb.GroupModel) *open_im_sdk.GroupInfo {
 		return DbToPbGroupInfo(group, ownerMap[group.GroupID].UserID, uint32(groupMemberNum[group.GroupID]))
 	})
 	return resp, nil
@@ -310,7 +266,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	if err != nil {
 		return nil, err
 	}
-	memberMap := utils.SliceToMap(members, func(e *relation.GroupMemberModel) string {
+	memberMap := utils.SliceToMap(members, func(e *relationTb.GroupMemberModel) string {
 		return e.UserID
 	})
 	if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 {
@@ -364,7 +320,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		}
 	} else {
 		opUserID := tracelog.GetOpUserID(ctx)
-		var groupMembers []*relation.GroupMemberModel
+		var groupMembers []*relationTb.GroupMemberModel
 		for _, userID := range req.InvitedUserIDs {
 			member := PbToDbGroupMember(userMap[userID])
 			member.GroupID = req.GroupID
@@ -398,7 +354,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
 	if err != nil {
 		return nil, err
 	}
-	resp.Members = utils.Slice(members, func(e *relation.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
 		return DbToPbGroupMembersCMSResp(e)
 	})
 	return resp, nil
@@ -411,7 +367,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 		return nil, err
 	}
 	resp.Total = total
-	resp.Members = utils.Slice(members, func(e *relation.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
 		return DbToPbGroupMembersCMSResp(e)
 	})
 	return resp, nil
@@ -447,7 +403,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		if err != nil {
 			return nil, err
 		}
-		memberMap := make(map[string]*relation.GroupMemberModel)
+		memberMap := make(map[string]*relationTb.GroupMemberModel)
 		for i, member := range members {
 			memberMap[member.UserID] = members[i]
 		}
@@ -496,7 +452,7 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 	if err != nil {
 		return nil, err
 	}
-	resp.Members = utils.Slice(members, func(e *relation.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
 		return DbToPbGroupMembersCMSResp(e)
 	})
 	return resp, nil
@@ -533,7 +489,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	if err != nil {
 		return nil, err
 	}
-	groupMap := utils.SliceToMap(groups, func(e *relation.GroupModel) string {
+	groupMap := utils.SliceToMap(groups, func(e *relationTb.GroupModel) string {
 		return e.GroupID
 	})
 	if ids := utils.Single(utils.Keys(groupMap), groupIDs); len(ids) > 0 {
@@ -547,10 +503,10 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	if err != nil {
 		return nil, err
 	}
-	ownerMap := utils.SliceToMap(owners, func(e *relation.GroupMemberModel) string {
+	ownerMap := utils.SliceToMap(owners, func(e *relationTb.GroupMemberModel) string {
 		return e.GroupID
 	})
-	resp.GroupRequests = utils.Slice(groupRequests, func(e *relation.GroupRequestModel) *open_im_sdk.GroupRequest {
+	resp.GroupRequests = utils.Slice(groupRequests, func(e *relationTb.GroupRequestModel) *open_im_sdk.GroupRequest {
 		return DbToPbGroupRequest(e, userMap[e.UserID], DbToPbGroupInfo(groupMap[e.GroupID], ownerMap[e.GroupID].UserID, uint32(groupMemberNumMap[e.GroupID])))
 	})
 	return resp, nil
@@ -573,10 +529,10 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
 	if err != nil {
 		return nil, err
 	}
-	ownerMap := utils.SliceToMap(owners, func(e *relation.GroupMemberModel) string {
+	ownerMap := utils.SliceToMap(owners, func(e *relationTb.GroupMemberModel) string {
 		return e.GroupID
 	})
-	resp.GroupInfos = utils.Slice(groups, func(e *relation.GroupModel) *open_im_sdk.GroupInfo {
+	resp.GroupInfos = utils.Slice(groups, func(e *relationTb.GroupModel) *open_im_sdk.GroupInfo {
 		return DbToPbGroupInfo(e, ownerMap[e.GroupID].UserID, uint32(groupMemberNumMap[e.GroupID]))
 	})
 	return resp, nil
@@ -618,9 +574,9 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 	if err != nil {
 		return nil, err
 	}
-	var member *relation.GroupMemberModel
+	var member *relationTb.GroupMemberModel
 	if req.HandleResult == constant.GroupResponseAgree {
-		member = &relation.GroupMemberModel{
+		member = &relationTb.GroupMemberModel{
 			GroupID:        req.GroupID,
 			UserID:         user.UserID,
 			Nickname:       user.Nickname,
@@ -664,7 +620,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		if group.GroupType == constant.SuperGroup {
 			return nil, constant.ErrGroupTypeNotSupport.Wrap()
 		}
-		user, err := relation_conn.GetUserByUserID(tracelog.GetOpUserID(ctx))
+		user, err := relation.GetUserByUserID(tracelog.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
@@ -677,20 +633,20 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
 			return nil, err
 		}
-		if err := s.GroupInterface.CreateGroup(ctx, nil, []*relation.GroupMemberModel{groupMember}); err != nil {
+		if err := s.GroupInterface.CreateGroup(ctx, nil, []*relationTb.GroupMemberModel{groupMember}); err != nil {
 			return nil, err
 		}
 		chat.MemberEnterDirectlyNotification(req.GroupID, tracelog.GetOpUserID(ctx), tracelog.GetOperationID(ctx))
 		return resp, nil
 	}
-	groupRequest := relation.GroupRequestModel{
+	groupRequest := relationTb.GroupRequestModel{
 		UserID:     tracelog.GetOpUserID(ctx),
 		ReqMsg:     req.ReqMessage,
 		GroupID:    req.GroupID,
 		JoinSource: req.JoinSource,
 		ReqTime:    time.Now(),
 	}
-	if err := s.GroupInterface.CreateGroupRequest(ctx, []*relation.GroupRequestModel{&groupRequest}); err != nil {
+	if err := s.GroupInterface.CreateGroupRequest(ctx, []*relationTb.GroupRequestModel{&groupRequest}); err != nil {
 		return nil, err
 	}
 	chat.JoinGroupApplicationNotification(ctx, req)
@@ -729,7 +685,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 			return nil, constant.ErrNoPermission.Wrap("no group owner or admin")
 		}
 	}
-	group, err := s.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
+	group, err := s.GroupInterface.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -743,7 +699,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	if err := s.GroupInterface.UpdateGroup(ctx, group.GroupID, data); err != nil {
 		return nil, err
 	}
-	group, err = s.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
+	group, err = s.GroupInterface.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -770,7 +726,7 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 	if err != nil {
 		return nil, err
 	}
-	memberMap := utils.SliceToMap(members, func(e *relation.GroupMemberModel) string { return e.UserID })
+	memberMap := utils.SliceToMap(members, func(e *relationTb.GroupMemberModel) string { return e.UserID })
 	if ids := utils.Single([]string{req.OldOwnerUserID, req.NewOwnerUserID}, utils.Keys(memberMap)); len(ids) > 0 {
 		return nil, constant.ErrArgs.Wrap("user not in group " + strings.Join(ids, ","))
 	}
@@ -804,7 +760,7 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq) (*pbGroup.GetGroupsResp, error) {
 	resp := &pbGroup.GetGroupsResp{}
 	var (
-		groups []*relation.GroupModel
+		groups []*relationTb.GroupModel
 		err    error
 	)
 	if req.GroupID != "" {
@@ -816,14 +772,14 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
 	if err != nil {
 		return nil, err
 	}
-	groupIDs := utils.Slice(groups, func(e *relation.GroupModel) string {
+	groupIDs := utils.Slice(groups, func(e *relationTb.GroupModel) string {
 		return e.GroupID
 	})
 	ownerMembers, err := s.GroupInterface.FindGroupMember(ctx, groupIDs, nil, []int32{constant.GroupOwner})
 	if err != nil {
 		return nil, err
 	}
-	ownerMemberMap := utils.SliceToMap(ownerMembers, func(e *relation.GroupMemberModel) string {
+	ownerMemberMap := utils.SliceToMap(ownerMembers, func(e *relationTb.GroupMemberModel) string {
 		return e.GroupID
 	})
 	if ids := utils.Single(groupIDs, utils.Keys(ownerMemberMap)); len(ids) > 0 {
@@ -833,7 +789,7 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
 	if err != nil {
 		return nil, err
 	}
-	resp.Groups = utils.Slice(groups, func(group *relation.GroupModel) *pbGroup.CMSGroup {
+	resp.Groups = utils.Slice(groups, func(group *relationTb.GroupModel) *pbGroup.CMSGroup {
 		member := ownerMemberMap[group.GroupID]
 		return DbToPbCMSGroup(group, member.UserID, member.Nickname, uint32(groupMemberNumMap[group.GroupID]))
 	})
@@ -847,7 +803,7 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
 		return nil, err
 	}
 	resp.Total = total
-	resp.Members = utils.Slice(members, func(e *relation.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
 		return DbToPbGroupMembersCMSResp(e)
 	})
 	return resp, nil
@@ -867,14 +823,14 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 	if len(requests) == 0 {
 		return resp, nil
 	}
-	groupIDs := utils.Distinct(utils.Slice(requests, func(e *relation.GroupRequestModel) string {
+	groupIDs := utils.Distinct(utils.Slice(requests, func(e *relationTb.GroupRequestModel) string {
 		return e.GroupID
 	}))
 	groups, err := s.GroupInterface.FindGroup(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	groupMap := utils.SliceToMap(groups, func(e *relation.GroupModel) string {
+	groupMap := utils.SliceToMap(groups, func(e *relationTb.GroupModel) string {
 		return e.GroupID
 	})
 	if ids := utils.Single(groupIDs, utils.Keys(groupMap)); len(ids) > 0 {
@@ -884,7 +840,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 	if err != nil {
 		return nil, err
 	}
-	ownerMap := utils.SliceToMap(owners, func(e *relation.GroupMemberModel) string {
+	ownerMap := utils.SliceToMap(owners, func(e *relationTb.GroupMemberModel) string {
 		return e.GroupID
 	})
 	if ids := utils.Single(groupIDs, utils.Keys(ownerMap)); len(ids) > 0 {
@@ -894,7 +850,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 	if err != nil {
 		return nil, err
 	}
-	resp.GroupRequests = utils.Slice(requests, func(e *relation.GroupRequestModel) *open_im_sdk.GroupRequest {
+	resp.GroupRequests = utils.Slice(requests, func(e *relationTb.GroupRequestModel) *open_im_sdk.GroupRequest {
 		return DbToPbGroupRequest(e, user, DbToPbGroupInfo(groupMap[e.GroupID], ownerMap[e.GroupID].UserID, uint32(groupMemberNum[e.GroupID])))
 	})
 	return resp, nil
@@ -1058,7 +1014,7 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
 	if err != nil {
 		return nil, err
 	}
-	resp.GroupAbstractInfos = utils.Slice(groups, func(e *relation.GroupModel) *pbGroup.GroupAbstractInfo {
+	resp.GroupAbstractInfos = utils.Slice(groups, func(e *relationTb.GroupModel) *pbGroup.GroupAbstractInfo {
 		userIDs := groupUserMap[e.GroupID]
 		utils.Sort(userIDs, true)
 		bi := big.NewInt(0)
@@ -1077,7 +1033,7 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.Ge
 	if err != nil {
 		return nil, err
 	}
-	resp.Members = utils.Slice(members, func(e *relation.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
 		return DbToPbGroupMembersCMSResp(e)
 	})
 	return resp, nil

internal/rpc/user/user.go

@@ -2,27 +2,21 @@ package user
 
 import (
 	"Open_IM/internal/common/convert"
+	"Open_IM/internal/common/rpc_server"
 	chat "Open_IM/internal/rpc/msg"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
-	relation2 "Open_IM/pkg/common/db/table/relation"
+	relationTb "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/log"
 	promePkg "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/common/tracelog"
-	pbFriend "Open_IM/pkg/proto/friend"
-	pbGroup "Open_IM/pkg/proto/group"
 	server_api_params "Open_IM/pkg/proto/sdk_ws"
 	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
-	"github.com/golang/protobuf/ptypes/wrappers"
-	"net"
-	"strconv"
-	"strings"
-
 	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
 
 	"google.golang.org/grpc"
@@ -31,23 +25,19 @@ import (
 type userServer struct {
 	rpcPort         int
 	rpcRegisterName string
-	etcdSchema      string
-	etcdAddr        []string
+	*rpc_server.RpcServer
 	controller.UserInterface
 }
 
 func NewUserServer(port int) *userServer {
-	log.NewPrivateLog(constant.LogFileName)
-	u := userServer{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImUserName,
-		etcdSchema:      config.Config.Etcd.EtcdSchema,
-		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	r, err := rpc_server.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImUserName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+	if err != nil {
+		panic(err)
 	}
 	//mysql init
 	var mysql relation.Mysql
 	var model relation.UserGorm
-	err := mysql.InitConn().AutoMigrateModel(&model)
+	err = mysql.InitConn().AutoMigrateModel(&model)
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
@@ -56,27 +46,17 @@ func NewUserServer(port int) *userServer {
 	} else {
 		panic("db init err:" + "conn is nil")
 	}
-	u.UserInterface = controller.NewUserController(model.DB)
-	return &u
+	return &userServer{RpcServer: r, UserInterface: controller.NewUserController(model.DB)}
 }
 
 func (s *userServer) Run() {
-	log.NewInfo("", "rpc user 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)
+	operationID := utils.OperationIDGenerator()
+	log.NewInfo(operationID, "rpc user start...")
+	listener, address, err := rpc_server.GetTcpListen(config.Config.ListenIP, s.Port)
 	if err != nil {
-		panic("listening err:" + err.Error() + s.rpcRegisterName)
+		panic(err)
 	}
-	log.NewInfo("", "listen network success, address ", address, listener)
+	log.NewInfo(operationID, "listen ok ", address)
 	defer listener.Close()
 	//grpc server
 	var grpcOpts []grpc.ServerOption
@@ -94,41 +74,22 @@ func (s *userServer) Run() {
 	defer srv.GracefulStop()
 	//Service registers with etcd
 	pbUser.RegisterUserServer(srv, s)
-	rpcRegisterIP := config.Config.RpcRegisterIP
-	if config.Config.RpcRegisterIP == "" {
-		rpcRegisterIP, err = utils.GetLocalIP()
-		if err != nil {
-			log.Error("", "GetLocalIP failed ", err.Error())
-		}
-	}
-	err = rpc.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10, "")
-	if err != nil {
-		log.NewError("", "RegisterEtcd failed ", err.Error(), s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName)
-		panic(utils.Wrap(err, "register user module  rpc to etcd err"))
-	}
+
 	err = srv.Serve(listener)
 	if err != nil {
-		log.NewError("", "Serve failed ", err.Error())
-		return
+		panic(err)
 	}
-	log.NewInfo("", "rpc  user success")
+	log.NewInfo(operationID, "rpc  user success")
 }
 
+// ok
 func (s *userServer) SyncJoinedGroupMemberFaceURL(ctx context.Context, userID string, faceURL string, operationID string, opUserID string) {
-	etcdConn, err := rpc.GetConn(ctx, config.Config.RpcRegisterName.OpenImFriendName)
+	members, err := s.GetJoinedGroupMembers(ctx, userID)
 	if err != nil {
 		return
 	}
-	client := pbGroup.NewGroupClient(etcdConn)
-	newReq := &pbGroup.GetJoinedGroupListReq{FromUserID: userID}
-	rpcResp, err := client.GetJoinedGroupList(ctx, newReq)
-	if err != nil {
-		return
-	}
-
-	for _, group := range rpcResp.Groups {
-		req := &pbGroup.SetGroupMemberInfoReq{GroupID: group.GroupID, UserID: userID, FaceURL: &wrappers.StringValue{Value: faceURL}}
-		_, err := client.SetGroupMemberInfo(ctx, req)
+	for _, group := range members {
+		err := s.SetGroupMemberFaceURL(ctx, faceURL, group.GroupID, userID)
 		if err != nil {
 			return
 		}
@@ -136,29 +97,15 @@ func (s *userServer) SyncJoinedGroupMemberFaceURL(ctx context.Context, userID st
 	}
 }
 
+// ok
 func (s *userServer) SyncJoinedGroupMemberNickname(ctx context.Context, userID string, newNickname, oldNickname string, operationID string, opUserID string) {
-	etcdConn, err := rpc.GetConn(ctx, config.Config.RpcRegisterName.OpenImFriendName)
+	members, err := s.GetJoinedGroupMembers(ctx, userID)
 	if err != nil {
 		return
 	}
-	client := pbGroup.NewGroupClient(etcdConn)
-	newReq := &pbGroup.GetJoinedGroupListReq{FromUserID: userID}
-	rpcResp, err := client.GetJoinedGroupList(ctx, newReq)
-	if err != nil {
-		return
-	}
-	req := pbGroup.GetUserInGroupMembersReq{UserID: userID}
-	for _, group := range rpcResp.Groups {
-		req.GroupIDs = append(req.GroupIDs, group.GroupID)
-	}
-	resp, err := client.GetUserInGroupMembers(ctx, &req)
-	if err != nil {
-		return
-	}
-	for _, v := range resp.Members {
+	for _, v := range members {
 		if v.Nickname == oldNickname {
-			req := pbGroup.SetGroupMemberNicknameReq{Nickname: newNickname, GroupID: v.GroupID, UserID: v.UserID}
-			_, err := client.SetGroupMemberNickname(ctx, &req)
+			err := s.SetGroupMemberNickname(ctx, newNickname, v.GroupID, v.UserID)
 			if err != nil {
 				return
 			}
@@ -167,10 +114,25 @@ func (s *userServer) SyncJoinedGroupMemberNickname(ctx context.Context, userID s
 	}
 }
 
+// 设置群昵称
+func (s *userServer) SetGroupMemberNickname(ctx context.Context, nickname string, groupID string, userID string) (err error) {
+	return
+}
+
+// 设置群头像
+func (s *userServer) SetGroupMemberFaceURL(ctx context.Context, faceURL string, groupID string, userID string) (err error) {
+	return
+}
+
+// 获取加入的群成员信息
+func (s *userServer) GetJoinedGroupMembers(ctx context.Context, userID string) (members []*server_api_params.GroupMemberFullInfo, err error) {
+	return
+}
+
 // ok
 func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbUser.GetDesignateUsersReq) (resp *pbUser.GetDesignateUsersResp, err error) {
 	resp = &pbUser.GetDesignateUsersResp{}
-	users, err := s.Find(ctx, req.UserIDs)
+	users, err := s.FindWithError(ctx, req.UserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -181,15 +143,20 @@ func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbUser.GetDesig
 	return resp, nil
 }
 
-func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserInfoReq) (*pbUser.UpdateUserInfoResp, error) {
-	resp := pbUser.UpdateUserInfoResp{}
-	err := token_verify.CheckAccessV3(ctx, req.UserInfo.UserID)
+func (s *userServer) GetAllPageFriends(ctx context.Context, ownerUserID string) (resp []*server_api_params.FriendInfo, err error) {
+	return
+}
+
+// ok
+func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserInfoReq) (resp *pbUser.UpdateUserInfoResp, err error) {
+	resp = &pbUser.UpdateUserInfoResp{}
+	err = token_verify.CheckAccessV3(ctx, req.UserInfo.UserID)
 	if err != nil {
 		return nil, err
 	}
 	oldNickname := ""
 	if req.UserInfo.Nickname != "" {
-		u, err := s.Find(ctx, []string{req.UserInfo.UserID})
+		u, err := s.FindWithError(ctx, []string{req.UserInfo.UserID})
 		if err != nil {
 			return nil, err
 		}
@@ -199,40 +166,34 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	if err != nil {
 		return nil, err
 	}
-	err = s.Update(ctx, []*relation2.UserModel{user})
+	err = s.Update(ctx, []*relationTb.UserModel{user})
 	if err != nil {
 		return nil, err
 	}
-	etcdConn, err := rpc.GetConn(ctx, config.Config.RpcRegisterName.OpenImFriendName)
-	if err != nil {
-		return nil, err
-	}
-	client := pbFriend.NewFriendClient(etcdConn)
-	newReq := &pbFriend.GetFriendsReq{UserID: req.UserInfo.UserID}
-	rpcResp, err := client.GetFriends(context.Background(), newReq)
+	friends, err := s.GetAllPageFriends(ctx, req.UserInfo.UserID)
 	if err != nil {
 		return nil, err
 	}
 	go func() {
-		for _, v := range rpcResp.FriendsInfo {
+		for _, v := range friends {
 			chat.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
 		}
 	}()
 
 	chat.UserInfoUpdatedNotification(ctx, tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
 	if req.UserInfo.FaceURL != "" {
-		s.SyncJoinedGroupMemberFaceURL(ctx, req.UserInfo.UserID, req.UserInfo.FaceURL, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
+		go s.SyncJoinedGroupMemberFaceURL(ctx, req.UserInfo.UserID, req.UserInfo.FaceURL, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
 	}
 	if req.UserInfo.Nickname != "" {
-		s.SyncJoinedGroupMemberNickname(ctx, req.UserInfo.UserID, req.UserInfo.Nickname, oldNickname, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
+		go s.SyncJoinedGroupMemberNickname(ctx, req.UserInfo.UserID, req.UserInfo.Nickname, oldNickname, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
 	}
-	return &resp, nil
+	return resp, nil
 }
 
+// ok
 func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbUser.SetGlobalRecvMessageOptReq) (resp *pbUser.SetGlobalRecvMessageOptResp, err error) {
 	resp = &pbUser.SetGlobalRecvMessageOptResp{}
-
-	if _, err := s.Find(ctx, []string{req.UserID}); err != nil {
+	if _, err := s.FindWithError(ctx, []string{req.UserID}); err != nil {
 		return nil, err
 	}
 	m := make(map[string]interface{}, 1)
@@ -244,18 +205,22 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbUser.Se
 	return resp, nil
 }
 
+// ok
 func (s *userServer) AccountCheck(ctx context.Context, req *pbUser.AccountCheckReq) (resp *pbUser.AccountCheckResp, err error) {
 	resp = &pbUser.AccountCheckResp{}
+	if utils.Duplicate(req.CheckUserIDs) {
+		return nil, constant.ErrArgs.Wrap("userID repeated")
+	}
 	err = token_verify.CheckAdmin(ctx)
 	if err != nil {
 		return nil, err
 	}
-	user, err := s.Find(ctx, req.CheckUserIDs)
+	users, err := s.Find(ctx, req.CheckUserIDs)
 	if err != nil {
 		return nil, err
 	}
 	userIDs := make(map[string]interface{}, 0)
-	for _, v := range user {
+	for _, v := range users {
 		userIDs[v.UserID] = nil
 	}
 	for _, v := range req.CheckUserIDs {
@@ -270,25 +235,19 @@ func (s *userServer) AccountCheck(ctx context.Context, req *pbUser.AccountCheckR
 	return resp, nil
 }
 
+// ok
 func (s *userServer) GetPaginationUsers(ctx context.Context, req *pbUser.GetPaginationUsersReq) (resp *pbUser.GetPaginationUsersResp, err error) {
 	resp = &pbUser.GetPaginationUsersResp{}
-	usersDB, total, err := s.Get(ctx, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	usersDB, total, err := s.Page(ctx, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-
 	resp.Total = int32(total)
-
-	for _, userDB := range usersDB {
-		u, err := convert.NewDBUser(userDB).Convert()
-		if err != nil {
-			return nil, err
-		}
-		resp.Users = append(resp.Users, u)
-	}
+	resp.Users, err = (*convert.DBUser)(nil).DB2PB(usersDB)
 	return resp, nil
 }
 
+// ok
 func (s *userServer) UserRegister(ctx context.Context, req *pbUser.UserRegisterReq) (resp *pbUser.UserRegisterResp, err error) {
 	resp = &pbUser.UserRegisterResp{}
 	if utils.DuplicateAny(req.Users, func(e *server_api_params.UserInfo) string { return e.UserID }) {
@@ -304,7 +263,7 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbUser.UserRegisterR
 		return nil, err
 	}
 	if exist {
-		return nil, constant.ErrRegisteredAlready.Wrap("userID exist in db")
+		return nil, constant.ErrRegisteredAlready.Wrap("userID registered already")
 	}
 	users, err := (*convert.PBUser)(nil).PB2DB(req.Users)
 	if err != nil {