blackteay/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2025-11-05 11:52:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: group update

Browse Source
This commit is contained in:
Gordon 2024-04-07 17:42:45 +08:00
parent 8ce565573e
commit 8730664dba
6 changed files with 125 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/openim-rpc/openim-rpc-group/main.go
View File

@ -15,16 +15,12 @@
package main
import (
"github.com/openimsdk/open-im-server/v3/internal/rpc/group"
"github.com/openimsdk/open-im-server/v3/pkg/common/cmd"
"github.com/openimsdk/tools/system/program"
)
func main() {
rpcCmd := cmd.NewRpcCmd(cmd.RpcGroupServer, group.Start)
rpcCmd.AddPortFlag()
rpcCmd.AddPrometheusPortFlag()
if err := rpcCmd.Exec(); err != nil {
if err := cmd.NewGroupRpcCmd().Exec(); err != nil {
program.ExitWithError(err)
}
}

2
internal/rpc/group/callback.go
View File

@ -34,7 +34,7 @@ import (
type GroupEventCallbackConfig struct {
CallbackUrl string
BeforeCreateGroup config.CallBackConfig
BeforeCreateGroup config.WebhookConfig
}
// CallbackBeforeCreateGroup callback before create group.

88
internal/rpc/group/group.go
View File

@ -17,6 +17,7 @@ package group
import (
"context"
"fmt"
"github.com/openimsdk/open-im-server/v3/pkg/common/cmd"
"math/big"
"math/rand"
"strconv"
@ -25,7 +26,6 @@ import (
"github.com/openimsdk/open-im-server/v3/pkg/authverify"
"github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
"github.com/openimsdk/open-im-server/v3/pkg/common/config"
"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
"github.com/openimsdk/open-im-server/v3/pkg/common/db/controller"
"github.com/openimsdk/open-im-server/v3/pkg/common/db/mgo"
@ -58,15 +58,15 @@ type groupServer struct {
notification *notification.GroupNotificationSender
conversationRpcClient rpcclient.ConversationRpcClient
msgRpcClient rpcclient.MessageRpcClient
config *config.GlobalConfig
config *cmd.GroupConfig
}
func Start(ctx context.Context, config *config.GlobalConfig, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
mgocli, err := mongoutil.NewMongoDB(ctx, config.Mongo.Build())
func Start(ctx context.Context, config *cmd.GroupConfig, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
if err != nil {
return err
}
rdb, err := redisutil.NewRedisClient(ctx, config.Redis.Build())
rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
if err != nil {
return err
}
@ -82,9 +82,9 @@ func Start(ctx context.Context, config *config.GlobalConfig, client discovery.Sv
if err != nil {
return err
}
userRpcClient := rpcclient.NewUserRpcClient(client, config.RpcRegisterName.OpenImUserName, &config.Manager, &config.IMAdmin)
msgRpcClient := rpcclient.NewMessageRpcClient(client, config.RpcRegisterName.OpenImMsgName)
conversationRpcClient := rpcclient.NewConversationRpcClient(client, config.RpcRegisterName.OpenImConversationName)
userRpcClient := rpcclient.NewUserRpcClient(client, config.Share.RpcRegisterName.User, &config.Share.IMAdmin)
msgRpcClient := rpcclient.NewMessageRpcClient(client, config.Share.RpcRegisterName.Msg)
conversationRpcClient := rpcclient.NewConversationRpcClient(client, config.Share.RpcRegisterName.Conversation)
var gs groupServer
database := controller.NewGroupDatabase(rdb, groupDB, groupMemberDB, groupRequestDB, mgocli.GetTx(), grouphash.NewGroupHashFromGroupServer(&gs))
gs.db = database
@ -128,7 +128,7 @@ func (s *groupServer) NotificationUserInfoUpdate(ctx context.Context, req *pbgro
}
func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error {
if !authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin) {
if !authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin) {
groupMember, err := s.db.TakeGroupMember(ctx, groupID, mcontext.GetOpUserID(ctx))
if err != nil {
return err
@ -193,7 +193,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
if req.OwnerUserID == "" {
return nil, errs.ErrArgs.WrapMsg("no group owner")
}
if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, &s.config.Manager, &s.config.IMAdmin); err != nil {
if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, &s.config.Share.IMAdmin); err != nil {
return nil, err
}
userIDs := append(append(req.MemberUserIDs, req.AdminUserIDs...), req.OwnerUserID)
@ -216,8 +216,8 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
}
config := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeCreateGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeCreateGroup,
}
// Callback Before create Group
@ -232,8 +232,8 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
}
beforeCreateGroupConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeMemberJoinGroup,
}
joinGroup := func(userID string, roleLevel int32) error {
@ -325,7 +325,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
}
func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbgroup.GetJoinedGroupListReq) (*pbgroup.GetJoinedGroupListResp, error) {
if err := authverify.CheckAccessV3(ctx, req.FromUserID, &s.config.Manager, &s.config.IMAdmin); err != nil {
if err := authverify.CheckAccessV3(ctx, req.FromUserID, &s.config.Share.IMAdmin); err != nil {
return nil, err
}
total, members, err := s.db.PageGetJoinGroup(ctx, req.FromUserID, req.Pagination)
@ -397,7 +397,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
var groupMember *relationtb.GroupMemberModel
var opUserID string
if !authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin) {
if !authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin) {
opUserID = mcontext.GetOpUserID(ctx)
var err error
groupMember, err = s.db.TakeGroupMember(ctx, req.GroupID, opUserID)
@ -410,8 +410,8 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
}
beforeInviteUserToGroupConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeInviteUserToGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeInviteUserToGroup,
}
if err := CallbackBeforeInviteUserToGroup(ctx, beforeInviteUserToGroupConfig, req); err != nil {
@ -419,7 +419,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
}
if group.NeedVerification == constant.AllNeedVerification {
if !authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin) {
if !authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin) {
if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
var requests []*relationtb.GroupRequestModel
for _, userID := range req.InvitedUserIDs {
@ -562,7 +562,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
for i, member := range members {
memberMap[member.UserID] = members[i]
}
isAppManagerUid := authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin)
isAppManagerUid := authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin)
opMember := memberMap[opUserID]
for _, userID := range req.KickedUserIDs {
member, ok := memberMap[userID]
@ -635,8 +635,8 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
}
killGroupMemberConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeMemberJoinGroup,
}
if err := CallbackKillGroupMember(ctx, killGroupMemberConfig, req); err != nil {
@ -765,7 +765,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
if !datautil.Contain(req.HandleResult, constant.GroupResponseAgree, constant.GroupResponseRefuse) {
return nil, errs.ErrArgs.WrapMsg("HandleResult unknown")
}
if !authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin) {
if !authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin) {
groupMember, err := s.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
if err != nil {
return nil, err
@ -811,8 +811,8 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
}
beforeMemberJoinGroupConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeMemberJoinGroup,
}
if err = CallbackBeforeMemberJoinGroup(ctx, beforeMemberJoinGroupConfig, member, group.Ex); err != nil {
@ -863,8 +863,8 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
}
applyJoinGroupBeforeConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeMemberJoinGroup,
}
if err = CallbackApplyJoinGroupBefore(ctx, applyJoinGroupBeforeConfig, reqCall); err != nil {
@ -925,7 +925,7 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbgroup.QuitGroupReq)
if req.UserID == "" {
req.UserID = mcontext.GetOpUserID(ctx)
} else {
if err := authverify.CheckAccessV3(ctx, req.UserID, &s.config.Manager, &s.config.IMAdmin); err != nil {
if err := authverify.CheckAccessV3(ctx, req.UserID, &s.config.Share.IMAdmin); err != nil {
return nil, err
}
}
@ -949,8 +949,8 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbgroup.QuitGroupReq)
}
quitGroupConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeMemberJoinGroup,
}
if err := CallbackQuitGroup(ctx, quitGroupConfig, req); err != nil {
@ -970,7 +970,7 @@ func (s *groupServer) deleteMemberAndSetConversationSeq(ctx context.Context, gro
func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInfoReq) (*pbgroup.SetGroupInfoResp, error) {
var opMember *relationtb.GroupMemberModel
if !authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin) {
if !authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin) {
var err error
opMember, err = s.db.TakeGroupMember(ctx, req.GroupInfoForSet.GroupID, mcontext.GetOpUserID(ctx))
if err != nil {
@ -985,8 +985,8 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
}
beforeSetGroupInfoConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeMemberJoinGroup,
}
if err := CallbackBeforeSetGroupInfo(ctx, beforeSetGroupInfoConfig, req); err != nil {
@ -1096,7 +1096,7 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.Trans
if newOwner == nil {
return nil, errs.ErrArgs.WrapMsg("NewOwnerUser not in group " + req.NewOwnerUserID)
}
if !authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin) {
if !authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin) {
if !(mcontext.GetOpUserID(ctx) == oldOwner.UserID && oldOwner.RoleLevel == constant.GroupOwner) {
return nil, errs.ErrNoPermission.WrapMsg("no permission transfer group owner")
}
@ -1106,8 +1106,8 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.Trans
}
afterTransferGroupOwnerConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeMemberJoinGroup,
}
if err := CallbackAfterTransferGroupOwner(ctx, afterTransferGroupOwnerConfig, req); err != nil {
@ -1235,7 +1235,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGrou
if err != nil {
return nil, err
}
if !authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin) {
if !authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin) {
if owner.UserID != mcontext.GetOpUserID(ctx) {
return nil, errs.ErrNoPermission.WrapMsg("not group owner")
}
@ -1279,8 +1279,8 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGrou
}
dismissGroupConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeMemberJoinGroup,
}
if err := CallbackDismissGroup(ctx, dismissGroupConfig, reqCall); err != nil {
@ -1298,7 +1298,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbgroup.MuteGrou
if err := s.PopulateGroupMember(ctx, member); err != nil {
return nil, err
}
if !authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin) {
if !authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin) {
opMember, err := s.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
if err != nil {
return nil, err
@ -1332,7 +1332,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbgroup.Ca
if err := s.PopulateGroupMember(ctx, member); err != nil {
return nil, err
}
if !authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin) {
if !authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin) {
opMember, err := s.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
if err != nil {
return nil, err
@ -1388,7 +1388,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGr
if opUserID == "" {
return nil, errs.ErrNoPermission.WrapMsg("no op user id")
}
isAppManagerUid := authverify.IsAppManagerUid(ctx, &s.config.Manager, &s.config.IMAdmin)
isAppManagerUid := authverify.IsAppManagerUid(ctx, &s.config.Share.IMAdmin)
for i := range req.Members {
req.Members[i].FaceURL = nil
}
@ -1472,8 +1472,8 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGr
}
beforeSetGroupMemberInfoConfig := &GroupEventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
CallbackUrl: s.config.WebhooksConfig.URL,
BeforeCreateGroup: s.config.WebhooksConfig.BeforeMemberJoinGroup,
}
for i := 0; i < len(req.Members); i++ {

2
pkg/common/cmd/constant.go
View File

@ -63,6 +63,8 @@ const (
zoopkeeperEnvPrefix = "openim-zookeeper"
authEnvPrefix = "openim-auth"
conversationEnvPrefix = "openim-conversation"
friendEnvPrefix = "openim-friend"
groupEnvPrefix = "openim-group"
)
const (

14
pkg/common/cmd/friend.go
View File

@ -43,13 +43,13 @@ func NewFriendRpcCmd() *FriendRpcCmd {
var friendConfig FriendConfig
ret := &FriendRpcCmd{friendConfig: friendConfig}
ret.configMap = map[string]StructEnvPrefix{
OpenIMRPCConversationCfgFileName: {EnvPrefix: conversationEnvPrefix, ConfigStruct: &friendConfig.RpcConfig},
RedisConfigFileName: {EnvPrefix: redisEnvPrefix, ConfigStruct: &friendConfig.RedisConfig},
ZookeeperConfigFileName: {EnvPrefix: zoopkeeperEnvPrefix, ConfigStruct: &friendConfig.ZookeeperConfig},
MongodbConfigFileName: {EnvPrefix: mongodbEnvPrefix, ConfigStruct: &friendConfig.MongodbConfig},
ShareFileName: {EnvPrefix: shareEnvPrefix, ConfigStruct: &friendConfig.Share},
NotificationFileName: {EnvPrefix: notificationEnvPrefix, ConfigStruct: &friendConfig.NotificationConfig},
WebhooksConfigFileName: {EnvPrefix: webhooksEnvPrefix, ConfigStruct: &friendConfig.WebhooksConfig},
OpenIMRPCFriendCfgFileName: {EnvPrefix: friendEnvPrefix, ConfigStruct: &friendConfig.RpcConfig},
RedisConfigFileName: {EnvPrefix: redisEnvPrefix, ConfigStruct: &friendConfig.RedisConfig},
ZookeeperConfigFileName: {EnvPrefix: zoopkeeperEnvPrefix, ConfigStruct: &friendConfig.ZookeeperConfig},
MongodbConfigFileName: {EnvPrefix: mongodbEnvPrefix, ConfigStruct: &friendConfig.MongodbConfig},
ShareFileName: {EnvPrefix: shareEnvPrefix, ConfigStruct: &friendConfig.Share},
NotificationFileName: {EnvPrefix: notificationEnvPrefix, ConfigStruct: &friendConfig.NotificationConfig},
WebhooksConfigFileName: {EnvPrefix: webhooksEnvPrefix, ConfigStruct: &friendConfig.WebhooksConfig},
}
ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
ret.ctx = context.WithValue(context.Background(), "version", config.Version)

70
pkg/common/cmd/group.go Normal file
View File

@ -0,0 +1,70 @@
// 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 cmd
import (
"context"
"github.com/openimsdk/open-im-server/v3/internal/rpc/group"
"github.com/openimsdk/open-im-server/v3/pkg/common/config"
"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
"github.com/openimsdk/tools/system/program"
"github.com/spf13/cobra"
)
type GroupRpcCmd struct {
*RootCmd
ctx context.Context
configMap map[string]StructEnvPrefix
groupConfig GroupConfig
}
type GroupConfig struct {
RpcConfig config.Conversation
RedisConfig config.Redis
MongodbConfig config.Mongo
ZookeeperConfig config.ZooKeeper
NotificationConfig config.Notification
Share config.Share
WebhooksConfig config.Webhooks
}
func NewGroupRpcCmd() *GroupRpcCmd {
var groupConfig GroupConfig
ret := &GroupRpcCmd{groupConfig: groupConfig}
ret.configMap = map[string]StructEnvPrefix{
OpenIMRPCGroupCfgFileName: {EnvPrefix: groupEnvPrefix, ConfigStruct: &groupConfig.RpcConfig},
RedisConfigFileName: {EnvPrefix: redisEnvPrefix, ConfigStruct: &groupConfig.RedisConfig},
ZookeeperConfigFileName: {EnvPrefix: zoopkeeperEnvPrefix, ConfigStruct: &groupConfig.ZookeeperConfig},
MongodbConfigFileName: {EnvPrefix: mongodbEnvPrefix, ConfigStruct: &groupConfig.MongodbConfig},
ShareFileName: {EnvPrefix: shareEnvPrefix, ConfigStruct: &groupConfig.Share},
NotificationFileName: {EnvPrefix: notificationEnvPrefix, ConfigStruct: &groupConfig.NotificationConfig},
WebhooksConfigFileName: {EnvPrefix: webhooksEnvPrefix, ConfigStruct: &groupConfig.WebhooksConfig},
}
ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
ret.ctx = context.WithValue(context.Background(), "version", config.Version)
ret.Command.PreRunE = func(cmd *cobra.Command, args []string) error {
return ret.preRunE()
}
return ret
}
func (a *GroupRpcCmd) Exec() error {
return a.Execute()
}
func (a *GroupRpcCmd) preRunE() error {
return startrpc.Start(a.ctx, &a.groupConfig.ZookeeperConfig, &a.groupConfig.RpcConfig.Prometheus, a.groupConfig.RpcConfig.RPC.ListenIP,
a.groupConfig.RpcConfig.RPC.RegisterIP, a.groupConfig.RpcConfig.RPC.Ports,
a.Index(), a.groupConfig.Share.RpcRegisterName.Auth, &a.groupConfig, group.Start)
}