feat: optimize code and support running in single process mode (#3142)

* pb * fix: Modifying other fields while setting IsPrivateChat does not take effect * fix: quote message error revoke * refactoring scheduled tasks * refactoring scheduled tasks * refactoring scheduled tasks * refactoring scheduled tasks * refactoring scheduled tasks * refactoring scheduled tasks * upgrading pkg tools * fix * fix * optimize log output * feat: support GetLastMessage * feat: support GetLastMessage * feat: s3 switch * feat: s3 switch * fix: GetUsersOnline * feat: SendBusinessNotification supported configuration parameters * feat: SendBusinessNotification supported configuration parameters * feat: SendBusinessNotification supported configuration parameters * feat: seq conversion failed without exiting * monolithic * fix: DeleteDoc crash * fix: DeleteDoc crash * fix: monolithic * fix: monolithic * fix: fill send time * fix: fill send time * fix: crash caused by withdrawing messages from users who have left the group * fix: mq * fix: mq * fix: user msg timestamp * fix: mq * 1 * 1 * 1 * 1 * 1 * 1 * 1 * seq read config * seq read config * 1 * 1 * fix: the source message of the reference is withdrawn, and the referenced message is deleted * 1 * 1 * 1 * 1 * 1 * 1 * 1 * 1 * 1 * 1 * 1 * 1 * 1 * 1
2026-05-04 00:55:59 +08:00 · 2025-02-14 16:18:27 +08:00
parent 4b3a2b7483
commit f322ddca77
100 changed files with 3044 additions and 1857 deletions
@@ -30,16 +30,14 @@ type ConfigManager struct {
 	client        *clientv3.Client

 	configPath string
-	runtimeEnv string
 }

-func NewConfigManager(IMAdminUserID []string, cfg *config.AllConfig, client *clientv3.Client, configPath string, runtimeEnv string) *ConfigManager {
+func NewConfigManager(IMAdminUserID []string, cfg *config.AllConfig, client *clientv3.Client, configPath string) *ConfigManager {
 	cm := &ConfigManager{
 		imAdminUserID: IMAdminUserID,
 		config:        cfg,
 		client:        client,
 		configPath:    configPath,
-		runtimeEnv:    runtimeEnv,
 	}
 	return cm
 }
@@ -209,13 +207,7 @@ func (cm *ConfigManager) resetConfig(c *gin.Context, checkChange bool, ops ...cl

 	changedKeys := make([]string, 0, len(configMap))
 	for k, v := range configMap {
-		err := config.Load(
-			cm.configPath,
-			k,
-			config.EnvPrefixMap[k],
-			cm.runtimeEnv,
-			v.new,
-		)
+		err := config.Load(cm.configPath, k, config.EnvPrefixMap[k], v.new)
 		if err != nil {
 			log.ZError(c, "load config failed", err)
 			continue
@@ -20,128 +20,61 @@ import (
 	"fmt"
 	"net"
 	"net/http"
-	"os"
-	"os/signal"
 	"strconv"
-	"syscall"
 	"time"

 	conf "github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	kdisc "github.com/openimsdk/open-im-server/v3/pkg/common/discovery"
-	disetcd "github.com/openimsdk/open-im-server/v3/pkg/common/discovery/etcd"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
-	"github.com/openimsdk/tools/discovery/etcd"
-	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/mw"
-	"github.com/openimsdk/tools/system/program"
 	"github.com/openimsdk/tools/utils/datautil"
-	"github.com/openimsdk/tools/utils/jsonutil"
 	"github.com/openimsdk/tools/utils/network"
 	"github.com/openimsdk/tools/utils/runtimeenv"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
 )

 type Config struct {
-	*conf.AllConfig
+	conf.AllConfig

-	RuntimeEnv string
-	ConfigPath string
+	ConfigPath conf.Path
+	Index      conf.Index
 }

-func Start(ctx context.Context, index int, config *Config) error {
-	apiPort, err := datautil.GetElemByIndex(config.API.Api.Ports, index)
+func Start(ctx context.Context, config *Config, client discovery.Conn, service grpc.ServiceRegistrar) error {
+	apiPort, err := datautil.GetElemByIndex(config.API.Api.Ports, int(config.Index))
 	if err != nil {
 		return err
 	}

-	config.RuntimeEnv = runtimeenv.RuntimeEnvironment()
-
-	client, err := kdisc.NewDiscoveryRegister(&config.Discovery, config.RuntimeEnv, []string{
-		config.Discovery.RpcService.MessageGateway,
-	})
-	if err != nil {
-		return errs.WrapMsg(err, "failed to register discovery service")
-	}
-	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")))
-
-	var (
-		netDone        = make(chan struct{}, 1)
-		netErr         error
-		prometheusPort int
-	)
-
-	registerIP, err := network.GetRpcRegisterIP("")
-	if err != nil {
-		return err
-	}
-
-	getAutoPort := func() (net.Listener, int, error) {
-		registerAddr := net.JoinHostPort(registerIP, "0")
-		listener, err := net.Listen("tcp", registerAddr)
-		if err != nil {
-			return nil, 0, errs.WrapMsg(err, "listen err", "registerAddr", registerAddr)
-		}
-		_, portStr, _ := net.SplitHostPort(listener.Addr().String())
-		port, _ := strconv.Atoi(portStr)
-		return listener, port, nil
-	}
-
-	if config.API.Prometheus.AutoSetPorts && config.Discovery.Enable != conf.ETCD {
-		return errs.New("only etcd support autoSetPorts", "RegisterName", "api").Wrap()
-	}
-
 	router, err := newGinRouter(ctx, client, config)
 	if err != nil {
 		return err
 	}
-	if config.API.Prometheus.Enable {
-		var (
-			listener net.Listener
-		)

-		if config.API.Prometheus.AutoSetPorts {
-			listener, prometheusPort, err = getAutoPort()
-			if err != nil {
-				return err
-			}
-
-			etcdClient := client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
-
-			_, err = etcdClient.Put(ctx, prommetrics.BuildDiscoveryKey(prommetrics.APIKeyName), jsonutil.StructToJsonString(prommetrics.BuildDefaultTarget(registerIP, prometheusPort)))
-			if err != nil {
-				return errs.WrapMsg(err, "etcd put err")
-			}
-		} else {
-			prometheusPort, err = datautil.GetElemByIndex(config.API.Prometheus.Ports, index)
-			if err != nil {
-				return err
-			}
-			listener, err = net.Listen("tcp", fmt.Sprintf(":%d", prometheusPort))
-			if err != nil {
-				return errs.WrapMsg(err, "listen err", "addr", fmt.Sprintf(":%d", prometheusPort))
-			}
+	apiCtx, apiCancel := context.WithCancelCause(context.Background())
+	done := make(chan struct{})
+	go func() {
+		httpServer := &http.Server{
+			Handler: router,
+			Addr:    net.JoinHostPort(network.GetListenIP(config.API.Api.ListenIP), strconv.Itoa(apiPort)),
 		}
-
 		go func() {
-			if err := prommetrics.ApiInit(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
-				netErr = errs.WrapMsg(err, fmt.Sprintf("api prometheus start err: %d", prometheusPort))
-				netDone <- struct{}{}
+			defer close(done)
+			select {
+			case <-ctx.Done():
+				apiCancel(fmt.Errorf("recv ctx %w", context.Cause(ctx)))
+			case <-apiCtx.Done():
+			}
+			log.ZDebug(ctx, "api server is shutting down")
+			if err := httpServer.Shutdown(context.Background()); err != nil {
+				log.ZWarn(ctx, "api server shutdown err", err)
 			}
 		}()
-
-	}
-	address := net.JoinHostPort(network.GetListenIP(config.API.Api.ListenIP), strconv.Itoa(apiPort))
-
-	server := http.Server{Addr: address, Handler: router}
-	log.CInfo(ctx, "API server is initializing", "runtimeEnv", config.RuntimeEnv, "address", address, "apiPort", apiPort, "prometheusPort", prometheusPort)
-	go func() {
-		err = server.ListenAndServe()
-		if err != nil && !errors.Is(err, http.ErrServerClosed) {
-			netErr = errs.WrapMsg(err, fmt.Sprintf("api start err: %s", server.Addr))
-			netDone <- struct{}{}
+		log.CInfo(ctx, "api server is init", "runtimeEnv", runtimeenv.RuntimeEnvironment(), "address", httpServer.Addr, "apiPort", apiPort)
+		err := httpServer.ListenAndServe()
+		if err == nil {
+			err = errors.New("api done")
 		}
+		apiCancel(err)
 	}()

 	//if config.Discovery.Enable == conf.ETCD {
@@ -157,19 +90,15 @@ func Start(ctx context.Context, index int, config *Config) error {
 	//case <-ctx.Done():
 	//}
 	<-apiCtx.Done()
-	exitCause := context.Cause(apiCtx)
+	exitCause := context.Cause(ctx)
 	log.ZWarn(ctx, "api server exit", exitCause)
 	timer := time.NewTimer(time.Second * 15)
 	defer timer.Stop()
 	select {
-	case <-sigs:
-		program.SIGTERMExit()
-		if err := shutdown(); err != nil {
-			return err
-		}
-	case <-netDone:
-		close(netDone)
-		return netErr
+	case <-timer.C:
+		log.ZWarn(ctx, "api server graceful stop timeout", nil)
+	case <-done:
+		log.ZDebug(ctx, "api server graceful stop done")
 	}
-	return nil
+	return exitCause
 }
@@ -2,6 +2,7 @@ package api

 import (
 	"encoding/json"
+	"errors"
 	"net/http"

 	"github.com/gin-gonic/gin"
@@ -11,16 +12,16 @@ import (
 	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/discovery/etcd"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/log"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )

 type PrometheusDiscoveryApi struct {
 	config *Config
 	client *clientv3.Client
+	kv     discovery.KeyValue
 }

-func NewPrometheusDiscoveryApi(config *Config, client discovery.SvcDiscoveryRegistry) *PrometheusDiscoveryApi {
+func NewPrometheusDiscoveryApi(config *Config, client discovery.Conn) *PrometheusDiscoveryApi {
 	api := &PrometheusDiscoveryApi{
 		config: config,
 	}
@@ -30,43 +31,26 @@ func NewPrometheusDiscoveryApi(config *Config, client discovery.SvcDiscoveryRegi
 	return api
 }

-func (p *PrometheusDiscoveryApi) Enable(c *gin.Context) {
-	if p.config.Discovery.Enable != conf.ETCD {
-		c.JSON(http.StatusOK, []struct{}{})
-		c.Abort()
-	}
-}
-
 func (p *PrometheusDiscoveryApi) discovery(c *gin.Context, key string) {
-	eResp, err := p.client.Get(c, prommetrics.BuildDiscoveryKey(key))
+	value, err := p.kv.GetKey(c, prommetrics.BuildDiscoveryKey(key))
 	if err != nil {
-		// Log and respond with an error if preparation fails.
-		apiresp.GinError(c, errs.WrapMsg(err, "etcd get err"))
+		if errors.Is(err, discovery.ErrNotSupportedKeyValue) {
+			c.JSON(http.StatusOK, []struct{}{})
+			return
+		}
+		apiresp.GinError(c, errs.WrapMsg(err, "get key value"))
 		return
 	}
-	if len(eResp.Kvs) == 0 {
-		c.JSON(http.StatusOK, []*prommetrics.Target{})
+	if len(value) == 0 {
+		c.JSON(http.StatusOK, []*prommetrics.RespTarget{})
+		return
 	}
-
-	var (
-		resp = &prommetrics.RespTarget{
-			Targets: make([]string, 0, len(eResp.Kvs)),
-		}
-	)
-
-	for i := range eResp.Kvs {
-		var target prommetrics.Target
-		err = json.Unmarshal(eResp.Kvs[i].Value, &target)
-		if err != nil {
-			log.ZError(c, "prometheus unmarshal err", errs.Wrap(err))
-		}
-		resp.Targets = append(resp.Targets, target.Target)
-		if resp.Labels == nil {
-			resp.Labels = target.Labels
-		}
+	var resp prommetrics.RespTarget
+	if err := json.Unmarshal(value, &resp); err != nil {
+		apiresp.GinError(c, errs.WrapMsg(err, "json unmarshal err"))
+		return
 	}
-
-	c.JSON(200, []*prommetrics.RespTarget{resp})
+	c.JSON(http.StatusOK, []*prommetrics.RespTarget{&resp})
 }

 func (p *PrometheusDiscoveryApi) Api(c *gin.Context) {
@@ -57,7 +57,7 @@ func prommetricsGin() gin.HandlerFunc {
 	}
 }

-func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, cfg *Config) (*gin.Engine, error) {
+func newGinRouter(ctx context.Context, client discovery.Conn, cfg *Config) (*gin.Engine, error) {
 	authConn, err := client.GetConn(ctx, cfg.Discovery.RpcService.Auth)
 	if err != nil {
 		return nil, err
@@ -291,7 +291,7 @@ func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, cf
 	}
 	{
 		pd := NewPrometheusDiscoveryApi(cfg, client)
-		proDiscoveryGroup := r.Group("/prometheus_discovery", pd.Enable)
+		proDiscoveryGroup := r.Group("/prometheus_discovery")
 		proDiscoveryGroup.GET("/api", pd.Api)
 		proDiscoveryGroup.GET("/user", pd.User)
 		proDiscoveryGroup.GET("/group", pd.Group)
@@ -309,9 +309,8 @@ func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, cf
 	if cfg.Discovery.Enable == config.ETCD {
 		etcdClient = client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
 	}
-	cm := NewConfigManager(cfg.Share.IMAdminUserID, cfg.AllConfig, etcdClient, cfg.ConfigPath, cfg.RuntimeEnv)
+	cm := NewConfigManager(cfg.Share.IMAdminUserID, &cfg.AllConfig, etcdClient, string(cfg.ConfigPath))
 	{
-
 		configGroup := r.Group("/config", cm.CheckAdmin)
 		configGroup.POST("/get_config_list", cm.GetConfigList)
 		configGroup.POST("/get_config", cm.GetConfig)
@@ -29,11 +29,11 @@ import (

 type UserApi struct {
 	Client user.UserClient
-	discov discovery.SvcDiscoveryRegistry
+	discov discovery.Conn
 	config config.RpcService
 }

-func NewUserApi(client user.UserClient, discov discovery.SvcDiscoveryRegistry, config config.RpcService) UserApi {
+func NewUserApi(client user.UserClient, discov discovery.Conn, config config.RpcService) UserApi {
 	return UserApi{Client: client, discov: discov, config: config}
 }