feat: Integrate Comprehensive E2E Testing for GoChat (#1906)

* feat: create e2e test readme

Signed-off-by: Xinwei Xiong (cubxxw) <3293172751nss@gmail.com>

* feat: fix markdown file

* feat: add openim make lint

* feat: add git chglog pull request

* feat: add git chglog pull request

* fix: fix openim api err code

* fix: fix openim api err code

* fix: fix openim api err code

* feat: Improve CICD

* feat: Combining GitHub and Google Workspace for Effective Project Management'

* feat: fix openim tools error code

* feat: fix openim tools error code

* feat: add openim error handle

* feat: add openim error handle

* feat: optimize tim white prom code return err

* feat: fix openim tools error code

* style: format openim server code style

* feat: add openim optimize commit code

* feat: add openim optimize commit code

* feat: add openim auto format code

* feat: add openim auto format code

* feat: add openim auto format code

* feat: add openim auto format code

* feat: add openim auto format code

* feat: format openim code

* feat: Some of the notes were translated

* feat: Some of the notes were translated

* feat: update openim server code

* feat: optimize openim reset code

* feat: optimize openim reset code

---------

Signed-off-by: Xinwei Xiong (cubxxw) <3293172751nss@gmail.com>

pkg/common/cmd/api.go

@@ -15,6 +15,9 @@
 package cmd
 
 import (
+	"errors"
+	"fmt"
+
 	"github.com/OpenIMSDK/protocol/constant"
 	"github.com/spf13/cobra"
 
@@ -32,17 +35,35 @@ func NewApiCmd() *ApiCmd {
 	return ret
 }
 
+// AddApi configures the API command to run with specified ports for the API and Prometheus monitoring.
+// It ensures error handling for port retrieval and only proceeds if both port numbers are successfully obtained.
 func (a *ApiCmd) AddApi(f func(port int, promPort int) error) {
 	a.Command.RunE = func(cmd *cobra.Command, args []string) error {
-		return f(a.getPortFlag(cmd), a.getPrometheusPortFlag(cmd))
+		port, err := a.getPortFlag(cmd)
+		if err != nil {
+			return err
+		}
+
+		promPort, err := a.getPrometheusPortFlag(cmd)
+		if err != nil {
+			return err
+		}
+
+		return f(port, promPort)
 	}
 }
 
-func (a *ApiCmd) GetPortFromConfig(portType string) int {
+func (a *ApiCmd) GetPortFromConfig(portType string) (int, error) {
 	if portType == constant.FlagPort {
-		return config2.Config.Api.OpenImApiPort[0]
+		if len(config2.Config.Api.OpenImApiPort) > 0 {
+			return config2.Config.Api.OpenImApiPort[0], nil
+		}
+		return 0, errors.New("API port configuration is empty or missing")
 	} else if portType == constant.FlagPrometheusPort {
-		return config2.Config.Prometheus.ApiPrometheusPort[0]
+		if len(config2.Config.Prometheus.ApiPrometheusPort) > 0 {
+			return config2.Config.Prometheus.ApiPrometheusPort[0], nil
+		}
+		return 0, errors.New("Prometheus port configuration is empty or missing")
 	}
-	return 0
+	return 0, fmt.Errorf("unknown port type: %s", portType)
 }

pkg/common/cmd/cron_task.go

@@ -36,3 +36,7 @@ func (c *CronTaskCmd) Exec(f func() error) error {
 	c.addRunE(f)
 	return c.Execute()
 }
+
+func (c *CronTaskCmd) GetPortFromConfig(portType string) (int, error) {
+	return 0, nil
+}

pkg/common/cmd/msg_gateway.go

@@ -15,13 +15,15 @@
 package cmd
 
 import (
-	"log"
+	"errors"
 
 	"github.com/spf13/cobra"
 
-	"github.com/OpenIMSDK/protocol/constant"
-
 	"github.com/openimsdk/open-im-server/v3/internal/msggateway"
+
+	"github.com/OpenIMSDK/protocol/constant"
+	"github.com/OpenIMSDK/tools/errs"
+
 	v3config "github.com/openimsdk/open-im-server/v3/pkg/common/config"
 )
 
@@ -39,20 +41,32 @@ func (m *MsgGatewayCmd) AddWsPortFlag() {
 	m.Command.Flags().IntP(constant.FlagWsPort, "w", 0, "ws server listen port")
 }
 
-func (m *MsgGatewayCmd) getWsPortFlag(cmd *cobra.Command) int {
+func (m *MsgGatewayCmd) getWsPortFlag(cmd *cobra.Command) (int, error) {
 	port, err := cmd.Flags().GetInt(constant.FlagWsPort)
 	if err != nil {
-		log.Println("Error getting ws port flag:", err)
+		return 0, errs.Wrap(err, "error getting ws port flag")
 	}
 	if port == 0 {
-		port = m.PortFromConfig(constant.FlagWsPort)
+		port, _ = m.PortFromConfig(constant.FlagWsPort)
 	}
-	return port
+	return port, nil
 }
 
 func (m *MsgGatewayCmd) addRunE() {
 	m.Command.RunE = func(cmd *cobra.Command, args []string) error {
-		return msggateway.RunWsAndServer(m.getPortFlag(cmd), m.getWsPortFlag(cmd), m.getPrometheusPortFlag(cmd))
+		wsPort, err := m.getWsPortFlag(cmd)
+		if err != nil {
+			return errs.Wrap(err, "failed to get WS port flag")
+		}
+		port, err := m.getPortFlag(cmd)
+		if err != nil {
+			return err
+		}
+		prometheusPort, err := m.getPrometheusPortFlag(cmd)
+		if err != nil {
+			return err
+		}
+		return msggateway.RunWsAndServer(port, wsPort, prometheusPort)
 	}
 }
 
@@ -61,18 +75,33 @@ func (m *MsgGatewayCmd) Exec() error {
 	return m.Execute()
 }
 
-func (m *MsgGatewayCmd) GetPortFromConfig(portType string) int {
+func (m *MsgGatewayCmd) GetPortFromConfig(portType string) (int, error) {
+	var port int
+	var exists bool
+
 	switch portType {
 	case constant.FlagWsPort:
-		return v3config.Config.LongConnSvr.OpenImWsPort[0]
+		if len(v3config.Config.LongConnSvr.OpenImWsPort) > 0 {
+			port = v3config.Config.LongConnSvr.OpenImWsPort[0]
+			exists = true
+		}
 
 	case constant.FlagPort:
-		return v3config.Config.LongConnSvr.OpenImMessageGatewayPort[0]
+		if len(v3config.Config.LongConnSvr.OpenImMessageGatewayPort) > 0 {
+			port = v3config.Config.LongConnSvr.OpenImMessageGatewayPort[0]
+			exists = true
+		}
 
 	case constant.FlagPrometheusPort:
-		return v3config.Config.Prometheus.MessageGatewayPrometheusPort[0]
-
-	default:
-		return 0
+		if len(v3config.Config.Prometheus.MessageGatewayPrometheusPort) > 0 {
+			port = v3config.Config.Prometheus.MessageGatewayPrometheusPort[0]
+			exists = true
+		}
 	}
+
+	if !exists {
+		return 0, errs.Wrap(errors.New("port type '%s' not found in configuration"), portType)
+	}
+
+	return port, nil
 }

pkg/common/cmd/msg_gateway_test.go

@@ -44,7 +44,7 @@ func TestMsgGatewayCmd_GetPortFromConfig(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.portType, func(t *testing.T) {
-			got := msgGatewayCmd.GetPortFromConfig(tt.portType)
+			got, _ := msgGatewayCmd.GetPortFromConfig(tt.portType)
 			assert.Equal(t, tt.want, got)
 		})
 	}

pkg/common/cmd/msg_transfer.go

@@ -37,7 +37,11 @@ func NewMsgTransferCmd() *MsgTransferCmd {
 
 func (m *MsgTransferCmd) addRunE() {
 	m.Command.RunE = func(cmd *cobra.Command, args []string) error {
-		return msgtransfer.StartTransfer(m.getPrometheusPortFlag(cmd))
+		prometheusPort, err := m.getPrometheusPortFlag(cmd)
+		if err != nil {
+			return err
+		}
+		return msgtransfer.StartTransfer(prometheusPort)
 	}
 }
 
@@ -46,14 +50,18 @@ func (m *MsgTransferCmd) Exec() error {
 	return m.Execute()
 }
 
-func (m *MsgTransferCmd) GetPortFromConfig(portType string) int {
+func (m *MsgTransferCmd) GetPortFromConfig(portType string) (int, error) {
 	if portType == constant.FlagPort {
-		return 0
+		return 0, nil
 	} else if portType == constant.FlagPrometheusPort {
 		n := m.getTransferProgressFlagValue()
-		return config2.Config.Prometheus.MessageTransferPrometheusPort[n]
+
+		if n < len(config2.Config.Prometheus.MessageTransferPrometheusPort) {
+			return config2.Config.Prometheus.MessageTransferPrometheusPort[n], nil
+		}
+		return 0, fmt.Errorf("index out of range for MessageTransferPrometheusPort with index %d", n)
 	}
-	return 0
+	return 0, fmt.Errorf("unknown port type: %s", portType)
 }
 
 func (m *MsgTransferCmd) AddTransferProgressFlag() {

pkg/common/cmd/msg_utils.go

@@ -18,6 +18,7 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/openimsdk/open-im-server/v3/internal/tools"
+	util "github.com/openimsdk/open-im-server/v3/pkg/util/genutil"
 )
 
 type MsgUtilsCmd struct {
@@ -137,7 +138,7 @@ func (s *SeqCmd) GetSeqCmd() *cobra.Command {
 	s.Command.Run = func(cmdLines *cobra.Command, args []string) {
 		_, err := tools.InitMsgTool()
 		if err != nil {
-			panic(err)
+			util.ExitWithError(err)
 		}
 		userID := s.getUserIDFlag(cmdLines)
 		superGroupID := s.getSuperGroupIDFlag(cmdLines)

pkg/common/cmd/root.go

@@ -19,6 +19,8 @@ import (
 
 	config2 "github.com/openimsdk/open-im-server/v3/pkg/common/config"
 
+	"github.com/OpenIMSDK/tools/errs"
+
 	"github.com/spf13/cobra"
 
 	"github.com/OpenIMSDK/protocol/constant"
@@ -28,8 +30,9 @@ import (
 )
 
 type RootCmdPt interface {
-	GetPortFromConfig(portType string) int
+	GetPortFromConfig(portType string) (int, error)
 }
+
 type RootCmd struct {
 	Command        cobra.Command
 	Name           string
@@ -77,7 +80,7 @@ func (rc *RootCmd) persistentPreRun(cmd *cobra.Command, opts ...func(*CmdOpts))
 	cmdOpts := rc.applyOptions(opts...)
 
 	if err := rc.initializeLogger(cmdOpts); err != nil {
-		return fmt.Errorf("failed to initialize from config: %w", err)
+		return errs.Wrap(err, "failed to initialize logger")
 	}
 
 	return nil
@@ -130,31 +133,41 @@ func (r *RootCmd) AddPortFlag() {
 	r.Command.Flags().IntP(constant.FlagPort, "p", 0, "server listen port")
 }
 
-func (r *RootCmd) getPortFlag(cmd *cobra.Command) int {
+func (r *RootCmd) getPortFlag(cmd *cobra.Command) (int, error) {
 	port, err := cmd.Flags().GetInt(constant.FlagPort)
 	if err != nil {
-		fmt.Println("Error getting ws port flag:", err)
+		// Wrapping the error with additional context
+		return 0, errs.Wrap(err, "error getting port flag")
 	}
 	if port == 0 {
-		port = r.PortFromConfig(constant.FlagPort)
+		port, _ = r.PortFromConfig(constant.FlagPort)
+		// port, err := r.PortFromConfig(constant.FlagPort)
+		// if err != nil {
+		//     // Optionally wrap the error if it's an internal error needing context
+		//     return 0, errs.Wrap(err, "error getting port from config")
+		// }
 	}
-	return port
+	return port, nil
 }
 
-func (r *RootCmd) GetPortFlag() int {
-	return r.port
+// // GetPortFlag returns the port flag.
+func (r *RootCmd) GetPortFlag() (int, error) {
+	return r.port, nil
 }
 
 func (r *RootCmd) AddPrometheusPortFlag() {
 	r.Command.Flags().IntP(constant.FlagPrometheusPort, "", 0, "server prometheus listen port")
 }
 
-func (r *RootCmd) getPrometheusPortFlag(cmd *cobra.Command) int {
-	port, _ := cmd.Flags().GetInt(constant.FlagPrometheusPort)
-	if port == 0 {
-		port = r.PortFromConfig(constant.FlagPrometheusPort)
+func (r *RootCmd) getPrometheusPortFlag(cmd *cobra.Command) (int, error) {
+	port, err := cmd.Flags().GetInt(constant.FlagPrometheusPort)
+	if err != nil || port == 0 {
+		port, err = r.PortFromConfig(constant.FlagPrometheusPort)
+		if err != nil {
+			return 0, err
+		}
 	}
-	return port
+	return port, nil
 }
 
 func (r *RootCmd) GetPrometheusPortFlag() int {
@@ -175,10 +188,11 @@ func (r *RootCmd) AddCommand(cmds ...*cobra.Command) {
 	r.Command.AddCommand(cmds...)
 }
 
-func (r *RootCmd) GetPortFromConfig(portType string) int {
-	return 0
-}
-
-func (r *RootCmd) PortFromConfig(portType string) int {
-	return r.cmdItf.GetPortFromConfig(portType)
+func (r *RootCmd) PortFromConfig(portType string) (int, error) {
+	// Retrieve the port and cache it
+	port, err := r.cmdItf.GetPortFromConfig(portType)
+	if err != nil {
+		return 0, err
+	}
+	return port, nil
 }

pkg/common/cmd/rpc.go

@@ -16,11 +16,14 @@ package cmd
 
 import (
 	"errors"
+	"fmt"
 
 	"github.com/OpenIMSDK/protocol/constant"
 	"github.com/spf13/cobra"
 	"google.golang.org/grpc"
 
+	"github.com/OpenIMSDK/tools/errs"
+
 	config2 "github.com/openimsdk/open-im-server/v3/pkg/common/config"
 
 	"github.com/OpenIMSDK/tools/discoveryregistry"
@@ -39,78 +42,78 @@ func NewRpcCmd(name string) *RpcCmd {
 }
 
 func (a *RpcCmd) Exec() error {
-	a.Command.Run = func(cmd *cobra.Command, args []string) {
-		a.port = a.getPortFlag(cmd)
-		a.prometheusPort = a.getPrometheusPortFlag(cmd)
+	a.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		portFlag, err := a.getPortFlag(cmd)
+		if err != nil {
+			return err
+		}
+		a.port = portFlag
+
+		prometheusPort, err := a.getPrometheusPortFlag(cmd)
+		if err != nil {
+			return err
+		}
+		a.prometheusPort = prometheusPort
+
+		return nil
 	}
 	return a.Execute()
 }
 
 func (a *RpcCmd) StartSvr(name string, rpcFn func(discov discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error) error {
-	if a.GetPortFlag() == 0 {
-		return errors.New("port is required")
+	portFlag, err := a.GetPortFlag()
+	if err != nil {
+		return err
+	} else {
+		a.port = portFlag
 	}
-	return startrpc.Start(a.GetPortFlag(), name, a.GetPrometheusPortFlag(), rpcFn)
+
+	return startrpc.Start(portFlag, name, a.GetPrometheusPortFlag(), rpcFn)
 }
 
-func (a *RpcCmd) GetPortFromConfig(portType string) int {
-	switch a.Name {
-	case RpcPushServer:
-		if portType == constant.FlagPort {
-			return config2.Config.RpcPort.OpenImPushPort[0]
-		}
-		if portType == constant.FlagPrometheusPort {
-			return config2.Config.Prometheus.PushPrometheusPort[0]
-		}
-	case RpcAuthServer:
-		if portType == constant.FlagPort {
-			return config2.Config.RpcPort.OpenImAuthPort[0]
-		}
-		if portType == constant.FlagPrometheusPort {
-			return config2.Config.Prometheus.AuthPrometheusPort[0]
-		}
-	case RpcConversationServer:
-		if portType == constant.FlagPort {
-			return config2.Config.RpcPort.OpenImConversationPort[0]
-		}
-		if portType == constant.FlagPrometheusPort {
-			return config2.Config.Prometheus.ConversationPrometheusPort[0]
-		}
-	case RpcFriendServer:
-		if portType == constant.FlagPort {
-			return config2.Config.RpcPort.OpenImFriendPort[0]
-		}
-		if portType == constant.FlagPrometheusPort {
-			return config2.Config.Prometheus.FriendPrometheusPort[0]
-		}
-	case RpcGroupServer:
-		if portType == constant.FlagPort {
-			return config2.Config.RpcPort.OpenImGroupPort[0]
-		}
-		if portType == constant.FlagPrometheusPort {
-			return config2.Config.Prometheus.GroupPrometheusPort[0]
-		}
-	case RpcMsgServer:
-		if portType == constant.FlagPort {
-			return config2.Config.RpcPort.OpenImMessagePort[0]
-		}
-		if portType == constant.FlagPrometheusPort {
-			return config2.Config.Prometheus.MessagePrometheusPort[0]
-		}
-	case RpcThirdServer:
-		if portType == constant.FlagPort {
-			return config2.Config.RpcPort.OpenImThirdPort[0]
-		}
-		if portType == constant.FlagPrometheusPort {
-			return config2.Config.Prometheus.ThirdPrometheusPort[0]
-		}
-	case RpcUserServer:
-		if portType == constant.FlagPort {
-			return config2.Config.RpcPort.OpenImUserPort[0]
-		}
-		if portType == constant.FlagPrometheusPort {
-			return config2.Config.Prometheus.UserPrometheusPort[0]
+func (a *RpcCmd) GetPortFromConfig(portType string) (int, error) {
+	portConfigMap := map[string]map[string]int{
+		RpcPushServer: {
+			constant.FlagPort:           config2.Config.RpcPort.OpenImPushPort[0],
+			constant.FlagPrometheusPort: config2.Config.Prometheus.PushPrometheusPort[0],
+		},
+		RpcAuthServer: {
+			constant.FlagPort:           config2.Config.RpcPort.OpenImAuthPort[0],
+			constant.FlagPrometheusPort: config2.Config.Prometheus.AuthPrometheusPort[0],
+		},
+		RpcConversationServer: {
+			constant.FlagPort:           config2.Config.RpcPort.OpenImConversationPort[0],
+			constant.FlagPrometheusPort: config2.Config.Prometheus.ConversationPrometheusPort[0],
+		},
+		RpcFriendServer: {
+			constant.FlagPort:           config2.Config.RpcPort.OpenImFriendPort[0],
+			constant.FlagPrometheusPort: config2.Config.Prometheus.FriendPrometheusPort[0],
+		},
+		RpcGroupServer: {
+			constant.FlagPort:           config2.Config.RpcPort.OpenImGroupPort[0],
+			constant.FlagPrometheusPort: config2.Config.Prometheus.GroupPrometheusPort[0],
+		},
+		RpcMsgServer: {
+			constant.FlagPort:           config2.Config.RpcPort.OpenImMessagePort[0],
+			constant.FlagPrometheusPort: config2.Config.Prometheus.MessagePrometheusPort[0],
+		},
+		RpcThirdServer: {
+			constant.FlagPort:           config2.Config.RpcPort.OpenImThirdPort[0],
+			constant.FlagPrometheusPort: config2.Config.Prometheus.ThirdPrometheusPort[0],
+		},
+		RpcUserServer: {
+			constant.FlagPort:           config2.Config.RpcPort.OpenImUserPort[0],
+			constant.FlagPrometheusPort: config2.Config.Prometheus.UserPrometheusPort[0],
+		},
+	}
+
+	if portMap, ok := portConfigMap[a.Name]; ok {
+		if port, ok := portMap[portType]; ok {
+			return port, nil
+		} else {
+			return 0, errs.Wrap(errors.New("port type not found"), fmt.Sprintf("Failed to get port for %s", a.Name))
 		}
 	}
-	return 0
+
+	return 0, errs.Wrap(fmt.Errorf("server name '%s' not found", a.Name), "Failed to get port configuration")
 }