复制项目

pkg/common/cmd/api.go

@@ -0,0 +1,97 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/api"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/prommetrics"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type ApiCmd struct {
+	*RootCmd
+	ctx       context.Context
+	configMap map[string]any
+	apiConfig *api.Config
+}
+
+func NewApiCmd() *ApiCmd {
+	var apiConfig api.Config
+	ret := &ApiCmd{apiConfig: &apiConfig}
+	ret.configMap = map[string]any{
+		config.DiscoveryConfigFilename:          &apiConfig.Discovery,
+		config.KafkaConfigFileName:              &apiConfig.Kafka,
+		config.LocalCacheConfigFileName:         &apiConfig.LocalCache,
+		config.LogConfigFileName:                &apiConfig.Log,
+		config.MinioConfigFileName:              &apiConfig.Minio,
+		config.MongodbConfigFileName:            &apiConfig.Mongo,
+		config.NotificationFileName:             &apiConfig.Notification,
+		config.OpenIMAPICfgFileName:             &apiConfig.API,
+		config.OpenIMCronTaskCfgFileName:        &apiConfig.CronTask,
+		config.OpenIMMsgGatewayCfgFileName:      &apiConfig.MsgGateway,
+		config.OpenIMMsgTransferCfgFileName:     &apiConfig.MsgTransfer,
+		config.OpenIMPushCfgFileName:            &apiConfig.Push,
+		config.OpenIMRPCAuthCfgFileName:         &apiConfig.Auth,
+		config.OpenIMRPCConversationCfgFileName: &apiConfig.Conversation,
+		config.OpenIMRPCFriendCfgFileName:       &apiConfig.Friend,
+		config.OpenIMRPCGroupCfgFileName:        &apiConfig.Group,
+		config.OpenIMRPCMsgCfgFileName:          &apiConfig.Msg,
+		config.OpenIMRPCThirdCfgFileName:        &apiConfig.Third,
+		config.OpenIMRPCUserCfgFileName:         &apiConfig.User,
+		config.RedisConfigFileName:              &apiConfig.Redis,
+		config.ShareFileName:                    &apiConfig.Share,
+		config.WebhooksConfigFileName:           &apiConfig.Webhooks,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		apiConfig.ConfigPath = config.Path(ret.configPath)
+		return ret.runE()
+	}
+	return ret
+}
+
+func (a *ApiCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *ApiCmd) runE() error {
+	a.apiConfig.Index = config.Index(a.Index())
+	prometheus := config.Prometheus{
+		Enable: a.apiConfig.API.Prometheus.Enable,
+		Ports:  a.apiConfig.API.Prometheus.Ports,
+	}
+	return startrpc.Start(
+		a.ctx, &a.apiConfig.Discovery,
+		nil, // circuitBreakerConfig - API doesn't use circuit breaker
+		nil, // rateLimiterConfig - API uses its own rate limiter middleware
+		&prometheus,
+		a.apiConfig.API.Api.ListenIP, "",
+		a.apiConfig.API.Prometheus.AutoSetPorts,
+		nil, int(a.apiConfig.Index),
+		prommetrics.APIKeyName,
+		&a.apiConfig.Notification,
+		a.apiConfig,
+		[]string{},
+		[]string{},
+		api.Start,
+	)
+}

pkg/common/cmd/auth.go

@@ -0,0 +1,73 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/rpc/auth"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type AuthRpcCmd struct {
+	*RootCmd
+	ctx        context.Context
+	configMap  map[string]any
+	authConfig *auth.Config
+}
+
+func NewAuthRpcCmd() *AuthRpcCmd {
+	var authConfig auth.Config
+	ret := &AuthRpcCmd{authConfig: &authConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMRPCAuthCfgFileName: &authConfig.RpcConfig,
+		config.RedisConfigFileName:      &authConfig.RedisConfig,
+		config.MongodbConfigFileName:    &authConfig.MongoConfig,
+		config.ShareFileName:            &authConfig.Share,
+		config.LocalCacheConfigFileName: &authConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:  &authConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+
+	return ret
+}
+
+func (a *AuthRpcCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *AuthRpcCmd) runE() error {
+	return startrpc.Start(a.ctx, &a.authConfig.Discovery, &a.authConfig.RpcConfig.CircuitBreaker, &a.authConfig.RpcConfig.RateLimiter, &a.authConfig.RpcConfig.Prometheus, a.authConfig.RpcConfig.RPC.ListenIP,
+		a.authConfig.RpcConfig.RPC.RegisterIP, a.authConfig.RpcConfig.RPC.AutoSetPorts, a.authConfig.RpcConfig.RPC.Ports,
+		a.Index(), a.authConfig.Discovery.RpcService.Auth, nil, a.authConfig,
+		[]string{
+			a.authConfig.RpcConfig.GetConfigFileName(),
+			a.authConfig.Share.GetConfigFileName(),
+			a.authConfig.RedisConfig.GetConfigFileName(),
+			a.authConfig.Discovery.GetConfigFileName(),
+		},
+		[]string{
+			a.authConfig.Discovery.RpcService.MessageGateway,
+		},
+		auth.Start)
+}

pkg/common/cmd/conversation.go

@@ -0,0 +1,75 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/rpc/conversation"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type ConversationRpcCmd struct {
+	*RootCmd
+	ctx                context.Context
+	configMap          map[string]any
+	conversationConfig *conversation.Config
+}
+
+func NewConversationRpcCmd() *ConversationRpcCmd {
+	var conversationConfig conversation.Config
+	ret := &ConversationRpcCmd{conversationConfig: &conversationConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMRPCConversationCfgFileName: &conversationConfig.RpcConfig,
+		config.RedisConfigFileName:              &conversationConfig.RedisConfig,
+		config.MongodbConfigFileName:            &conversationConfig.MongodbConfig,
+		config.ShareFileName:                    &conversationConfig.Share,
+		config.NotificationFileName:             &conversationConfig.NotificationConfig,
+		config.WebhooksConfigFileName:           &conversationConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName:         &conversationConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:          &conversationConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+	return ret
+}
+
+func (a *ConversationRpcCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *ConversationRpcCmd) runE() error {
+	return startrpc.Start(a.ctx, &a.conversationConfig.Discovery, &a.conversationConfig.RpcConfig.CircuitBreaker, &a.conversationConfig.RpcConfig.RateLimiter, &a.conversationConfig.RpcConfig.Prometheus, a.conversationConfig.RpcConfig.RPC.ListenIP,
+		a.conversationConfig.RpcConfig.RPC.RegisterIP, a.conversationConfig.RpcConfig.RPC.AutoSetPorts, a.conversationConfig.RpcConfig.RPC.Ports,
+		a.Index(), a.conversationConfig.Discovery.RpcService.Conversation, &a.conversationConfig.NotificationConfig, a.conversationConfig,
+		[]string{
+			a.conversationConfig.RpcConfig.GetConfigFileName(),
+			a.conversationConfig.RedisConfig.GetConfigFileName(),
+			a.conversationConfig.MongodbConfig.GetConfigFileName(),
+			a.conversationConfig.NotificationConfig.GetConfigFileName(),
+			a.conversationConfig.Share.GetConfigFileName(),
+			a.conversationConfig.LocalCacheConfig.GetConfigFileName(),
+			a.conversationConfig.WebhooksConfig.GetConfigFileName(),
+			a.conversationConfig.Discovery.GetConfigFileName(),
+		}, nil,
+		conversation.Start)
+}

pkg/common/cmd/cron_task.go

@@ -0,0 +1,75 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/tools/cron"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type CronTaskCmd struct {
+	*RootCmd
+	ctx            context.Context
+	configMap      map[string]any
+	cronTaskConfig *cron.Config
+}
+
+func NewCronTaskCmd() *CronTaskCmd {
+	var cronTaskConfig cron.Config
+	ret := &CronTaskCmd{cronTaskConfig: &cronTaskConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMCronTaskCfgFileName: &cronTaskConfig.CronTask,
+		config.ShareFileName:             &cronTaskConfig.Share,
+		config.DiscoveryConfigFilename:   &cronTaskConfig.Discovery,
+		config.MongodbConfigFileName:     &cronTaskConfig.Mongo,
+		config.RedisConfigFileName:       &cronTaskConfig.Redis,
+		config.NotificationFileName:      &cronTaskConfig.Notification,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+	return ret
+}
+
+func (a *CronTaskCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *CronTaskCmd) runE() error {
+	var prometheus config.Prometheus
+	return startrpc.Start(
+		a.ctx, &a.cronTaskConfig.Discovery,
+		nil,
+		nil,
+		&prometheus,
+		"", "",
+		true,
+		nil, 0,
+		"",
+		nil,
+		a.cronTaskConfig,
+		[]string{},
+		[]string{},
+		cron.Start,
+	)
+}

pkg/common/cmd/doc.go

@@ -0,0 +1,15 @@
+// Copyright © 2024 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 "git.imall.cloud/openim/open-im-server-deploy/pkg/common/cmd"

pkg/common/cmd/friend.go

@@ -0,0 +1,75 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/rpc/relation"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type FriendRpcCmd struct {
+	*RootCmd
+	ctx            context.Context
+	configMap      map[string]any
+	relationConfig *relation.Config
+}
+
+func NewFriendRpcCmd() *FriendRpcCmd {
+	var relationConfig relation.Config
+	ret := &FriendRpcCmd{relationConfig: &relationConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMRPCFriendCfgFileName: &relationConfig.RpcConfig,
+		config.RedisConfigFileName:        &relationConfig.RedisConfig,
+		config.MongodbConfigFileName:      &relationConfig.MongodbConfig,
+		config.ShareFileName:              &relationConfig.Share,
+		config.NotificationFileName:       &relationConfig.NotificationConfig,
+		config.WebhooksConfigFileName:     &relationConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName:   &relationConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:    &relationConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+	return ret
+}
+
+func (a *FriendRpcCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *FriendRpcCmd) runE() error {
+	return startrpc.Start(a.ctx, &a.relationConfig.Discovery, &a.relationConfig.RpcConfig.CircuitBreaker, &a.relationConfig.RpcConfig.RateLimiter, &a.relationConfig.RpcConfig.Prometheus, a.relationConfig.RpcConfig.RPC.ListenIP,
+		a.relationConfig.RpcConfig.RPC.RegisterIP, a.relationConfig.RpcConfig.RPC.AutoSetPorts, a.relationConfig.RpcConfig.RPC.Ports,
+		a.Index(), a.relationConfig.Discovery.RpcService.Friend, &a.relationConfig.NotificationConfig, a.relationConfig,
+		[]string{
+			a.relationConfig.RpcConfig.GetConfigFileName(),
+			a.relationConfig.RedisConfig.GetConfigFileName(),
+			a.relationConfig.MongodbConfig.GetConfigFileName(),
+			a.relationConfig.NotificationConfig.GetConfigFileName(),
+			a.relationConfig.Share.GetConfigFileName(),
+			a.relationConfig.WebhooksConfig.GetConfigFileName(),
+			a.relationConfig.LocalCacheConfig.GetConfigFileName(),
+			a.relationConfig.Discovery.GetConfigFileName(),
+		}, nil,
+		relation.Start)
+}

pkg/common/cmd/group.go

@@ -0,0 +1,76 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/rpc/group"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/versionctx"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type GroupRpcCmd struct {
+	*RootCmd
+	ctx         context.Context
+	configMap   map[string]any
+	groupConfig *group.Config
+}
+
+func NewGroupRpcCmd() *GroupRpcCmd {
+	var groupConfig group.Config
+	ret := &GroupRpcCmd{groupConfig: &groupConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMRPCGroupCfgFileName: &groupConfig.RpcConfig,
+		config.RedisConfigFileName:       &groupConfig.RedisConfig,
+		config.MongodbConfigFileName:     &groupConfig.MongodbConfig,
+		config.ShareFileName:             &groupConfig.Share,
+		config.NotificationFileName:      &groupConfig.NotificationConfig,
+		config.WebhooksConfigFileName:    &groupConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName:  &groupConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:   &groupConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+	return ret
+}
+
+func (a *GroupRpcCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *GroupRpcCmd) runE() error {
+	return startrpc.Start(a.ctx, &a.groupConfig.Discovery, &a.groupConfig.RpcConfig.CircuitBreaker, &a.groupConfig.RpcConfig.RateLimiter, &a.groupConfig.RpcConfig.Prometheus, a.groupConfig.RpcConfig.RPC.ListenIP,
+		a.groupConfig.RpcConfig.RPC.RegisterIP, a.groupConfig.RpcConfig.RPC.AutoSetPorts, a.groupConfig.RpcConfig.RPC.Ports,
+		a.Index(), a.groupConfig.Discovery.RpcService.Group, &a.groupConfig.NotificationConfig, a.groupConfig,
+		[]string{
+			a.groupConfig.RpcConfig.GetConfigFileName(),
+			a.groupConfig.RedisConfig.GetConfigFileName(),
+			a.groupConfig.MongodbConfig.GetConfigFileName(),
+			a.groupConfig.NotificationConfig.GetConfigFileName(),
+			a.groupConfig.Share.GetConfigFileName(),
+			a.groupConfig.WebhooksConfig.GetConfigFileName(),
+			a.groupConfig.LocalCacheConfig.GetConfigFileName(),
+			a.groupConfig.Discovery.GetConfigFileName(),
+		}, nil,
+		group.Start, versionctx.EnableVersionCtx())
+}

pkg/common/cmd/msg.go

@@ -0,0 +1,77 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/rpc/msg"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type MsgRpcCmd struct {
+	*RootCmd
+	ctx       context.Context
+	configMap map[string]any
+	msgConfig *msg.Config
+}
+
+func NewMsgRpcCmd() *MsgRpcCmd {
+	var msgConfig msg.Config
+	ret := &MsgRpcCmd{msgConfig: &msgConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMRPCMsgCfgFileName:  &msgConfig.RpcConfig,
+		config.RedisConfigFileName:      &msgConfig.RedisConfig,
+		config.MongodbConfigFileName:    &msgConfig.MongodbConfig,
+		config.KafkaConfigFileName:      &msgConfig.KafkaConfig,
+		config.ShareFileName:            &msgConfig.Share,
+		config.NotificationFileName:     &msgConfig.NotificationConfig,
+		config.WebhooksConfigFileName:   &msgConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName: &msgConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:  &msgConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+	return ret
+}
+
+func (a *MsgRpcCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *MsgRpcCmd) runE() error {
+	return startrpc.Start(a.ctx, &a.msgConfig.Discovery, &a.msgConfig.RpcConfig.CircuitBreaker, &a.msgConfig.RpcConfig.RateLimiter, &a.msgConfig.RpcConfig.Prometheus, a.msgConfig.RpcConfig.RPC.ListenIP,
+		a.msgConfig.RpcConfig.RPC.RegisterIP, a.msgConfig.RpcConfig.RPC.AutoSetPorts, a.msgConfig.RpcConfig.RPC.Ports,
+		a.Index(), a.msgConfig.Discovery.RpcService.Msg, &a.msgConfig.NotificationConfig, a.msgConfig,
+		[]string{
+			a.msgConfig.RpcConfig.GetConfigFileName(),
+			a.msgConfig.RedisConfig.GetConfigFileName(),
+			a.msgConfig.MongodbConfig.GetConfigFileName(),
+			a.msgConfig.KafkaConfig.GetConfigFileName(),
+			a.msgConfig.NotificationConfig.GetConfigFileName(),
+			a.msgConfig.Share.GetConfigFileName(),
+			a.msgConfig.WebhooksConfig.GetConfigFileName(),
+			a.msgConfig.LocalCacheConfig.GetConfigFileName(),
+			a.msgConfig.Discovery.GetConfigFileName(),
+		}, nil,
+		msg.Start)
+}

pkg/common/cmd/msg_gateway.go

@@ -0,0 +1,105 @@
+// 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"
+	"encoding/json"
+	"fmt"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/msggateway"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+
+	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type MsgGatewayCmd struct {
+	*RootCmd
+	ctx              context.Context
+	configMap        map[string]any
+	msgGatewayConfig *msggateway.Config
+}
+
+func NewMsgGatewayCmd() *MsgGatewayCmd {
+	var msgGatewayConfig msggateway.Config
+	ret := &MsgGatewayCmd{msgGatewayConfig: &msgGatewayConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMMsgGatewayCfgFileName: &msgGatewayConfig.MsgGateway,
+		config.ShareFileName:               &msgGatewayConfig.Share,
+		config.RedisConfigFileName:         &msgGatewayConfig.RedisConfig,
+		config.WebhooksConfigFileName:      &msgGatewayConfig.WebhooksConfig,
+		config.DiscoveryConfigFilename:     &msgGatewayConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+	return ret
+}
+
+func (m *MsgGatewayCmd) Exec() error {
+	return m.Execute()
+}
+
+func (m *MsgGatewayCmd) runE() error {
+	m.msgGatewayConfig.Index = config.Index(m.Index())
+	rpc := m.msgGatewayConfig.MsgGateway.RPC
+	// 从配置读取 Prometheus，避免空配置导致的下标越界
+	prometheus := m.msgGatewayConfig.MsgGateway.Prometheus
+
+	b, err := json.Marshal(prometheus)
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(b))
+	log.CInfo(m.ctx, "prometheus", "prometheus", string(b))
+	// 调试日志：打印关键启动参数
+	log.CInfo(m.ctx, "msg-gateway starting",
+		"autoSetPorts", rpc.AutoSetPorts,
+		"rpcPorts", rpc.Ports,
+		"prometheusEnable", prometheus.Enable,
+		"prometheusPorts", prometheus.Ports,
+		"index", int(m.msgGatewayConfig.Index),
+		"listenIP", rpc.ListenIP,
+		"registerIP", rpc.RegisterIP,
+	)
+
+	if !rpc.AutoSetPorts && (len(rpc.Ports) == 0) {
+		log.ZWarn(m.ctx, "rpc ports is empty while autoSetPorts=false", nil)
+	}
+	if prometheus.Enable && len(prometheus.Ports) == 0 {
+		log.ZWarn(m.ctx, "prometheus enabled but ports is empty", nil)
+	}
+	return startrpc.Start(
+		m.ctx, &m.msgGatewayConfig.Discovery,
+		&m.msgGatewayConfig.MsgGateway.CircuitBreaker,
+		&m.msgGatewayConfig.MsgGateway.RateLimiter,
+		&prometheus,
+		rpc.ListenIP, rpc.RegisterIP,
+		rpc.AutoSetPorts,
+		rpc.Ports, int(m.msgGatewayConfig.Index),
+		m.msgGatewayConfig.Discovery.RpcService.MessageGateway,
+		nil,
+		m.msgGatewayConfig,
+		[]string{},
+		[]string{},
+		msggateway.Start,
+	)
+}

pkg/common/cmd/msg_gateway_test.go

@@ -0,0 +1,69 @@
+// 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 (
+	"math"
+	"testing"
+
+	"git.imall.cloud/openim/protocol/auth"
+	"github.com/openimsdk/tools/apiresp"
+	"github.com/openimsdk/tools/utils/jsonutil"
+	"github.com/stretchr/testify/mock"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+// MockRootCmd is a mock type for the RootCmd type
+type MockRootCmd struct {
+	mock.Mock
+}
+
+func (m *MockRootCmd) Execute() error {
+	args := m.Called()
+	return args.Error(0)
+}
+
+func TestName(t *testing.T) {
+	resp := &apiresp.ApiResponse{
+		ErrCode: 1234,
+		ErrMsg:  "test",
+		ErrDlt:  "4567",
+		Data: &auth.GetUserTokenResp{
+			Token:             "1234567",
+			ExpireTimeSeconds: math.MaxInt64,
+		},
+	}
+	data, err := resp.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	t.Log(string(data))
+
+	var rReso apiresp.ApiResponse
+	rReso.Data = &auth.GetUserTokenResp{}
+
+	if err := jsonutil.JsonUnmarshal(data, &rReso); err != nil {
+		panic(err)
+	}
+
+	t.Logf("%+v\n", rReso)
+
+}
+
+func TestName1(t *testing.T) {
+	t.Log(primitive.NewObjectID().String())
+	t.Log(primitive.NewObjectID().Hex())
+
+}

pkg/common/cmd/msg_transfer.go

@@ -0,0 +1,78 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/msgtransfer"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/prommetrics"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type MsgTransferCmd struct {
+	*RootCmd
+	ctx               context.Context
+	configMap         map[string]any
+	msgTransferConfig *msgtransfer.Config
+}
+
+func NewMsgTransferCmd() *MsgTransferCmd {
+	var msgTransferConfig msgtransfer.Config
+	ret := &MsgTransferCmd{msgTransferConfig: &msgTransferConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMMsgTransferCfgFileName: &msgTransferConfig.MsgTransfer,
+		config.RedisConfigFileName:          &msgTransferConfig.RedisConfig,
+		config.MongodbConfigFileName:        &msgTransferConfig.MongodbConfig,
+		config.KafkaConfigFileName:          &msgTransferConfig.KafkaConfig,
+		config.ShareFileName:                &msgTransferConfig.Share,
+		config.WebhooksConfigFileName:       &msgTransferConfig.WebhooksConfig,
+		config.DiscoveryConfigFilename:      &msgTransferConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+	return ret
+}
+
+func (m *MsgTransferCmd) Exec() error {
+	return m.Execute()
+}
+
+func (m *MsgTransferCmd) runE() error {
+	m.msgTransferConfig.Index = config.Index(m.Index())
+	var prometheus config.Prometheus
+	return startrpc.Start(
+		m.ctx, &m.msgTransferConfig.Discovery,
+		&m.msgTransferConfig.MsgTransfer.CircuitBreaker,
+		&m.msgTransferConfig.MsgTransfer.RateLimiter,
+		&prometheus,
+		"", "",
+		true,
+		nil, int(m.msgTransferConfig.Index),
+		prommetrics.MessageTransferKeyName,
+		nil,
+		m.msgTransferConfig,
+		[]string{},
+		[]string{},
+		msgtransfer.Start,
+	)
+}

pkg/common/cmd/msg_utils.go

@@ -0,0 +1,171 @@
+// 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 (
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"github.com/spf13/cobra"
+)
+
+type MsgUtilsCmd struct {
+	cobra.Command
+}
+
+func (m *MsgUtilsCmd) AddUserIDFlag() {
+	m.Command.PersistentFlags().StringP("userID", "u", "", "openIM userID")
+}
+func (m *MsgUtilsCmd) AddIndexFlag() {
+	m.Command.PersistentFlags().IntP(config.FlagTransferIndex, "i", 0, "process startup sequence number")
+}
+
+func (m *MsgUtilsCmd) AddConfigDirFlag() {
+	m.Command.PersistentFlags().StringP(config.FlagConf, "c", "", "path of config directory")
+
+}
+
+func (m *MsgUtilsCmd) getUserIDFlag(cmdLines *cobra.Command) string {
+	userID, _ := cmdLines.Flags().GetString("userID")
+	return userID
+}
+
+func (m *MsgUtilsCmd) AddFixAllFlag() {
+	m.Command.PersistentFlags().BoolP("fixAll", "f", false, "openIM fix all seqs")
+}
+
+/* func (m *MsgUtilsCmd) getFixAllFlag(cmdLines *cobra.Command) bool {
+	fixAll, _ := cmdLines.Flags().GetBool("fixAll")
+	return fixAll
+} */
+
+func (m *MsgUtilsCmd) AddClearAllFlag() {
+	m.Command.PersistentFlags().BoolP("clearAll", "", false, "openIM clear all seqs")
+}
+
+/* func (m *MsgUtilsCmd) getClearAllFlag(cmdLines *cobra.Command) bool {
+	clearAll, _ := cmdLines.Flags().GetBool("clearAll")
+	return clearAll
+} */
+
+func (m *MsgUtilsCmd) AddSuperGroupIDFlag() {
+	m.Command.PersistentFlags().StringP("superGroupID", "g", "", "openIM superGroupID")
+}
+
+func (m *MsgUtilsCmd) getSuperGroupIDFlag(cmdLines *cobra.Command) string {
+	superGroupID, _ := cmdLines.Flags().GetString("superGroupID")
+	return superGroupID
+}
+
+func (m *MsgUtilsCmd) AddBeginSeqFlag() {
+	m.Command.PersistentFlags().Int64P("beginSeq", "b", 0, "openIM beginSeq")
+}
+
+/* func (m *MsgUtilsCmd) getBeginSeqFlag(cmdLines *cobra.Command) int64 {
+	beginSeq, _ := cmdLines.Flags().GetInt64("beginSeq")
+	return beginSeq
+} */
+
+func (m *MsgUtilsCmd) AddLimitFlag() {
+	m.Command.PersistentFlags().Int64P("limit", "l", 0, "openIM limit")
+}
+
+/* func (m *MsgUtilsCmd) getLimitFlag(cmdLines *cobra.Command) int64 {
+	limit, _ := cmdLines.Flags().GetInt64("limit")
+	return limit
+} */
+
+func (m *MsgUtilsCmd) Execute() error {
+	return m.Command.Execute()
+}
+
+func NewMsgUtilsCmd(use, short string, args cobra.PositionalArgs) *MsgUtilsCmd {
+	return &MsgUtilsCmd{
+		Command: cobra.Command{
+			Use:   use,
+			Short: short,
+			Args:  args,
+		},
+	}
+}
+
+type GetCmd struct {
+	*MsgUtilsCmd
+}
+
+func NewGetCmd() *GetCmd {
+	return &GetCmd{
+		NewMsgUtilsCmd("get [resource]", "get action", cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs)),
+	}
+}
+
+type FixCmd struct {
+	*MsgUtilsCmd
+}
+
+func NewFixCmd() *FixCmd {
+	return &FixCmd{
+		NewMsgUtilsCmd("fix [resource]", "fix action", cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs)),
+	}
+}
+
+type ClearCmd struct {
+	*MsgUtilsCmd
+}
+
+func NewClearCmd() *ClearCmd {
+	return &ClearCmd{
+		NewMsgUtilsCmd("clear [resource]", "clear action", cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs)),
+	}
+}
+
+type SeqCmd struct {
+	*MsgUtilsCmd
+}
+
+func NewSeqCmd() *SeqCmd {
+	seqCmd := &SeqCmd{
+		NewMsgUtilsCmd("seq", "seq", nil),
+	}
+	return seqCmd
+}
+
+func (s *SeqCmd) GetSeqCmd() *cobra.Command {
+	s.Command.Run = func(cmdLines *cobra.Command, args []string) {
+
+	}
+	return &s.Command
+}
+
+func (s *SeqCmd) FixSeqCmd() *cobra.Command {
+	return &s.Command
+}
+
+type MsgCmd struct {
+	*MsgUtilsCmd
+}
+
+func NewMsgCmd() *MsgCmd {
+	msgCmd := &MsgCmd{
+		NewMsgUtilsCmd("msg", "msg", nil),
+	}
+	return msgCmd
+}
+
+func (m *MsgCmd) GetMsgCmd() *cobra.Command {
+	return &m.Command
+}
+
+func (m *MsgCmd) ClearMsgCmd() *cobra.Command {
+	return &m.Command
+}

pkg/common/cmd/push.go

@@ -0,0 +1,80 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type PushRpcCmd struct {
+	*RootCmd
+	ctx        context.Context
+	configMap  map[string]any
+	pushConfig *push.Config
+}
+
+func NewPushRpcCmd() *PushRpcCmd {
+	var pushConfig push.Config
+	ret := &PushRpcCmd{pushConfig: &pushConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMPushCfgFileName:    &pushConfig.RpcConfig,
+		config.RedisConfigFileName:      &pushConfig.RedisConfig,
+		config.MongodbConfigFileName:    &pushConfig.MongoConfig,
+		config.KafkaConfigFileName:      &pushConfig.KafkaConfig,
+		config.ShareFileName:            &pushConfig.Share,
+		config.NotificationFileName:     &pushConfig.NotificationConfig,
+		config.WebhooksConfigFileName:   &pushConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName: &pushConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:  &pushConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		ret.pushConfig.FcmConfigPath = config.Path(ret.ConfigPath())
+		return ret.runE()
+	}
+	return ret
+}
+
+func (a *PushRpcCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *PushRpcCmd) runE() error {
+	return startrpc.Start(a.ctx, &a.pushConfig.Discovery, &a.pushConfig.RpcConfig.CircuitBreaker, &a.pushConfig.RpcConfig.RateLimiter, &a.pushConfig.RpcConfig.Prometheus, a.pushConfig.RpcConfig.RPC.ListenIP,
+		a.pushConfig.RpcConfig.RPC.RegisterIP, a.pushConfig.RpcConfig.RPC.AutoSetPorts, a.pushConfig.RpcConfig.RPC.Ports,
+		a.Index(), a.pushConfig.Discovery.RpcService.Push, &a.pushConfig.NotificationConfig, a.pushConfig,
+		[]string{
+			a.pushConfig.RpcConfig.GetConfigFileName(),
+			a.pushConfig.RedisConfig.GetConfigFileName(),
+			a.pushConfig.KafkaConfig.GetConfigFileName(),
+			a.pushConfig.NotificationConfig.GetConfigFileName(),
+			a.pushConfig.Share.GetConfigFileName(),
+			a.pushConfig.WebhooksConfig.GetConfigFileName(),
+			a.pushConfig.LocalCacheConfig.GetConfigFileName(),
+			a.pushConfig.Discovery.GetConfigFileName(),
+		},
+		[]string{
+			a.pushConfig.Discovery.RpcService.MessageGateway,
+		},
+		push.Start)
+}

pkg/common/cmd/root.go

@@ -0,0 +1,251 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	kdisc "git.imall.cloud/openim/open-im-server-deploy/pkg/common/discovery"
+	disetcd "git.imall.cloud/openim/open-im-server-deploy/pkg/common/discovery/etcd"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/discovery/etcd"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
+	"github.com/spf13/cobra"
+	clientv3 "go.etcd.io/etcd/client/v3"
+)
+
+type RootCmd struct {
+	Command        cobra.Command
+	processName    string
+	port           int
+	prometheusPort int
+	log            config.Log
+	index          int
+	configPath     string
+	etcdClient     *clientv3.Client
+}
+
+func (r *RootCmd) ConfigPath() string {
+	return r.configPath
+}
+
+func (r *RootCmd) Index() int {
+	return r.index
+}
+
+func (r *RootCmd) Port() int {
+	return r.port
+}
+
+type CmdOpts struct {
+	loggerPrefixName string
+	configMap        map[string]any
+}
+
+func WithCronTaskLogName() func(*CmdOpts) {
+	return func(opts *CmdOpts) {
+		opts.loggerPrefixName = "openim-crontask"
+	}
+}
+
+func WithLogName(logName string) func(*CmdOpts) {
+	return func(opts *CmdOpts) {
+		opts.loggerPrefixName = logName
+	}
+}
+func WithConfigMap(configMap map[string]any) func(*CmdOpts) {
+	return func(opts *CmdOpts) {
+		opts.configMap = configMap
+	}
+}
+
+func NewRootCmd(processName string, opts ...func(*CmdOpts)) *RootCmd {
+	rootCmd := &RootCmd{processName: processName}
+	cmd := cobra.Command{
+		Use:  "Start openIM application",
+		Long: fmt.Sprintf(`Start %s `, processName),
+		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+			return rootCmd.persistentPreRun(cmd, opts...)
+		},
+		SilenceUsage:  true,
+		SilenceErrors: false,
+	}
+	cmd.Flags().StringP(config.FlagConf, "c", "", "path of config directory")
+	cmd.Flags().IntP(config.FlagTransferIndex, "i", 0, "process startup sequence number")
+
+	rootCmd.Command = cmd
+	return rootCmd
+}
+
+func (r *RootCmd) initEtcd() error {
+	configDirectory, _, err := r.getFlag(&r.Command)
+	if err != nil {
+		return err
+	}
+	disConfig := config.Discovery{}
+	err = config.Load(configDirectory, config.DiscoveryConfigFilename, config.EnvPrefixMap[config.DiscoveryConfigFilename], &disConfig)
+	if err != nil {
+		return err
+	}
+	if disConfig.Enable == config.ETCD {
+		discov, _ := kdisc.NewDiscoveryRegister(&disConfig, nil)
+		if etcdDiscov, ok := discov.(*etcd.SvcDiscoveryRegistryImpl); ok {
+			r.etcdClient = etcdDiscov.GetClient()
+		}
+	}
+	return nil
+}
+
+func (r *RootCmd) persistentPreRun(cmd *cobra.Command, opts ...func(*CmdOpts)) error {
+	if err := r.initEtcd(); err != nil {
+		return err
+	}
+	cmdOpts := r.applyOptions(opts...)
+	if err := r.initializeConfiguration(cmd, cmdOpts); err != nil {
+		return err
+	}
+	if err := r.updateConfigFromEtcd(cmdOpts); err != nil {
+		return err
+	}
+	if err := r.initializeLogger(cmdOpts); err != nil {
+		return errs.WrapMsg(err, "failed to initialize logger")
+	}
+	if r.etcdClient != nil {
+		if err := r.etcdClient.Close(); err != nil {
+			return errs.WrapMsg(err, "failed to close etcd client")
+		}
+	}
+	return nil
+}
+
+func (r *RootCmd) initializeConfiguration(cmd *cobra.Command, opts *CmdOpts) error {
+	configDirectory, _, err := r.getFlag(cmd)
+	if err != nil {
+		return err
+	}
+
+	// Load common configuration file
+	//opts.configMap[ShareFileName] = StructEnvPrefix{EnvPrefix: shareEnvPrefix, ConfigStruct: &r.share}
+	for configFileName, configStruct := range opts.configMap {
+		err := config.Load(configDirectory, configFileName, config.EnvPrefixMap[configFileName], configStruct)
+		if err != nil {
+			return err
+		}
+	}
+	// Load common log configuration file
+	return config.Load(configDirectory, config.LogConfigFileName, config.EnvPrefixMap[config.LogConfigFileName], &r.log)
+}
+
+func (r *RootCmd) updateConfigFromEtcd(opts *CmdOpts) error {
+	if r.etcdClient == nil {
+		return nil
+	}
+	ctx := context.TODO()
+
+	res, err := r.etcdClient.Get(ctx, disetcd.BuildKey(disetcd.EnableConfigCenterKey))
+	if err != nil {
+		log.ZWarn(ctx, "root cmd updateConfigFromEtcd, etcd Get EnableConfigCenterKey err: %v", errs.Wrap(err))
+		return nil
+	}
+	if res.Count == 0 {
+		return nil
+	} else {
+		if string(res.Kvs[0].Value) == disetcd.Disable {
+			return nil
+		} else if string(res.Kvs[0].Value) != disetcd.Enable {
+			return errs.New("unknown EnableConfigCenter value").Wrap()
+		}
+	}
+
+	update := func(configFileName string, configStruct any) error {
+		key := disetcd.BuildKey(configFileName)
+		etcdRes, err := r.etcdClient.Get(ctx, key)
+		if err != nil {
+			log.ZWarn(ctx, "root cmd updateConfigFromEtcd, etcd Get err: %v", errs.Wrap(err))
+			return nil
+		}
+		if etcdRes.Count == 0 {
+			data, err := json.Marshal(configStruct)
+			if err != nil {
+				return errs.ErrArgs.WithDetail(err.Error()).Wrap()
+			}
+			_, err = r.etcdClient.Put(ctx, disetcd.BuildKey(configFileName), string(data))
+			if err != nil {
+				log.ZWarn(ctx, "root cmd updateConfigFromEtcd, etcd Put err: %v", errs.Wrap(err))
+			}
+			return nil
+		}
+		err = json.Unmarshal(etcdRes.Kvs[0].Value, configStruct)
+		if err != nil {
+			return errs.WrapMsg(err, "failed to unmarshal config from etcd")
+		}
+		return nil
+	}
+	for configFileName, configStruct := range opts.configMap {
+		if err := update(configFileName, configStruct); err != nil {
+			return err
+		}
+	}
+	if err := update(config.LogConfigFileName, &r.log); err != nil {
+		return err
+	}
+	// Load common log configuration file
+	return nil
+
+}
+
+func (r *RootCmd) applyOptions(opts ...func(*CmdOpts)) *CmdOpts {
+	cmdOpts := defaultCmdOpts()
+	for _, opt := range opts {
+		opt(cmdOpts)
+	}
+
+	return cmdOpts
+}
+
+func (r *RootCmd) initializeLogger(cmdOpts *CmdOpts) error {
+	err := log.InitLoggerFromConfig(
+		cmdOpts.loggerPrefixName,
+		r.processName,
+		"", "",
+		r.log.RemainLogLevel,
+		r.log.IsStdout,
+		r.log.IsJson,
+		r.log.StorageLocation,
+		r.log.RemainRotationCount,
+		r.log.RotationTime,
+		version.Version,
+		r.log.IsSimplify,
+	)
+	if err != nil {
+		return errs.Wrap(err)
+	}
+	return errs.Wrap(log.InitConsoleLogger(r.processName, r.log.RemainLogLevel, r.log.IsJson, version.Version))
+
+}
+
+func defaultCmdOpts() *CmdOpts {
+	return &CmdOpts{
+		loggerPrefixName: "openim-service-log",
+	}
+}
+
+func (r *RootCmd) getFlag(cmd *cobra.Command) (string, int, error) {
+	configDirectory, err := cmd.Flags().GetString(config.FlagConf)
+	if err != nil {
+		return "", 0, errs.Wrap(err)
+	}
+	r.configPath = configDirectory
+	index, err := cmd.Flags().GetInt(config.FlagTransferIndex)
+	if err != nil {
+		return "", 0, errs.Wrap(err)
+	}
+	r.index = index
+	return configDirectory, index, nil
+}
+
+func (r *RootCmd) Execute() error {
+	return r.Command.Execute()
+}

pkg/common/cmd/third.go

@@ -0,0 +1,75 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/rpc/third"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type ThirdRpcCmd struct {
+	*RootCmd
+	ctx         context.Context
+	configMap   map[string]any
+	thirdConfig *third.Config
+}
+
+func NewThirdRpcCmd() *ThirdRpcCmd {
+	var thirdConfig third.Config
+	ret := &ThirdRpcCmd{thirdConfig: &thirdConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMRPCThirdCfgFileName: &thirdConfig.RpcConfig,
+		config.RedisConfigFileName:       &thirdConfig.RedisConfig,
+		config.MongodbConfigFileName:     &thirdConfig.MongodbConfig,
+		config.ShareFileName:             &thirdConfig.Share,
+		config.NotificationFileName:      &thirdConfig.NotificationConfig,
+		config.MinioConfigFileName:       &thirdConfig.MinioConfig,
+		config.LocalCacheConfigFileName:  &thirdConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:   &thirdConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+	return ret
+}
+
+func (a *ThirdRpcCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *ThirdRpcCmd) runE() error {
+	return startrpc.Start(a.ctx, &a.thirdConfig.Discovery, &a.thirdConfig.RpcConfig.CircuitBreaker, &a.thirdConfig.RpcConfig.RateLimiter, &a.thirdConfig.RpcConfig.Prometheus, a.thirdConfig.RpcConfig.RPC.ListenIP,
+		a.thirdConfig.RpcConfig.RPC.RegisterIP, a.thirdConfig.RpcConfig.RPC.AutoSetPorts, a.thirdConfig.RpcConfig.RPC.Ports,
+		a.Index(), a.thirdConfig.Discovery.RpcService.Third, &a.thirdConfig.NotificationConfig, a.thirdConfig,
+		[]string{
+			a.thirdConfig.RpcConfig.GetConfigFileName(),
+			a.thirdConfig.RedisConfig.GetConfigFileName(),
+			a.thirdConfig.MongodbConfig.GetConfigFileName(),
+			a.thirdConfig.NotificationConfig.GetConfigFileName(),
+			a.thirdConfig.Share.GetConfigFileName(),
+			a.thirdConfig.MinioConfig.GetConfigFileName(),
+			a.thirdConfig.LocalCacheConfig.GetConfigFileName(),
+			a.thirdConfig.Discovery.GetConfigFileName(),
+		}, nil,
+		third.Start)
+}

pkg/common/cmd/user.go

@@ -0,0 +1,77 @@
+// 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"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/rpc/user"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/startrpc"
+	"git.imall.cloud/openim/open-im-server-deploy/version"
+	"github.com/openimsdk/tools/system/program"
+	"github.com/spf13/cobra"
+)
+
+type UserRpcCmd struct {
+	*RootCmd
+	ctx        context.Context
+	configMap  map[string]any
+	userConfig *user.Config
+}
+
+func NewUserRpcCmd() *UserRpcCmd {
+	var userConfig user.Config
+	ret := &UserRpcCmd{userConfig: &userConfig}
+	ret.configMap = map[string]any{
+		config.OpenIMRPCUserCfgFileName: &userConfig.RpcConfig,
+		config.RedisConfigFileName:      &userConfig.RedisConfig,
+		config.MongodbConfigFileName:    &userConfig.MongodbConfig,
+		config.KafkaConfigFileName:      &userConfig.KafkaConfig,
+		config.ShareFileName:            &userConfig.Share,
+		config.NotificationFileName:     &userConfig.NotificationConfig,
+		config.WebhooksConfigFileName:   &userConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName: &userConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:  &userConfig.Discovery,
+	}
+	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
+	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
+	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		return ret.runE()
+	}
+	return ret
+}
+
+func (a *UserRpcCmd) Exec() error {
+	return a.Execute()
+}
+
+func (a *UserRpcCmd) runE() error {
+	return startrpc.Start(a.ctx, &a.userConfig.Discovery, &a.userConfig.RpcConfig.CircuitBreaker, &a.userConfig.RpcConfig.RateLimiter, &a.userConfig.RpcConfig.Prometheus, a.userConfig.RpcConfig.RPC.ListenIP,
+		a.userConfig.RpcConfig.RPC.RegisterIP, a.userConfig.RpcConfig.RPC.AutoSetPorts, a.userConfig.RpcConfig.RPC.Ports,
+		a.Index(), a.userConfig.Discovery.RpcService.User, &a.userConfig.NotificationConfig, a.userConfig,
+		[]string{
+			a.userConfig.RpcConfig.GetConfigFileName(),
+			a.userConfig.RedisConfig.GetConfigFileName(),
+			a.userConfig.MongodbConfig.GetConfigFileName(),
+			a.userConfig.KafkaConfig.GetConfigFileName(),
+			a.userConfig.NotificationConfig.GetConfigFileName(),
+			a.userConfig.Share.GetConfigFileName(),
+			a.userConfig.WebhooksConfig.GetConfigFileName(),
+			a.userConfig.LocalCacheConfig.GetConfigFileName(),
+			a.userConfig.Discovery.GetConfigFileName(),
+		}, nil,
+		user.Start)
+}