cobra

cmd/api/main.go

@@ -39,7 +39,7 @@ func run(port int) error {
 	if config.Config.Api.ListenIP != "" {
 		address = config.Config.Api.ListenIP + ":" + strconv.Itoa(port)
 	}
-	fmt.Println("start api server, address: ", address, ", OpenIM version: ", constant.CurrentVersion)
+	fmt.Println("start api server, address: ", address, ", OpenIM version: ", config.Version)
 	err = router.Run(address)
 	if err != nil {
 		log.Error("", "api run failed ", address, err.Error())

cmd/crontask/main.go

@@ -9,8 +9,7 @@ import (
 
 func main() {
 	cronTaskCmd := cmd.NewCronTaskCmd()
-	cronTaskCmd.AddRunE(tools.StartCronTask)
+	if err := cronTaskCmd.Exec(tools.StartCronTask); err != nil {
-	if err := cronTaskCmd.Execute(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}

cmd/msggateway/main.go

@@ -1,31 +1,18 @@
 package main
 
 import (
-	"OpenIM/internal/msggateway"
+	"OpenIM/pkg/common/cmd"
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/constant"
-	"OpenIM/pkg/common/log"
-	"flag"
 	"fmt"
-	"sync"
+	"os"
 )
 
 func main() {
-	if err := config.InitConfig(""); err != nil {
+	msgGatewayCmd := cmd.NewMsgGatewayCmd()
-		panic(err.Error())
+	msgGatewayCmd.AddPortFlag()
+	msgGatewayCmd.AddPrometheusPortFlag()
+	msgGatewayCmd.AddWsPortFlag()
+	if err := msgGatewayCmd.Exec(); err != nil {
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
-	log.NewPrivateLog(constant.LogFileName)
-	defaultRpcPorts := config.Config.RpcPort.OpenImMessageGatewayPort
-	defaultWsPorts := config.Config.LongConnSvr.WebsocketPort
-	defaultPromePorts := config.Config.Prometheus.MessageGatewayPrometheusPort
-	rpcPort := flag.Int("rpc_port", defaultRpcPorts[0], "rpc listening port")
-	wsPort := flag.Int("ws_port", defaultWsPorts[0], "ws listening port")
-	prometheusPort := flag.Int("prometheus_port", defaultPromePorts[0], "PushrometheusPort default listen port")
-	flag.Parse()
-	var wg sync.WaitGroup
-	wg.Add(1)
-	fmt.Println("start rpc/msg_gateway server, port: ", *rpcPort, *wsPort, *prometheusPort, ", OpenIM version: ", constant.CurrentVersion, "\n")
-	msggateway.Init(*rpcPort, *wsPort)
-	msggateway.Run(*prometheusPort)
-	wg.Wait()
 }

cmd/msgtransfer/main.go

@@ -1,24 +1,16 @@
 package main
 
 import (
-	"OpenIM/internal/msgtransfer"
+	"OpenIM/pkg/common/cmd"
-	"OpenIM/pkg/common/config"
+	"fmt"
-	"OpenIM/pkg/common/constant"
+	"os"
-	"OpenIM/pkg/common/log"
-	"flag"
-	"sync"
 )
 
 func main() {
-	if err := config.InitConfig(""); err != nil {
+	msgTransferCmd := cmd.NewMsgTransferCmd()
-		panic(err.Error())
+	msgTransferCmd.AddPrometheusPortFlag()
+	if err := msgTransferCmd.Exec(); err != nil {
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
-	var wg sync.WaitGroup
-	wg.Add(1)
-	prometheusPort := flag.Int("prometheus_port", config.Config.Prometheus.MessageTransferPrometheusPort[0], "MessageTransferPrometheusPort default listen port")
-	log.NewPrivateLog(constant.LogFileName)
-	if err := msgtransfer.StartTransfer(*prometheusPort); err != nil {
-		panic(err)
-	}
-	wg.Wait()
 }

cmd/push/main.go

@@ -1,19 +1,18 @@
 package main
 
 import (
-	"OpenIM/internal/push"
+	"OpenIM/pkg/common/cmd"
-	"OpenIM/internal/startrpc"
+	"fmt"
-	"OpenIM/pkg/common/config"
+	"os"
-	"OpenIM/pkg/common/constant"
-	"OpenIM/pkg/common/log"
 )
 
 func main() {
-	if err := config.InitConfig(); err != nil {
+	pushCmd := cmd.NewPushCmd()
-		panic(err.Error())
+	pushCmd.AddPortFlag()
-	}
+	pushCmd.AddPrometheusPortFlag()
-	log.NewPrivateLog(constant.LogFileName)
+	pushCmd.AddPush()
-	if err := startrpc.Start(config.Config.RpcPort.OpenImAuthPort[0], config.Config.RpcRegisterName.OpenImAuthName, config.Config.Prometheus.AuthPrometheusPort[0], push.Start); err != nil {
+	if err := pushCmd.Execute(); err != nil {
-		panic(err.Error())
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
 }

cmd/rpc/auth/main.go

@@ -2,15 +2,18 @@ package main
 
 import (
 	"OpenIM/internal/rpc/auth"
-	"OpenIM/internal/startrpc"
+	"OpenIM/pkg/common/cmd"
 	"OpenIM/pkg/common/config"
+	"fmt"
+	"os"
 )
 
 func main() {
-	if err := config.InitConfig(""); err != nil {
+	rpcCmd := cmd.NewRpcCmd(config.Config.RpcRegisterName.OpenImAuthName)
-		panic(err.Error())
+	rpcCmd.AddPortFlag()
-	}
+	rpcCmd.AddPrometheusPortFlag()
-	if err := startrpc.Start(config.Config.RpcPort.OpenImAuthPort[0], config.Config.RpcRegisterName.OpenImAuthName, config.Config.Prometheus.AuthPrometheusPort[0], auth.Start); err != nil {
+	if err := rpcCmd.Exec(auth.Start); err != nil {
-		panic(err.Error())
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
 }

cmd/rpc/conversation/main.go

@@ -2,15 +2,18 @@ package main
 
 import (
 	"OpenIM/internal/rpc/conversation"
-	"OpenIM/internal/startrpc"
+	"OpenIM/pkg/common/cmd"
 	"OpenIM/pkg/common/config"
+	"fmt"
+	"os"
 )
 
 func main() {
-	if err := config.InitConfig(""); err != nil {
+	rpcCmd := cmd.NewRpcCmd(config.Config.RpcRegisterName.OpenImConversationName)
-		panic(err.Error())
+	rpcCmd.AddPortFlag()
-	}
+	rpcCmd.AddPrometheusPortFlag()
-	if err := startrpc.Start(config.Config.RpcPort.OpenImConversationPort[0], config.Config.RpcRegisterName.OpenImConversationName, config.Config.Prometheus.ConversationPrometheusPort[0], conversation.Start); err != nil {
+	if err := rpcCmd.Exec(conversation.Start); err != nil {
-		panic(err.Error())
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
 }

cmd/rpc/friend/main.go

@@ -2,15 +2,18 @@ package main
 
 import (
 	"OpenIM/internal/rpc/friend"
-	"OpenIM/internal/startrpc"
+	"OpenIM/pkg/common/cmd"
 	"OpenIM/pkg/common/config"
+	"fmt"
+	"os"
 )
 
 func main() {
-	if err := config.InitConfig(""); err != nil {
+	rpcCmd := cmd.NewRpcCmd(config.Config.RpcRegisterName.OpenImFriendName)
-		panic(err.Error())
+	rpcCmd.AddPortFlag()
-	}
+	rpcCmd.AddPrometheusPortFlag()
-	if err := startrpc.Start(config.Config.RpcPort.OpenImFriendPort[0], config.Config.RpcRegisterName.OpenImFriendName, config.Config.Prometheus.FriendPrometheusPort[0], friend.Start); err != nil {
+	if err := rpcCmd.Exec(friend.Start); err != nil {
-		panic(err.Error())
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
 }

cmd/rpc/group/main.go

@@ -1,16 +1,19 @@
 package main
 
 import (
-	"OpenIM/internal/rpc/group"
+	"OpenIM/internal/rpc/friend"
-	"OpenIM/internal/startrpc"
+	"OpenIM/pkg/common/cmd"
 	"OpenIM/pkg/common/config"
+	"fmt"
+	"os"
 )
 
 func main() {
-	if err := config.InitConfig(""); err != nil {
+	rpcCmd := cmd.NewRpcCmd(config.Config.RpcRegisterName.OpenImGroupName)
-		panic(err.Error())
+	rpcCmd.AddPortFlag()
-	}
+	rpcCmd.AddPrometheusPortFlag()
-	if err := startrpc.Start(config.Config.RpcPort.OpenImGroupPort[0], config.Config.RpcRegisterName.OpenImGroupName, config.Config.Prometheus.GroupPrometheusPort[0], group.Start); err != nil {
+	if err := rpcCmd.Exec(friend.Start); err != nil {
-		panic(err.Error())
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
 }

cmd/rpc/msg/main.go

@@ -2,15 +2,18 @@ package main
 
 import (
 	"OpenIM/internal/rpc/msg"
-	"OpenIM/internal/startrpc"
+	"OpenIM/pkg/common/cmd"
 	"OpenIM/pkg/common/config"
+	"fmt"
+	"os"
 )
 
 func main() {
-	if err := config.InitConfig(""); err != nil {
+	rpcCmd := cmd.NewRpcCmd(config.Config.RpcRegisterName.OpenImMsgName)
-		panic(err.Error())
+	rpcCmd.AddPortFlag()
-	}
+	rpcCmd.AddPrometheusPortFlag()
-	if err := startrpc.Start(config.Config.RpcPort.OpenImMessagePort[0], config.Config.RpcRegisterName.OpenImMsgName, config.Config.Prometheus.AuthPrometheusPort[0], msg.Start); err != nil {
+	if err := rpcCmd.Exec(msg.Start); err != nil {
-		panic(err.Error())
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
 }

cmd/rpc/third/main.go

@@ -2,15 +2,18 @@ package main
 
 import (
 	"OpenIM/internal/rpc/third"
-	"OpenIM/internal/startrpc"
+	"OpenIM/pkg/common/cmd"
 	"OpenIM/pkg/common/config"
+	"fmt"
+	"os"
 )
 
 func main() {
-	if err := config.InitConfig(""); err != nil {
+	rpcCmd := cmd.NewRpcCmd(config.Config.RpcRegisterName.OpenImThirdName)
-		panic(err.Error())
+	rpcCmd.AddPortFlag()
-	}
+	rpcCmd.AddPrometheusPortFlag()
-	if err := startrpc.Start(config.Config.RpcPort.OpenImThirdPort[0], config.Config.RpcRegisterName.OpenImThirdName, config.Config.Prometheus.ThirdPrometheusPort[0], third.Start); err != nil {
+	if err := rpcCmd.Exec(third.Start); err != nil {
-		panic(err.Error())
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
 }

cmd/rpc/user/main.go

@@ -2,15 +2,18 @@ package main
 
 import (
 	"OpenIM/internal/rpc/user"
-	"OpenIM/internal/startrpc"
+	"OpenIM/pkg/common/cmd"
 	"OpenIM/pkg/common/config"
+	"fmt"
+	"os"
 )
 
 func main() {
-	if err := config.InitConfig(""); err != nil {
+	rpcCmd := cmd.NewRpcCmd(config.Config.RpcRegisterName.OpenImUserName)
-		panic(err.Error())
+	rpcCmd.AddPortFlag()
-	}
+	rpcCmd.AddPrometheusPortFlag()
-	if err := startrpc.Start(config.Config.RpcPort.OpenImUserPort[0], config.Config.RpcRegisterName.OpenImUserName, config.Config.Prometheus.UserPrometheusPort[0], user.Start); err != nil {
+	if err := rpcCmd.Exec(user.Start); err != nil {
-		panic(err.Error())
+		fmt.Println(err.Error())
+		os.Exit(1)
 	}
 }

internal/msggateway/init.go

@@ -37,6 +37,8 @@ func Init(rpcPort, wsPort int) {
 }
 
 func Run(prometheusPort int) {
+	var wg sync.WaitGroup
+	wg.Add(3)
 	go ws.run()
 	go rpcSvr.run()
 	go func() {
@@ -45,4 +47,5 @@ func Run(prometheusPort int) {
 			panic(err)
 		}
 	}()
+	wg.Wait()
 }

internal/msgtransfer/init.go

@@ -9,6 +9,7 @@ import (
 	"OpenIM/pkg/common/db/unrelation"
 	"OpenIM/pkg/common/prome"
 	"fmt"
+	"sync"
 )
 
 type MsgTransfer struct {
@@ -64,6 +65,8 @@ func (m *MsgTransfer) initPrometheus() {
 }
 
 func (m *MsgTransfer) Start(prometheusPort int) error {
+	var wg sync.WaitGroup
+	wg.Add(4)
 	if config.Config.ChatPersistenceMysql {
 		go m.persistentCH.persistentConsumerGroup.RegisterHandleAndConsumer(m.persistentCH)
 	} else {
@@ -76,5 +79,6 @@ func (m *MsgTransfer) Start(prometheusPort int) error {
 	if err != nil {
 		return err
 	}
+	wg.Wait()
 	return nil
 }

internal/startrpc/start.go

@@ -20,7 +20,7 @@ func start(rpcPort int, rpcRegisterName string, prometheusPorts int, rpcFn func(
 	flagRpcPort := flag.Int("port", rpcPort, "get RpcGroupPort from cmd,default 16000 as port")
 	flagPrometheusPort := flag.Int("prometheus_port", prometheusPorts, "groupPrometheusPort default listen port")
 	flag.Parse()
-	fmt.Println("start group rpc server, port: ", *flagRpcPort, ", OpenIM version: ", constant.CurrentVersion)
+	fmt.Println("start group rpc server, port: ", *flagRpcPort, ", OpenIM version: ", config.Version)
 	log.NewPrivateLog(constant.LogFileName)
 	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", config.Config.ListenIP, *flagRpcPort))
 	if err != nil {

pkg/common/cmd/cron_task.go

@@ -10,8 +10,13 @@ func NewCronTaskCmd() *CronTaskCmd {
 	return &CronTaskCmd{NewRootCmd()}
 }
 
-func (c *CronTaskCmd) AddRunE(f func() error) {
+func (c *CronTaskCmd) addRunE(f func() error) {
 	c.Command.RunE = func(cmd *cobra.Command, args []string) error {
 		return f()
 	}
 }
+
+func (c *CronTaskCmd) Exec(f func() error) error {
+	c.addRunE(f)
+	return c.Execute()
+}

pkg/common/cmd/msg_gateway.go

@@ -1 +1,36 @@
 package cmd
+
+import (
+	"OpenIM/internal/msggateway"
+	"OpenIM/pkg/common/constant"
+	"github.com/spf13/cobra"
+)
+
+type MsgGatewayCmd struct {
+	*RootCmd
+}
+
+func NewMsgGatewayCmd() MsgGatewayCmd {
+	return MsgGatewayCmd{NewRootCmd()}
+}
+
+func (m *MsgGatewayCmd) AddWsPortFlag() {
+	m.Command.Flags().IntP(constant.FlagWsPort, "w", 0, "ws server listen port")
+}
+
+func (m *MsgGatewayCmd) getWsPortFlag(cmd *cobra.Command) int {
+	port, _ := cmd.Flags().GetInt(constant.FlagWsPort)
+	return port
+}
+
+func (m *MsgGatewayCmd) addRun() {
+	m.Command.Run = func(cmd *cobra.Command, args []string) {
+		msggateway.Init(m.getPortFlag(cmd), m.getWsPortFlag(cmd))
+		msggateway.Run(m.getPrometheusPortFlag(cmd))
+	}
+}
+
+func (m *MsgGatewayCmd) Exec() error {
+	m.addRun()
+	return m.Execute()
+}

pkg/common/cmd/msg_transfer.go

@@ -0,0 +1,25 @@
+package cmd
+
+import (
+	"OpenIM/internal/msgtransfer"
+	"github.com/spf13/cobra"
+)
+
+type MsgTransferCmd struct {
+	*RootCmd
+}
+
+func NewMsgTransferCmd() MsgTransferCmd {
+	return MsgTransferCmd{NewRootCmd()}
+}
+
+func (m *MsgTransferCmd) addRunE() {
+	m.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return msgtransfer.StartTransfer(m.getPrometheusPortFlag(cmd))
+	}
+}
+
+func (m *MsgTransferCmd) Exec() error {
+	m.addRunE()
+	return m.Execute()
+}

pkg/common/cmd/push.go

@@ -0,0 +1,22 @@
+package cmd
+
+import (
+	"OpenIM/internal/push"
+	"OpenIM/internal/startrpc"
+	"OpenIM/pkg/common/config"
+	"github.com/spf13/cobra"
+)
+
+type PushCmd struct {
+	*RpcCmd
+}
+
+func NewPushCmd() *PushCmd {
+	return &PushCmd{NewRpcCmd(config.Config.RpcRegisterName.OpenImPushName)}
+}
+
+func (r *RpcCmd) AddPush() {
+	r.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return startrpc.Start(r.getPortFlag(cmd), r.rpcRegisterName, r.getPrometheusPortFlag(cmd), push.Start)
+	}
+}

pkg/common/cmd/root.go

@@ -8,9 +8,6 @@ import (
 
 type RootCmd struct {
 	Command cobra.Command
-	port    int
-
-	prometheusPort int
 }
 
 func NewRootCmd() (rootCmd *RootCmd) {
@@ -20,8 +17,6 @@ func NewRootCmd() (rootCmd *RootCmd) {
 		Short: "Start the server",
 		Long:  `Start the server`,
 		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-			rootCmd.port = rootCmd.getPortFlag(cmd)
-			rootCmd.prometheusPort = rootCmd.getPrometheusPortFlag(cmd)
 			return rootCmd.getConfFromCmdAndInit(cmd)
 		},
 	}
@@ -38,7 +33,7 @@ func (r *RootCmd) AddRunE(f func(cmd RootCmd) error) {
 
 func (r *RootCmd) AddRpc(f func(port, prometheusPort int) error) {
 	r.Command.RunE = func(cmd *cobra.Command, args []string) error {
-		return f(r.port, r.prometheusPort)
+		return f(r.getPortFlag(cmd), r.getPrometheusPortFlag(cmd))
 	}
 }
 
@@ -55,23 +50,15 @@ func (r *RootCmd) getPortFlag(cmd *cobra.Command) int {
 	return port
 }
 
-func (r *RootCmd) GetPortFlag() int {
-	return r.port
-}
-
 func (r *RootCmd) AddPrometheusPortFlag() {
-	r.Command.Flags().StringP(constant.PrometheusPort, "pp", "", "server listen port")
+	r.Command.Flags().StringP(constant.FlagPrometheusPort, "pp", "", "server prometheus listen port")
 }
 
 func (r *RootCmd) getPrometheusPortFlag(cmd *cobra.Command) int {
-	port, _ := cmd.Flags().GetInt(constant.PrometheusPort)
+	port, _ := cmd.Flags().GetInt(constant.FlagPrometheusPort)
 	return port
 }
 
-func (r *RootCmd) GetPrometheusPortFlag() int {
-	return r.prometheusPort
-}
-
 func (r *RootCmd) getConfFromCmdAndInit(cmdLines *cobra.Command) error {
 	configFolderPath, _ := cmdLines.Flags().GetString(constant.FlagConf)
 	return config.InitConfig(configFolderPath)

pkg/common/cmd/rpc.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"OpenIM/internal/startrpc"
 	"OpenIM/pkg/discoveryregistry"
 	"github.com/spf13/cobra"
 	"google.golang.org/grpc"
@@ -8,14 +9,20 @@ import (
 
 type RpcCmd struct {
 	*RootCmd
+	rpcRegisterName string
 }
 
-func NewRpcCmd() *RpcCmd {
+func NewRpcCmd(rpcRegisterName string) *RpcCmd {
-	return &RpcCmd{NewRootCmd()}
+	return &RpcCmd{NewRootCmd(), rpcRegisterName}
 }
 
-func (r *RpcCmd) AddRpc(f func(port, rpcRegisterName string, prometheusPort int, rpcFn func(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error, options ...grpc.ServerOption) error) {
+func (r *RpcCmd) AddRpc(rpcFn func(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error) {
 	r.Command.RunE = func(cmd *cobra.Command, args []string) error {
-		return f(r.port, r.prometheusPort)
+		return startrpc.Start(r.getPortFlag(cmd), r.rpcRegisterName, r.getPrometheusPortFlag(cmd), rpcFn)
 	}
 }
+
+func (r *RpcCmd) Exec(rpcFn func(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error) error {
+	r.AddRpc(rpcFn)
+	return r.Execute()
+}

pkg/common/constant/constant.go

@@ -320,17 +320,15 @@ func GroupIsBanPrivateChat(status int32) bool {
 	return true
 }
 
-const BigVersion = "v2"
-
 const LogFileName = "OpenIM.log"
 
-const CurrentVersion = "v2.3.4-rc0"
-
 const LocalHost = "0.0.0.0"
 
 // flag parse
 const (
 	FlagPort   = "port"
-	PrometheusPort = "prometheus_port"
+	FlagWsPort = "ws_port"
+
+	FlagPrometheusPort = "prometheus_port"
 	FlagConf           = "config_folder_path"
 )

script/msg_gateway_start.sh

@@ -31,7 +31,7 @@ fi
 sleep 1
 cd ${msg_gateway_binary_root}
 for ((i = 0; i < ${#ws_ports[@]}; i++)); do
-  nohup ./${msg_gateway_name} -rpc_port ${rpc_ports[$i]} -ws_port ${ws_ports[$i]} -prometheus_port ${prome_ports[$i]} >>../logs/openIM.log 2>&1 &
+  nohup ./${msg_gateway_name} -port ${rpc_ports[$i]} -ws_port ${ws_ports[$i]} -prometheus_port ${prome_ports[$i]} >>../logs/openIM.log 2>&1 &
 done
 
 #Check launched service process