optimization: change the configuration file from being read globally … (#1935)

* optimization: change the configuration file from being read globally to being read independently.

* optimization: change the configuration file from being read globally to being read independently.

* optimization: change the configuration file from being read globally to being read independently.

* optimization: config file changed to dependency injection.

* fix: replace global config with dependency injection

* fix: replace global config with dependency injection

* fix: import the enough param

* fix: import the enough param

* fix: import the enough param

* fix: fix the component check of path

* fix: fix the kafka of tls is nil problem

* fix: fix the TLS.CACrt is nil error

* fix: fix the valiable shadows problem

* fix: fix the comflect

* optimization: message remove options.

* fix: fix the param pass error

* fix: find error

* fix: find error

* fix: find eror

* fix: find error

* fix: find error

* fix: del the undifined func

* fix: find error

* fix: fix the error

* fix: pass config

* fix: find error

* fix: find error

* fix: find error

* fix: find error

* fix: find error

* fix: fix the config

* fix: fix the error

* fix: fix the config pass error

* fix: fix the eror

* fix: fix the error

* fix: fix the error

* fix: fix the error

* fix: find error

* fix: fix the error

* fix: fix the config

* fix: add return err

* fix: fix the err2

* fix: err

* fix: fix the func

* fix: del the chinese comment

* fix: fix the func

* fix: fix the gateway_test logic

* fix: s3

* test

* test

* fix: not found

---------

Co-authored-by: luhaoling <2198702716@qq.com>
Co-authored-by: withchao <993506633@qq.com>

internal/api/msg.go

@@ -198,7 +198,7 @@ func (m *MessageApi) SendMessage(c *gin.Context) {
 	}
 
 	// Check if the user has the app manager role.
-	if !authverify.IsAppManagerUid(c) {
+	if !authverify.IsAppManagerUid(c, m.Config) {
 		// Respond with a permission error if the user is not an app manager.
 		apiresp.GinError(c, errs.ErrNoPermission.Wrap("only app manager can send message"))
 		return
@@ -256,7 +256,7 @@ func (m *MessageApi) SendBusinessNotification(c *gin.Context) {
 		return
 	}
 
-	if !authverify.IsAppManagerUid(c) {
+	if !authverify.IsAppManagerUid(c, m.Config) {
 		apiresp.GinError(c, errs.ErrNoPermission.Wrap("only app manager can send message"))
 		return
 	}
@@ -300,7 +300,7 @@ func (m *MessageApi) BatchSendMsg(c *gin.Context) {
 		return
 	}
 	log.ZInfo(c, "BatchSendMsg", "req", req)
-	if err := authverify.CheckAdmin(c); err != nil {
+	if err := authverify.CheckAdmin(c, m.Config); err != nil {
 		apiresp.GinError(c, errs.ErrNoPermission.Wrap("only app manager can send message"))
 		return
 	}

internal/api/route.go

@@ -17,53 +17,142 @@ package api
 import (
 	"context"
 	"fmt"
+	kdisc "github.com/openimsdk/open-im-server/v3/pkg/common/discoveryregister"
+	ginprom "github.com/openimsdk/open-im-server/v3/pkg/common/ginprometheus"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
+	util "github.com/openimsdk/open-im-server/v3/pkg/util/genutil"
+	"net"
 	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
 
 	"github.com/OpenIMSDK/protocol/constant"
 	"github.com/OpenIMSDK/tools/apiresp"
-	"github.com/OpenIMSDK/tools/discoveryregistry"
 	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/log"
-	"github.com/OpenIMSDK/tools/mw"
 	"github.com/OpenIMSDK/tools/tokenverify"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/db/controller"
+
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
 	"github.com/go-playground/validator/v10"
-	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/db/controller"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 	"github.com/redis/go-redis/v9"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
+
+	"github.com/OpenIMSDK/tools/discoveryregistry"
+	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/mw"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 )
 
-func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.UniversalClient) *gin.Engine {
-	discov.AddOption(
-		mw.GrpcClient(),
-		grpc.WithTransportCredentials(insecure.NewCredentials()),
-		grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")),
-	) // Default RPC middleware
+func Start(config *config.GlobalConfig, port int, proPort int) error {
+	log.ZDebug(context.Background(), "configAPI1111111111111111111", config, "port", port, "javafdasfs")
+	if port == 0 || proPort == 0 {
+		err := "port or proPort is empty:" + strconv.Itoa(port) + "," + strconv.Itoa(proPort)
+		return errs.Wrap(fmt.Errorf(err))
+	}
+	rdb, err := cache.NewRedis(config)
+	if err != nil {
+		return err
+	}
+
+	var client discoveryregistry.SvcDiscoveryRegistry
+
+	// Determine whether zk is passed according to whether it is a clustered deployment
+	client, err = kdisc.NewDiscoveryRegister(config)
+	if err != nil {
+		return errs.Wrap(err, "register discovery err")
+	}
+
+	if err = client.CreateRpcRootNodes(config.GetServiceNames()); err != nil {
+		return errs.Wrap(err, "create rpc root nodes error")
+	}
+
+	if err = client.RegisterConf2Registry(constant.OpenIMCommonConfigKey, config.EncodeConfig()); err != nil {
+		return errs.Wrap(err)
+	}
+	var (
+		netDone = make(chan struct{}, 1)
+		netErr  error
+	)
+	router := newGinRouter(client, rdb, config)
+	if config.Prometheus.Enable {
+		go func() {
+			p := ginprom.NewPrometheus("app", prommetrics.GetGinCusMetrics("Api"))
+			p.SetListenAddress(fmt.Sprintf(":%d", proPort))
+			if err = p.Use(router); err != nil && err != http.ErrServerClosed {
+				netErr = errs.Wrap(err, fmt.Sprintf("prometheus start err: %d", proPort))
+				netDone <- struct{}{}
+			}
+		}()
+
+	}
+
+	var address string
+	if config.Api.ListenIP != "" {
+		address = net.JoinHostPort(config.Api.ListenIP, strconv.Itoa(port))
+	} else {
+		address = net.JoinHostPort("0.0.0.0", strconv.Itoa(port))
+	}
+
+	server := http.Server{Addr: address, Handler: router}
+
+	go func() {
+		err = server.ListenAndServe()
+		if err != nil && err != http.ErrServerClosed {
+			netErr = errs.Wrap(err, fmt.Sprintf("api start err: %s", server.Addr))
+			netDone <- struct{}{}
+
+		}
+	}()
+
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGTERM)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+	select {
+	case <-sigs:
+		util.SIGTERMExit()
+		err := server.Shutdown(ctx)
+		if err != nil {
+			return errs.Wrap(err, "shutdown err")
+		}
+	case <-netDone:
+		close(netDone)
+		return netErr
+	}
+	return nil
+}
+
+func newGinRouter(disCov discoveryregistry.SvcDiscoveryRegistry, rdb redis.UniversalClient, config *config.GlobalConfig) *gin.Engine {
+	disCov.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")))
 	gin.SetMode(gin.ReleaseMode)
 	r := gin.New()
 	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
 		_ = v.RegisterValidation("required_if", RequiredIf)
 	}
-	log.ZInfo(context.Background(), "load config", "config", config.Config)
 	r.Use(gin.Recovery(), mw.CorsHandler(), mw.GinParseOperationID())
 	// init rpc client here
-	userRpc := rpcclient.NewUser(discov)
-	groupRpc := rpcclient.NewGroup(discov)
-	friendRpc := rpcclient.NewFriend(discov)
-	messageRpc := rpcclient.NewMessage(discov)
-	conversationRpc := rpcclient.NewConversation(discov)
-	authRpc := rpcclient.NewAuth(discov)
-	thirdRpc := rpcclient.NewThird(discov)
+	userRpc := rpcclient.NewUser(disCov, config)
+	groupRpc := rpcclient.NewGroup(disCov, config)
+	friendRpc := rpcclient.NewFriend(disCov, config)
+	messageRpc := rpcclient.NewMessage(disCov, config)
+	conversationRpc := rpcclient.NewConversation(disCov, config)
+	authRpc := rpcclient.NewAuth(disCov, config)
+	thirdRpc := rpcclient.NewThird(disCov, config)
 
 	u := NewUserApi(*userRpc)
 	m := NewMessageApi(messageRpc, userRpc)
-	ParseToken := GinParseToken(rdb)
+	ParseToken := GinParseToken(rdb, config)
 	userRouterGroup := r.Group("/user")
 	{
 		userRouterGroup.POST("/user_register", u.UserRegister)
@@ -157,8 +246,8 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 	// Third service
 	thirdGroup := r.Group("/third", ParseToken)
 	{
-		thirdGroup.GET("/prometheus", GetPrometheus)
 		t := NewThirdApi(*thirdRpc)
+		thirdGroup.GET("/prometheus", t.GetPrometheus)
 		thirdGroup.POST("/fcm_update_token", t.FcmUpdateToken)
 		thirdGroup.POST("/set_app_badge", t.SetAppBadge)
 
@@ -225,12 +314,12 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 	return r
 }
 
-// GinParseToken is a middleware that parses the token in the request header and verifies it.
-func GinParseToken(rdb redis.UniversalClient) gin.HandlerFunc {
+func GinParseToken(rdb redis.UniversalClient, config *config.GlobalConfig) gin.HandlerFunc {
 	dataBase := controller.NewAuthDatabase(
-		cache.NewMsgCacheModel(rdb),
-		config.Config.Secret,
-		config.Config.TokenPolicy.Expire,
+		cache.NewMsgCacheModel(rdb, config),
+		config.Secret,
+		config.TokenPolicy.Expire,
+		config,
 	)
 	return func(c *gin.Context) {
 		switch c.Request.Method {
@@ -242,7 +331,7 @@ func GinParseToken(rdb redis.UniversalClient) gin.HandlerFunc {
 				c.Abort()
 				return
 			}
-			claims, err := tokenverify.GetClaimFromToken(token, authverify.Secret())
+			claims, err := tokenverify.GetClaimFromToken(token, authverify.Secret(config.Secret))
 			if err != nil {
 				log.ZWarn(c, "jwt get token error", errs.ErrTokenUnknown.Wrap())
 				apiresp.GinError(c, errs.ErrTokenUnknown.Wrap())

internal/api/third.go

@@ -19,12 +19,12 @@ import (
 	"net/http"
 	"strconv"
 
+	"github.com/gin-gonic/gin"
+
 	"github.com/OpenIMSDK/protocol/third"
 	"github.com/OpenIMSDK/tools/a2r"
 	"github.com/OpenIMSDK/tools/errs"
 	"github.com/OpenIMSDK/tools/mcontext"
-	"github.com/gin-gonic/gin"
-	config2 "github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 )
 
@@ -126,6 +126,6 @@ func (o *ThirdApi) SearchLogs(c *gin.Context) {
 	a2r.Call(third.ThirdClient.SearchLogs, o.Client, c)
 }
 
-func GetPrometheus(c *gin.Context) {
-	c.Redirect(http.StatusFound, config2.Config.Prometheus.GrafanaUrl)
+func (o *ThirdApi) GetPrometheus(c *gin.Context) {
+	c.Redirect(http.StatusFound, o.Config.Prometheus.GrafanaUrl)
 }

internal/api/user.go

@@ -23,7 +23,7 @@ import (
 	"github.com/OpenIMSDK/tools/errs"
 	"github.com/OpenIMSDK/tools/log"
 	"github.com/gin-gonic/gin"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 )
 
@@ -70,7 +70,7 @@ func (u *UserApi) GetUsersOnlineStatus(c *gin.Context) {
 		apiresp.GinError(c, err)
 		return
 	}
-	conns, err := u.Discov.GetConns(c, config.Config.RpcRegisterName.OpenImMessageGatewayName)
+	conns, err := u.Discov.GetConns(c, u.Config.RpcRegisterName.OpenImMessageGatewayName)
 	if err != nil {
 		apiresp.GinError(c, err)
 		return
@@ -134,7 +134,7 @@ func (u *UserApi) GetUsersOnlineTokenDetail(c *gin.Context) {
 		apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap())
 		return
 	}
-	conns, err := u.Discov.GetConns(c, config.Config.RpcRegisterName.OpenImMessageGatewayName)
+	conns, err := u.Discov.GetConns(c, u.Config.RpcRegisterName.OpenImMessageGatewayName)
 	if err != nil {
 		apiresp.GinError(c, err)
 		return