feat: Implement webhook in createConversation (#3228)

* update test method args.

* feat: implement createConversations webhook function.

* improve webhookCreateConversations Implement

* implement createconversation webhook.

* remove unused paramaters.

.github/workflows/merge-from-milestone.yml

@@ -113,33 +113,14 @@ jobs:
 
               echo "Cherry-picking commit: $merge_commit"
               if ! git cherry-pick "$merge_commit" --strategy=recursive -X theirs; then
-                echo "Conflict detected for $merge_commit. Resolving with incoming changes."
-                conflict_files=$(git diff --name-only --diff-filter=U)
-                echo "Conflicting files:"
-                echo "$conflict_files"
-
-                for file in $conflict_files; do
-                  if [ -f "$file" ]; then
-                    echo "Resolving conflict for $file"
-                    git add "$file"
-                  else
-                    echo "File $file has been deleted. Skipping."
-                    git rm "$file"
-                  fi
-                done
-
-                echo "Conflicts resolved. Continuing cherry-pick."
-                git cherry-pick --continue || { echo "Cherry-pick failed, but continuing to create PR."; }
-              else
-                echo "Cherry-pick successful for commit $merge_commit."
+                echo "Cherry-pick encountered conflicts, attempting to continue..."
+                git cherry-pick --continue || { echo "Cherry-pick failed"; exit 1; }
               fi
 
               git remote set-url origin "https://${BOT_TOKEN}@github.com/${{ github.repository }}.git"
               
               echo "Pushing branch: $cherry_pick_branch"
-              if ! git push origin $cherry_pick_branch --force; then
-                echo "Push failed, but continuing to create PR..."
-              fi
+              git push origin $cherry_pick_branch --force || { echo "Push failed"; exit 1; }
 
               new_pr_title="$pr_title [Created by @$pr_creator from #$pr_number]"
               new_pr_body="$pr_body

cmd/main.go

@@ -1,419 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"net"
-	"os"
-	"os/signal"
-	"path"
-	"path/filepath"
-	"reflect"
-	"runtime"
-	"strings"
-	"sync"
-	"syscall"
-	"time"
-
-	"github.com/mitchellh/mapstructure"
-	"github.com/openimsdk/open-im-server/v3/internal/api"
-	"github.com/openimsdk/open-im-server/v3/internal/msggateway"
-	"github.com/openimsdk/open-im-server/v3/internal/msgtransfer"
-	"github.com/openimsdk/open-im-server/v3/internal/push"
-	"github.com/openimsdk/open-im-server/v3/internal/rpc/auth"
-	"github.com/openimsdk/open-im-server/v3/internal/rpc/conversation"
-	"github.com/openimsdk/open-im-server/v3/internal/rpc/group"
-	"github.com/openimsdk/open-im-server/v3/internal/rpc/msg"
-	"github.com/openimsdk/open-im-server/v3/internal/rpc/relation"
-	"github.com/openimsdk/open-im-server/v3/internal/rpc/third"
-	"github.com/openimsdk/open-im-server/v3/internal/rpc/user"
-	"github.com/openimsdk/open-im-server/v3/internal/tools/cron"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
-	"github.com/openimsdk/open-im-server/v3/version"
-	"github.com/openimsdk/tools/discovery"
-	"github.com/openimsdk/tools/discovery/standalone"
-	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/system/program"
-	"github.com/openimsdk/tools/utils/datautil"
-	"github.com/openimsdk/tools/utils/network"
-	"github.com/spf13/viper"
-	"google.golang.org/grpc"
-)
-
-func init() {
-	config.SetStandalone()
-	prommetrics.RegistryAll()
-}
-
-func main() {
-	var configPath string
-	flag.StringVar(&configPath, "c", "", "config path")
-	flag.Parse()
-	if configPath == "" {
-		_, _ = fmt.Fprintln(os.Stderr, "config path is empty")
-		os.Exit(1)
-		return
-	}
-	cmd := newCmds(configPath)
-	putCmd(cmd, false, auth.Start)
-	putCmd(cmd, false, conversation.Start)
-	putCmd(cmd, false, relation.Start)
-	putCmd(cmd, false, group.Start)
-	putCmd(cmd, false, msg.Start)
-	putCmd(cmd, false, third.Start)
-	putCmd(cmd, false, user.Start)
-	putCmd(cmd, false, push.Start)
-	putCmd(cmd, true, msggateway.Start)
-	putCmd(cmd, true, msgtransfer.Start)
-	putCmd(cmd, true, api.Start)
-	putCmd(cmd, true, cron.Start)
-	ctx := context.Background()
-	if err := cmd.run(ctx); err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "server exit %s", err)
-		os.Exit(1)
-		return
-	}
-}
-
-func newCmds(confPath string) *cmds {
-	return &cmds{confPath: confPath}
-}
-
-type cmdName struct {
-	Name  string
-	Func  func(ctx context.Context) error
-	Block bool
-}
-type cmds struct {
-	confPath string
-	cmds     []cmdName
-	config   config.AllConfig
-	conf     map[string]reflect.Value
-}
-
-func (x *cmds) getTypePath(typ reflect.Type) string {
-	return path.Join(typ.PkgPath(), typ.Name())
-}
-
-func (x *cmds) initDiscovery() {
-	x.config.Discovery.Enable = "standalone"
-	vof := reflect.ValueOf(&x.config.Discovery.RpcService).Elem()
-	tof := reflect.TypeOf(&x.config.Discovery.RpcService).Elem()
-	num := tof.NumField()
-	for i := 0; i < num; i++ {
-		field := tof.Field(i)
-		if !field.IsExported() {
-			continue
-		}
-		if field.Type.Kind() != reflect.String {
-			continue
-		}
-		vof.Field(i).SetString(field.Name)
-	}
-}
-
-func (x *cmds) initAllConfig() error {
-	x.conf = make(map[string]reflect.Value)
-	vof := reflect.ValueOf(&x.config).Elem()
-	num := vof.NumField()
-	for i := 0; i < num; i++ {
-		field := vof.Field(i)
-		for ptr := true; ptr; {
-			if field.Kind() == reflect.Ptr {
-				field = field.Elem()
-			} else {
-				ptr = false
-			}
-		}
-		x.conf[x.getTypePath(field.Type())] = field
-		val := field.Addr().Interface()
-		name := val.(interface{ GetConfigFileName() string }).GetConfigFileName()
-		confData, err := os.ReadFile(filepath.Join(x.confPath, name))
-		if err != nil {
-			if os.IsNotExist(err) {
-				continue
-			}
-			return err
-		}
-		v := viper.New()
-		v.SetConfigType("yaml")
-		if err := v.ReadConfig(bytes.NewReader(confData)); err != nil {
-			return err
-		}
-		opt := func(conf *mapstructure.DecoderConfig) {
-			conf.TagName = config.StructTagName
-		}
-		if err := v.Unmarshal(val, opt); err != nil {
-			return err
-		}
-	}
-	x.initDiscovery()
-	x.config.Redis.Disable = false
-	x.config.LocalCache = config.LocalCache{}
-	config.InitNotification(&x.config.Notification)
-	return nil
-}
-
-func (x *cmds) parseConf(conf any) error {
-	vof := reflect.ValueOf(conf)
-	for {
-		if vof.Kind() == reflect.Ptr {
-			vof = vof.Elem()
-		} else {
-			break
-		}
-	}
-	tof := vof.Type()
-	numField := vof.NumField()
-	for i := 0; i < numField; i++ {
-		typeField := tof.Field(i)
-		if !typeField.IsExported() {
-			continue
-		}
-		field := vof.Field(i)
-		pkt := x.getTypePath(field.Type())
-		val, ok := x.conf[pkt]
-		if !ok {
-			switch field.Interface().(type) {
-			case config.Index:
-			case config.Path:
-				field.SetString(x.confPath)
-			case config.AllConfig:
-				field.Set(reflect.ValueOf(x.config))
-			case *config.AllConfig:
-				field.Set(reflect.ValueOf(&x.config))
-			default:
-				return fmt.Errorf("config field %s %s not found", vof.Type().Name(), typeField.Name)
-			}
-			continue
-		}
-		field.Set(val)
-	}
-	return nil
-}
-
-func (x *cmds) add(name string, block bool, fn func(ctx context.Context) error) {
-	x.cmds = append(x.cmds, cmdName{Name: name, Block: block, Func: fn})
-}
-
-func (x *cmds) initLog() error {
-	conf := x.config.Log
-	if err := log.InitLoggerFromConfig(
-		"openim-server",
-		program.GetProcessName(),
-		"", "",
-		conf.RemainLogLevel,
-		conf.IsStdout,
-		conf.IsJson,
-		conf.StorageLocation,
-		conf.RemainRotationCount,
-		conf.RotationTime,
-		strings.TrimSpace(version.Version),
-		conf.IsSimplify,
-	); err != nil {
-		return err
-	}
-	return nil
-
-}
-
-func (x *cmds) run(ctx context.Context) error {
-	if len(x.cmds) == 0 {
-		return fmt.Errorf("no command to run")
-	}
-	if err := x.initAllConfig(); err != nil {
-		return err
-	}
-	if err := x.initLog(); err != nil {
-		return err
-	}
-
-	ctx, cancel := context.WithCancelCause(ctx)
-
-	go func() {
-		<-ctx.Done()
-		log.ZError(ctx, "context server exit cause", context.Cause(ctx))
-	}()
-
-	if prometheus := x.config.API.Prometheus; prometheus.Enable {
-		var (
-			port int
-			err  error
-		)
-		if !prometheus.AutoSetPorts {
-			port, err = datautil.GetElemByIndex(prometheus.Ports, 0)
-			if err != nil {
-				return err
-			}
-		}
-		ip, err := network.GetLocalIP()
-		if err != nil {
-			return err
-		}
-		listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
-		if err != nil {
-			return fmt.Errorf("prometheus listen %d error %w", port, err)
-		}
-		defer listener.Close()
-		log.ZDebug(ctx, "prometheus start", "addr", listener.Addr())
-		target, err := json.Marshal(prommetrics.BuildDefaultTarget(ip, listener.Addr().(*net.TCPAddr).Port))
-		if err != nil {
-			return err
-		}
-		if err := standalone.GetKeyValue().SetKey(ctx, prommetrics.BuildDiscoveryKey(prommetrics.APIKeyName), target); err != nil {
-			return err
-		}
-		go func() {
-			err := prommetrics.Start(listener)
-			if err == nil {
-				err = fmt.Errorf("http done")
-			}
-			cancel(fmt.Errorf("prometheus %w", err))
-		}()
-	}
-
-	go func() {
-		sigs := make(chan os.Signal, 1)
-		signal.Notify(sigs, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
-		select {
-		case <-ctx.Done():
-			return
-		case val := <-sigs:
-			log.ZDebug(ctx, "recv signal", "signal", val.String())
-			cancel(fmt.Errorf("signal %s", val.String()))
-		}
-	}()
-
-	for i := range x.cmds {
-		cmd := x.cmds[i]
-		if cmd.Block {
-			continue
-		}
-		if err := cmd.Func(ctx); err != nil {
-			cancel(fmt.Errorf("server %s exit %w", cmd.Name, err))
-			return err
-		}
-		go func() {
-			if cmd.Block {
-				cancel(fmt.Errorf("server %s exit", cmd.Name))
-			}
-		}()
-	}
-
-	var wait cmdManger
-	for i := range x.cmds {
-		cmd := x.cmds[i]
-		if !cmd.Block {
-			continue
-		}
-		wait.Start(cmd.Name)
-		go func() {
-			defer wait.Shutdown(cmd.Name)
-			if err := cmd.Func(ctx); err != nil {
-				cancel(fmt.Errorf("server %s exit %w", cmd.Name, err))
-				return
-			}
-			cancel(fmt.Errorf("server %s exit", cmd.Name))
-		}()
-	}
-	<-ctx.Done()
-	exitCause := context.Cause(ctx)
-	log.ZWarn(ctx, "notification of service closure", exitCause)
-	done := wait.Wait()
-	timeout := time.NewTimer(time.Second * 10)
-	defer timeout.Stop()
-	for {
-		select {
-		case <-timeout.C:
-			log.ZWarn(ctx, "server exit timeout", nil, "running", wait.Running())
-			return exitCause
-		case _, ok := <-done:
-			if ok {
-				log.ZWarn(ctx, "waiting for the service to exit", nil, "running", wait.Running())
-			} else {
-				log.ZInfo(ctx, "all server exit done")
-				return exitCause
-			}
-		}
-	}
-}
-
-func putCmd[C any](cmd *cmds, block bool, fn func(ctx context.Context, config *C, client discovery.Conn, server grpc.ServiceRegistrar) error) {
-	name := path.Base(runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name())
-	if index := strings.Index(name, "."); index >= 0 {
-		name = name[:index]
-	}
-	cmd.add(name, block, func(ctx context.Context) error {
-		var conf C
-		if err := cmd.parseConf(&conf); err != nil {
-			return err
-		}
-		return fn(ctx, &conf, standalone.GetDiscoveryConn(), standalone.GetServiceRegistrar())
-	})
-}
-
-type cmdManger struct {
-	lock  sync.Mutex
-	done  chan struct{}
-	count int
-	names map[string]struct{}
-}
-
-func (x *cmdManger) Start(name string) {
-	x.lock.Lock()
-	defer x.lock.Unlock()
-	if x.names == nil {
-		x.names = make(map[string]struct{})
-	}
-	if x.done == nil {
-		x.done = make(chan struct{}, 1)
-	}
-	if _, ok := x.names[name]; ok {
-		panic(fmt.Errorf("cmd %s already exists", name))
-	}
-	x.count++
-	x.names[name] = struct{}{}
-}
-
-func (x *cmdManger) Shutdown(name string) {
-	x.lock.Lock()
-	defer x.lock.Unlock()
-	if _, ok := x.names[name]; !ok {
-		panic(fmt.Errorf("cmd %s not exists", name))
-	}
-	delete(x.names, name)
-	x.count--
-	if x.count == 0 {
-		close(x.done)
-	} else {
-		select {
-		case x.done <- struct{}{}:
-		default:
-		}
-	}
-}
-
-func (x *cmdManger) Wait() <-chan struct{} {
-	x.lock.Lock()
-	defer x.lock.Unlock()
-	if x.count == 0 || x.done == nil {
-		tmp := make(chan struct{})
-		close(tmp)
-		return tmp
-	}
-	return x.done
-}
-
-func (x *cmdManger) Running() []string {
-	x.lock.Lock()
-	defer x.lock.Unlock()
-	names := make([]string, 0, len(x.names))
-	for name := range x.names {
-		names = append(names, name)
-	}
-	return names
-}

go.mod

@@ -13,7 +13,7 @@ require (
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/openimsdk/protocol v0.0.73-alpha.6
-	github.com/openimsdk/tools v0.0.50-alpha.83
+	github.com/openimsdk/tools v0.0.50-alpha.81
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.18.0
 	github.com/stretchr/testify v1.9.0
@@ -35,7 +35,7 @@ require (
 	github.com/hashicorp/golang-lru/v2 v2.0.7
 	github.com/kelindar/bitmap v1.5.2
 	github.com/likexian/gokit v0.25.13
-	github.com/openimsdk/gomake v0.0.15-alpha.5
+	github.com/openimsdk/gomake v0.0.14-alpha.5
 	github.com/redis/go-redis/v9 v9.4.0
 	github.com/robfig/cron/v3 v3.0.1
 	github.com/shirou/gopsutil v3.21.11+incompatible
@@ -219,3 +219,5 @@ require (
 	golang.org/x/crypto v0.27.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 )
+
+//replace github.com/openimsdk/protocol => /Users/chao/Desktop/code/protocol

go.sum

@@ -349,8 +349,8 @@ github.com/openimsdk/gomake v0.0.15-alpha.5 h1:eEZCEHm+NsmcO3onXZPIUbGFCYPYbsX5b
 github.com/openimsdk/gomake v0.0.15-alpha.5/go.mod h1:PndCozNc2IsQIciyn9mvEblYWZwJmAI+06z94EY+csI=
 github.com/openimsdk/protocol v0.0.73-alpha.6 h1:sna9coWG7HN1zObBPtvG0Ki/vzqHXiB4qKbA5P3w7kc=
 github.com/openimsdk/protocol v0.0.73-alpha.6/go.mod h1:WF7EuE55vQvpyUAzDXcqg+B+446xQyEba0X35lTINmw=
-github.com/openimsdk/tools v0.0.50-alpha.83 h1:7c1D40YGqIWUmGfCII5pduETGC/8c2DyS9SQ4LvoplU=
-github.com/openimsdk/tools v0.0.50-alpha.83/go.mod h1:n2poR3asX1e1XZce4O+MOWAp+X02QJRFvhcLCXZdzRo=
+github.com/openimsdk/tools v0.0.50-alpha.81 h1:VbuJKtigNXLkCKB/Q6f2UHsqoSaTOAwS8F51c1nhOCA=
+github.com/openimsdk/tools v0.0.50-alpha.81/go.mod h1:n2poR3asX1e1XZce4O+MOWAp+X02QJRFvhcLCXZdzRo=
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=

internal/api/config_manager.go

@@ -30,14 +30,16 @@ type ConfigManager struct {
 	client        *clientv3.Client
 
 	configPath string
+	runtimeEnv string
 }
 
-func NewConfigManager(IMAdminUserID []string, cfg *config.AllConfig, client *clientv3.Client, configPath string) *ConfigManager {
+func NewConfigManager(IMAdminUserID []string, cfg *config.AllConfig, client *clientv3.Client, configPath string, runtimeEnv string) *ConfigManager {
 	cm := &ConfigManager{
 		imAdminUserID: IMAdminUserID,
 		config:        cfg,
 		client:        client,
 		configPath:    configPath,
+		runtimeEnv:    runtimeEnv,
 	}
 	return cm
 }
@@ -207,7 +209,13 @@ 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], v.new)
+		err := config.Load(
+			cm.configPath,
+			k,
+			config.EnvPrefixMap[k],
+			cm.runtimeEnv,
+			v.new,
+		)
 		if err != nil {
 			log.ZError(c, "load config failed", err)
 			continue

internal/api/init.go

@@ -20,61 +20,128 @@ import (
 	"fmt"
 	"net"
 	"net/http"
+	"os"
+	"os/signal"
 	"strconv"
+	"syscall"
 	"time"
 
 	conf "github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/tools/discovery"
+	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/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
 
-	ConfigPath conf.Path
-	Index      conf.Index
+	RuntimeEnv string
+	ConfigPath string
 }
 
-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))
+func Start(ctx context.Context, index int, config *Config) error {
+	apiPort, err := datautil.GetElemByIndex(config.API.Api.Ports, 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
+		)
 
-	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() {
-			defer close(done)
-			select {
-			case <-ctx.Done():
-				apiCancel(fmt.Errorf("recv ctx %w", context.Cause(ctx)))
-			case <-apiCtx.Done():
+		if config.API.Prometheus.AutoSetPorts {
+			listener, prometheusPort, err = getAutoPort()
+			if err != nil {
+				return err
 			}
-			log.ZDebug(ctx, "api server is shutting down")
-			if err := httpServer.Shutdown(context.Background()); err != nil {
-				log.ZWarn(ctx, "api server shutdown err", 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))
+			}
+		}
+
+		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{}{}
 			}
 		}()
-		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")
+
+	}
+	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{}{}
 		}
-		apiCancel(err)
 	}()
 
 	//if config.Discovery.Enable == conf.ETCD {
@@ -90,15 +157,19 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, service g
 	//case <-ctx.Done():
 	//}
 	<-apiCtx.Done()
-	exitCause := context.Cause(ctx)
+	exitCause := context.Cause(apiCtx)
 	log.ZWarn(ctx, "api server exit", exitCause)
 	timer := time.NewTimer(time.Second * 15)
 	defer timer.Stop()
 	select {
-	case <-timer.C:
-		log.ZWarn(ctx, "api server graceful stop timeout", nil)
-	case <-done:
-		log.ZDebug(ctx, "api server graceful stop done")
+	case <-sigs:
+		program.SIGTERMExit()
+		if err := shutdown(); err != nil {
+			return err
+		}
+	case <-netDone:
+		close(netDone)
+		return netErr
 	}
-	return exitCause
+	return nil
 }

internal/api/msg.go

@@ -379,7 +379,7 @@ func (m *MessageApi) SendBusinessNotification(c *gin.Context) {
 				IsSendMsg:        req.SendMsg,
 				ReliabilityLevel: *req.ReliabilityLevel,
 				UnreadCount:      false,
-			}, nil),
+			}),
 		},
 	}
 	respPb, err := m.Client.SendMsg(c, &sendMsgReq)
@@ -524,7 +524,6 @@ func (m *MessageApi) SendSimpleMessage(c *gin.Context) {
 		apiresp.GinError(c, err)
 		return
 	}
-
 	m.ginRespSendMsg(c, sendReq, respPb)
 }
 

internal/api/prometheus_discovery.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"encoding/json"
-	"errors"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -12,16 +11,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.Conn) *PrometheusDiscoveryApi {
+func NewPrometheusDiscoveryApi(config *Config, client discovery.SvcDiscoveryRegistry) *PrometheusDiscoveryApi {
 	api := &PrometheusDiscoveryApi{
 		config: config,
 	}
@@ -31,26 +30,43 @@ func NewPrometheusDiscoveryApi(config *Config, client discovery.Conn) *Prometheu
 	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) {
-	value, err := p.kv.GetKey(c, prommetrics.BuildDiscoveryKey(key))
+	eResp, err := p.client.Get(c, prommetrics.BuildDiscoveryKey(key))
 	if err != nil {
-		if errors.Is(err, discovery.ErrNotSupportedKeyValue) {
-			c.JSON(http.StatusOK, []struct{}{})
-			return
+		// Log and respond with an error if preparation fails.
+		apiresp.GinError(c, errs.WrapMsg(err, "etcd get err"))
+		return
+	}
+	if len(eResp.Kvs) == 0 {
+		c.JSON(http.StatusOK, []*prommetrics.Target{})
+	}
+
+	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
 		}
-		apiresp.GinError(c, errs.WrapMsg(err, "get key value"))
-		return
 	}
-	if len(value) == 0 {
-		c.JSON(http.StatusOK, []*prommetrics.RespTarget{})
-		return
-	}
-	var resp prommetrics.RespTarget
-	if err := json.Unmarshal(value, &resp); err != nil {
-		apiresp.GinError(c, errs.WrapMsg(err, "json unmarshal err"))
-		return
-	}
-	c.JSON(http.StatusOK, []*prommetrics.RespTarget{&resp})
+
+	c.JSON(200, []*prommetrics.RespTarget{resp})
 }
 
 func (p *PrometheusDiscoveryApi) Api(c *gin.Context) {

internal/api/router.go

@@ -9,8 +9,12 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
 	"github.com/go-playground/validator/v10"
-	"github.com/openimsdk/open-im-server/v3/internal/api/jssdk"
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/utils/datautil"
+	clientv3 "go.etcd.io/etcd/client/v3"
+
+	"github.com/openimsdk/open-im-server/v3/internal/api/jssdk"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
@@ -53,7 +57,7 @@ func prommetricsGin() gin.HandlerFunc {
 	}
 }
 
-func newGinRouter(ctx context.Context, client discovery.Conn, cfg *Config) (*gin.Engine, error) {
+func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, cfg *Config) (*gin.Engine, error) {
 	authConn, err := client.GetConn(ctx, cfg.Discovery.RpcService.Auth)
 	if err != nil {
 		return nil, err
@@ -287,7 +291,7 @@ func newGinRouter(ctx context.Context, client discovery.Conn, cfg *Config) (*gin
 	}
 	{
 		pd := NewPrometheusDiscoveryApi(cfg, client)
-		proDiscoveryGroup := r.Group("/prometheus_discovery")
+		proDiscoveryGroup := r.Group("/prometheus_discovery", pd.Enable)
 		proDiscoveryGroup.GET("/api", pd.Api)
 		proDiscoveryGroup.GET("/user", pd.User)
 		proDiscoveryGroup.GET("/group", pd.Group)
@@ -305,8 +309,9 @@ func newGinRouter(ctx context.Context, client discovery.Conn, cfg *Config) (*gin
 	if cfg.Discovery.Enable == config.ETCD {
 		etcdClient = client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
 	}
-	cm := NewConfigManager(cfg.Share.IMAdminUserID, &cfg.AllConfig, etcdClient, string(cfg.ConfigPath))
+	cm := NewConfigManager(cfg.Share.IMAdminUserID, cfg.AllConfig, etcdClient, cfg.ConfigPath, cfg.RuntimeEnv)
 	{
+
 		configGroup := r.Group("/config", cm.CheckAdmin)
 		configGroup.POST("/get_config_list", cm.GetConfigList)
 		configGroup.POST("/get_config", cm.GetConfig)
@@ -354,7 +359,9 @@ func GinParseToken(authClient *rpcli.AuthClient) gin.HandlerFunc {
 
 func setGinIsAdmin(imAdminUserID []string) gin.HandlerFunc {
 	return func(c *gin.Context) {
-		c.Set(authverify.CtxAdminUserIDsKey, imAdminUserID)
+		opUserID := mcontext.GetOpUserID(c)
+		admin := datautil.Contain(opUserID, imAdminUserID...)
+		c.Set(authverify.CtxIsAdminKey, admin)
 	}
 }
 

internal/api/user.go

@@ -29,11 +29,11 @@ import (
 
 type UserApi struct {
 	Client user.UserClient
-	discov discovery.Conn
+	discov discovery.SvcDiscoveryRegistry
 	config config.RpcService
 }
 
-func NewUserApi(client user.UserClient, discov discovery.Conn, config config.RpcService) UserApi {
+func NewUserApi(client user.UserClient, discov discovery.SvcDiscoveryRegistry, config config.RpcService) UserApi {
 	return UserApi{Client: client, discov: discov, config: config}
 }
 

internal/msggateway/hub_server.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/msggateway"
 	"github.com/openimsdk/protocol/sdkws"
@@ -34,7 +35,7 @@ import (
 	"google.golang.org/grpc"
 )
 
-func (s *Server) InitServer(ctx context.Context, config *Config, disCov discovery.Conn, server grpc.ServiceRegistrar) error {
+func (s *Server) InitServer(ctx context.Context, config *Config, disCov discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
 	userConn, err := disCov.GetConn(ctx, config.Discovery.RpcService.User)
 	if err != nil {
 		return err
@@ -50,26 +51,26 @@ func (s *Server) InitServer(ctx context.Context, config *Config, disCov discover
 	return nil
 }
 
-//func (s *Server) Start(ctx context.Context, index int, conf *Config) error {
-//	return startrpc.Start(ctx, &conf.Discovery, &conf.MsgGateway.Prometheus, conf.MsgGateway.ListenIP,
-//		conf.MsgGateway.RPC.RegisterIP,
-//		conf.MsgGateway.RPC.AutoSetPorts, conf.MsgGateway.RPC.Ports, index,
-//		conf.Discovery.RpcService.MessageGateway,
-//		nil,
-//		conf,
-//		[]string{
-//			conf.Share.GetConfigFileName(),
-//			conf.Discovery.GetConfigFileName(),
-//			conf.MsgGateway.GetConfigFileName(),
-//			conf.WebhooksConfig.GetConfigFileName(),
-//			conf.RedisConfig.GetConfigFileName(),
-//		},
-//		[]string{
-//			conf.Discovery.RpcService.MessageGateway,
-//		},
-//		s.InitServer,
-//	)
-//}
+func (s *Server) Start(ctx context.Context, index int, conf *Config) error {
+	return startrpc.Start(ctx, &conf.Discovery, &conf.MsgGateway.Prometheus, conf.MsgGateway.ListenIP,
+		conf.MsgGateway.RPC.RegisterIP,
+		conf.MsgGateway.RPC.AutoSetPorts, conf.MsgGateway.RPC.Ports, index,
+		conf.Discovery.RpcService.MessageGateway,
+		nil,
+		conf,
+		[]string{
+			conf.Share.GetConfigFileName(),
+			conf.Discovery.GetConfigFileName(),
+			conf.MsgGateway.GetConfigFileName(),
+			conf.WebhooksConfig.GetConfigFileName(),
+			conf.RedisConfig.GetConfigFileName(),
+		},
+		[]string{
+			conf.Discovery.RpcService.MessageGateway,
+		},
+		s.InitServer,
+	)
+}
 
 type Server struct {
 	msggateway.UnimplementedMsgGatewayServer

internal/msggateway/init.go

@@ -19,14 +19,10 @@ import (
 	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/dbbuild"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpccache"
-	"github.com/openimsdk/tools/discovery"
-	"github.com/openimsdk/tools/utils/datautil"
-	"github.com/openimsdk/tools/utils/runtimeenv"
-	"google.golang.org/grpc"
-
+	"github.com/openimsdk/tools/db/redisutil"
 	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/utils/datautil"
 )
 
 type Config struct {
@@ -35,25 +31,21 @@ type Config struct {
 	RedisConfig    config.Redis
 	WebhooksConfig config.Webhooks
 	Discovery      config.Discovery
-	Index          config.Index
 }
 
 // Start run ws server.
-func Start(ctx context.Context, conf *Config, client discovery.Conn, server grpc.ServiceRegistrar) error {
-	log.CInfo(ctx, "MSG-GATEWAY server is initializing", "runtimeEnv", runtimeenv.RuntimeEnvironment(),
+func Start(ctx context.Context, index int, conf *Config) error {
+	log.CInfo(ctx, "MSG-GATEWAY server is initializing", "autoSetPorts", conf.MsgGateway.RPC.AutoSetPorts,
 		"rpcPorts", conf.MsgGateway.RPC.Ports,
 		"wsPort", conf.MsgGateway.LongConnSvr.Ports, "prometheusPorts", conf.MsgGateway.Prometheus.Ports)
-	wsPort, err := datautil.GetElemByIndex(conf.MsgGateway.LongConnSvr.Ports, int(conf.Index))
+	wsPort, err := datautil.GetElemByIndex(conf.MsgGateway.LongConnSvr.Ports, index)
 	if err != nil {
 		return err
 	}
-
-	dbb := dbbuild.NewBuilder(nil, &conf.RedisConfig)
-	rdb, err := dbb.Redis(ctx)
+	rdb, err := redisutil.NewRedisClient(ctx, conf.RedisConfig.Build())
 	if err != nil {
 		return err
 	}
-
 	longServer := NewWsServer(
 		conf,
 		WithPort(wsPort),
@@ -68,50 +60,12 @@ func Start(ctx context.Context, conf *Config, client discovery.Conn, server grpc
 		return err
 	})
 
-	if err := hubServer.InitServer(ctx, conf, client, server); err != nil {
-		return err
-	}
-
 	go longServer.ChangeOnlineStatus(4)
 
-	return hubServer.LongConnServer.Run(ctx)
+	netDone := make(chan error)
+	go func() {
+		err = hubServer.Start(ctx, index, conf)
+		netDone <- err
+	}()
+	return hubServer.LongConnServer.Run(netDone)
 }
-
-//
-//// Start run ws server.
-//func Start(ctx context.Context, index int, conf *Config) error {
-//	log.CInfo(ctx, "MSG-GATEWAY server is initializing", "runtimeEnv", runtimeenv.RuntimeEnvironment(),
-//		"rpcPorts", conf.MsgGateway.RPC.Ports,
-//		"wsPort", conf.MsgGateway.LongConnSvr.Ports, "prometheusPorts", conf.MsgGateway.Prometheus.Ports)
-//	wsPort, err := datautil.GetElemByIndex(conf.MsgGateway.LongConnSvr.Ports, index)
-//	if err != nil {
-//		return err
-//	}
-//
-//	rdb, err := redisutil.NewRedisClient(ctx, conf.RedisConfig.Build())
-//	if err != nil {
-//		return err
-//	}
-//	longServer := NewWsServer(
-//		conf,
-//		WithPort(wsPort),
-//		WithMaxConnNum(int64(conf.MsgGateway.LongConnSvr.WebsocketMaxConnNum)),
-//		WithHandshakeTimeout(time.Duration(conf.MsgGateway.LongConnSvr.WebsocketTimeout)*time.Second),
-//		WithMessageMaxMsgLength(conf.MsgGateway.LongConnSvr.WebsocketMaxMsgLen),
-//	)
-//
-//	hubServer := NewServer(longServer, conf, func(srv *Server) error {
-//		var err error
-//		longServer.online, err = rpccache.NewOnlineCache(srv.userClient, nil, rdb, false, longServer.subscriberUserOnlineStatusChanges)
-//		return err
-//	})
-//
-//	go longServer.ChangeOnlineStatus(4)
-//
-//	netDone := make(chan error)
-//	go func() {
-//		err = hubServer.Start(ctx, index, conf)
-//		netDone <- err
-//	}()
-//	return hubServer.LongConnServer.Run(netDone)
-//}

internal/msggateway/ws_server.go

@@ -2,6 +2,7 @@ package msggateway
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net/http"
 	"sync"
@@ -10,6 +11,7 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/common/discovery/etcd"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpccache"
 	pbAuth "github.com/openimsdk/protocol/auth"
@@ -21,18 +23,19 @@ import (
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/msggateway"
 	"github.com/openimsdk/tools/discovery"
+	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/utils/stringutil"
 	"golang.org/x/sync/errgroup"
 )
 
 type LongConnServer interface {
-	Run(ctx context.Context) error
+	Run(done chan error) error
 	wsHandler(w http.ResponseWriter, r *http.Request)
 	GetUserAllCons(userID string) ([]*Client, bool)
 	GetUserPlatformCons(userID string, platform int) ([]*Client, bool, bool)
 	Validate(s any) error
-	SetDiscoveryRegistry(ctx context.Context, client discovery.Conn, config *Config) error
+	SetDiscoveryRegistry(ctx context.Context, client discovery.SvcDiscoveryRegistry, config *Config) error
 	KickUserConn(client *Client) error
 	UnRegister(c *Client)
 	SetKickHandlerInfo(i *kickHandler)
@@ -49,7 +52,7 @@ type WsServer struct {
 	unregisterChan    chan *Client
 	kickHandlerChan   chan *kickHandler
 	clients           UserMap
-	online            rpccache.OnlineCache
+	online            *rpccache.OnlineCache
 	subscription      *Subscription
 	clientPool        sync.Pool
 	onlineUserNum     atomic.Int64
@@ -57,7 +60,7 @@ type WsServer struct {
 	handshakeTimeout  time.Duration
 	writeBufferSize   int
 	validate          *validator.Validate
-	disCov            discovery.Conn
+	disCov            discovery.SvcDiscoveryRegistry
 	Compressor
 	//Encoder
 	MessageHandler
@@ -72,7 +75,7 @@ type kickHandler struct {
 	newClient  *Client
 }
 
-func (ws *WsServer) SetDiscoveryRegistry(ctx context.Context, disCov discovery.Conn, config *Config) error {
+func (ws *WsServer) SetDiscoveryRegistry(ctx context.Context, disCov discovery.SvcDiscoveryRegistry, config *Config) error {
 	userConn, err := disCov.GetConn(ctx, config.Discovery.RpcService.User)
 	if err != nil {
 		return err
@@ -155,14 +158,19 @@ func NewWsServer(msgGatewayConfig *Config, opts ...Option) *WsServer {
 	}
 }
 
-func (ws *WsServer) Run(ctx context.Context) error {
-	var client *Client
+func (ws *WsServer) Run(done chan error) error {
+	var (
+		client       *Client
+		netErr       error
+		shutdownDone = make(chan struct{}, 1)
+	)
+
+	server := http.Server{Addr: ":" + stringutil.IntToString(ws.port), Handler: nil}
 
-	ctx, cancel := context.WithCancelCause(ctx)
 	go func() {
 		for {
 			select {
-			case <-ctx.Done():
+			case <-shutdownDone:
 				return
 			case client = <-ws.registerChan:
 				ws.registerClient(client)
@@ -173,37 +181,42 @@ func (ws *WsServer) Run(ctx context.Context) error {
 			}
 		}
 	}()
-
-	done := make(chan struct{})
+	netDone := make(chan struct{}, 1)
 	go func() {
-		wsServer := http.Server{Addr: fmt.Sprintf(":%d", ws.port), Handler: nil}
 		http.HandleFunc("/", ws.wsHandler)
-		go func() {
-			defer close(done)
-			<-ctx.Done()
-			_ = wsServer.Shutdown(context.Background())
-		}()
-		err := wsServer.ListenAndServe()
-		if err == nil {
-			err = fmt.Errorf("http server closed")
+		err := server.ListenAndServe()
+		if err != nil && !errors.Is(err, http.ErrServerClosed) {
+			netErr = errs.WrapMsg(err, "ws start err", server.Addr)
+			netDone <- struct{}{}
 		}
-		cancel(fmt.Errorf("msg gateway %w", err))
 	}()
-
-	<-ctx.Done()
-
-	timeout := time.NewTimer(time.Second * 15)
-	defer timeout.Stop()
-	select {
-	case <-timeout.C:
-		log.ZWarn(ctx, "msg gateway graceful stop timeout", nil)
-	case <-done:
-		log.ZDebug(ctx, "msg gateway graceful stop done")
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	shutDown := func() error {
+		sErr := server.Shutdown(ctx)
+		if sErr != nil {
+			return errs.WrapMsg(sErr, "shutdown err")
+		}
+		close(shutdownDone)
+		return nil
 	}
-	return context.Cause(ctx)
+	etcd.RegisterShutDown(shutDown)
+	defer cancel()
+	var err error
+	select {
+	case err = <-done:
+		if err := shutDown(); err != nil {
+			return err
+		}
+		if err != nil {
+			return err
+		}
+	case <-netDone:
+	}
+	return netErr
+
 }
 
-const concurrentRequest = 3
+var concurrentRequest = 3
 
 func (ws *WsServer) sendUserOnlineInfoToOtherNode(ctx context.Context, client *Client) error {
 	conns, err := ws.disCov.GetConns(ctx, ws.msgGatewayConfig.Discovery.RpcService.MessageGateway)

internal/msgtransfer/init.go

@@ -16,35 +16,51 @@ package msgtransfer
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
 
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/mcache"
+	disetcd "github.com/openimsdk/open-im-server/v3/pkg/common/discovery/etcd"
+	"github.com/openimsdk/tools/discovery"
+	"github.com/openimsdk/tools/discovery/etcd"
+	"github.com/openimsdk/tools/utils/jsonutil"
+	"github.com/openimsdk/tools/utils/network"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
-	"github.com/openimsdk/open-im-server/v3/pkg/dbbuild"
-	"github.com/openimsdk/open-im-server/v3/pkg/mqbuild"
-	"github.com/openimsdk/tools/discovery"
-	"github.com/openimsdk/tools/mq"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/redisutil"
+	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/openimsdk/tools/utils/runtimeenv"
 
 	conf "github.com/openimsdk/open-im-server/v3/pkg/common/config"
+	discRegister "github.com/openimsdk/open-im-server/v3/pkg/common/discovery"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
+	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/mw"
+	"github.com/openimsdk/tools/system/program"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
 )
 
 type MsgTransfer struct {
-	historyConsumer      mq.Consumer
-	historyMongoConsumer mq.Consumer
 	// This consumer aggregated messages, subscribed to the topic:toRedis,
 	//  the message is stored in redis, Incr Redis, and then the message is sent to toPush topic for push,
 	// and the message is sent to toMongo topic for persistence
-	historyHandler *OnlineHistoryRedisConsumerHandler
+	historyCH *OnlineHistoryRedisConsumerHandler
 	//This consumer handle message to mongo
-	historyMongoHandler *OnlineHistoryMongoConsumerHandler
-	ctx                 context.Context
-	//cancel              context.CancelFunc
+	historyMongoCH *OnlineHistoryMongoConsumerHandler
+	ctx            context.Context
+	cancel         context.CancelFunc
+
+	runTimeEnv string
 }
 
 type Config struct {
@@ -55,59 +71,48 @@ type Config struct {
 	Share          conf.Share
 	WebhooksConfig conf.Webhooks
 	Discovery      conf.Discovery
-	Index          conf.Index
 }
 
-func Start(ctx context.Context, config *Config, client discovery.Conn, server grpc.ServiceRegistrar) error {
-	builder := mqbuild.NewBuilder(&config.KafkaConfig)
+func Start(ctx context.Context, index int, config *Config) error {
+	runTimeEnv := runtimeenv.RuntimeEnvironment()
 
-	log.CInfo(ctx, "MSG-TRANSFER server is initializing", "runTimeEnv", runtimeenv.RuntimeEnvironment(), "prometheusPorts",
-		config.MsgTransfer.Prometheus.Ports, "index", config.Index)
-	dbb := dbbuild.NewBuilder(&config.MongodbConfig, &config.RedisConfig)
-	mgocli, err := dbb.Mongo(ctx)
+	log.CInfo(ctx, "MSG-TRANSFER server is initializing", "runTimeEnv", runTimeEnv, "prometheusPorts",
+		config.MsgTransfer.Prometheus.Ports, "index", index)
+
+	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
 	if err != nil {
 		return err
 	}
-	rdb, err := dbb.Redis(ctx)
+	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
 	if err != nil {
 		return err
 	}
+	client, err := discRegister.NewDiscoveryRegister(&config.Discovery, runTimeEnv, nil)
+	if err != nil {
+		return err
+	}
+	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")))
+
+	if config.Discovery.Enable == conf.ETCD {
+		cm := disetcd.NewConfigManager(client.(*etcd.SvcDiscoveryRegistryImpl).GetClient(), []string{
+			config.MsgTransfer.GetConfigFileName(),
+			config.RedisConfig.GetConfigFileName(),
+			config.MongodbConfig.GetConfigFileName(),
+			config.KafkaConfig.GetConfigFileName(),
+			config.Share.GetConfigFileName(),
+			config.WebhooksConfig.GetConfigFileName(),
+			config.Discovery.GetConfigFileName(),
+			conf.LogConfigFileName,
+		})
+		cm.Watch(ctx)
+	}
 
-	//if config.Discovery.Enable == conf.ETCD {
-	//	cm := disetcd.NewConfigManager(client.(*etcd.SvcDiscoveryRegistryImpl).GetClient(), []string{
-	//		config.MsgTransfer.GetConfigFileName(),
-	//		config.RedisConfig.GetConfigFileName(),
-	//		config.MongodbConfig.GetConfigFileName(),
-	//		config.KafkaConfig.GetConfigFileName(),
-	//		config.Share.GetConfigFileName(),
-	//		config.WebhooksConfig.GetConfigFileName(),
-	//		config.Discovery.GetConfigFileName(),
-	//		conf.LogConfigFileName,
-	//	})
-	//	cm.Watch(ctx)
-	//}
-	mongoProducer, err := builder.GetTopicProducer(ctx, config.KafkaConfig.ToMongoTopic)
-	if err != nil {
-		return err
-	}
-	pushProducer, err := builder.GetTopicProducer(ctx, config.KafkaConfig.ToPushTopic)
-	if err != nil {
-		return err
-	}
 	msgDocModel, err := mgo.NewMsgMongo(mgocli.GetDB())
 	if err != nil {
 		return err
 	}
-	var msgModel cache.MsgCache
-	if rdb == nil {
-		cm, err := mgo.NewCacheMgo(mgocli.GetDB())
-		if err != nil {
-			return err
-		}
-		msgModel = mcache.NewMsgCache(cm, msgDocModel)
-	} else {
-		msgModel = redis.NewMsgCache(rdb, msgDocModel)
-	}
+	msgModel := redis.NewMsgCache(rdb, msgDocModel)
 	seqConversation, err := mgo.NewSeqConversationMongo(mgocli.GetDB())
 	if err != nil {
 		return err
@@ -118,68 +123,124 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 		return err
 	}
 	seqUserCache := redis.NewSeqUserCacheRedis(rdb, seqUser)
-	msgTransferDatabase, err := controller.NewMsgTransferDatabase(msgDocModel, msgModel, seqUserCache, seqConversationCache, mongoProducer, pushProducer)
+	msgTransferDatabase, err := controller.NewMsgTransferDatabase(msgDocModel, msgModel, seqUserCache, seqConversationCache, &config.KafkaConfig)
 	if err != nil {
 		return err
 	}
-	historyConsumer, err := builder.GetTopicConsumer(ctx, config.KafkaConfig.ToRedisTopic)
+	historyCH, err := NewOnlineHistoryRedisConsumerHandler(ctx, client, config, msgTransferDatabase)
 	if err != nil {
 		return err
 	}
-	historyMongoConsumer, err := builder.GetTopicConsumer(ctx, config.KafkaConfig.ToMongoTopic)
+	historyMongoCH, err := NewOnlineHistoryMongoConsumerHandler(&config.KafkaConfig, msgTransferDatabase)
 	if err != nil {
 		return err
 	}
-	historyHandler, err := NewOnlineHistoryRedisConsumerHandler(ctx, client, config, msgTransferDatabase)
-	if err != nil {
-		return err
-	}
-	historyMongoHandler := NewOnlineHistoryMongoConsumerHandler(msgTransferDatabase)
 
 	msgTransfer := &MsgTransfer{
-		historyConsumer:      historyConsumer,
-		historyMongoConsumer: historyMongoConsumer,
-		historyHandler:       historyHandler,
-		historyMongoHandler:  historyMongoHandler,
+		historyCH:      historyCH,
+		historyMongoCH: historyMongoCH,
+		runTimeEnv:     runTimeEnv,
 	}
 
-	return msgTransfer.Start(ctx)
+	return msgTransfer.Start(index, config, client)
 }
 
-func (m *MsgTransfer) Start(ctx context.Context) error {
-	var cancel context.CancelCauseFunc
-	m.ctx, cancel = context.WithCancelCause(ctx)
+func (m *MsgTransfer) Start(index int, config *Config, client discovery.SvcDiscoveryRegistry) error {
+	m.ctx, m.cancel = context.WithCancel(context.Background())
+	var (
+		netDone = make(chan struct{}, 1)
+		netErr  error
+	)
 
-	go func() {
-		for {
-			if err := m.historyConsumer.Subscribe(m.ctx, m.historyHandler.HandlerRedisMessage); err != nil {
-				cancel(fmt.Errorf("history consumer %w", err))
-				log.ZError(m.ctx, "historyConsumer err", err)
-				return
-			}
-		}
-	}()
-
-	go func() {
-		fn := func(ctx context.Context, key string, value []byte) error {
-			m.historyMongoHandler.HandleChatWs2Mongo(ctx, key, value)
-			return nil
-		}
-		for {
-			if err := m.historyMongoConsumer.Subscribe(m.ctx, fn); err != nil {
-				cancel(fmt.Errorf("history mongo consumer %w", err))
-				log.ZError(m.ctx, "historyMongoConsumer err", err)
-				return
-			}
-		}
-	}()
-
-	go m.historyHandler.HandleUserHasReadSeqMessages(m.ctx)
-
-	err := m.historyHandler.redisMessageBatches.Start()
+	go m.historyCH.historyConsumerGroup.RegisterHandleAndConsumer(m.ctx, m.historyCH)
+	go m.historyMongoCH.historyConsumerGroup.RegisterHandleAndConsumer(m.ctx, m.historyMongoCH)
+	go m.historyCH.HandleUserHasReadSeqMessages(m.ctx)
+	err := m.historyCH.redisMessageBatches.Start()
 	if err != nil {
 		return err
 	}
-	<-m.ctx.Done()
-	return context.Cause(m.ctx)
+
+	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.MsgTransfer.Prometheus.AutoSetPorts && config.Discovery.Enable != conf.ETCD {
+		return errs.New("only etcd support autoSetPorts", "RegisterName", "api").Wrap()
+	}
+
+	if config.MsgTransfer.Prometheus.Enable {
+		var (
+			listener       net.Listener
+			prometheusPort int
+		)
+
+		if config.MsgTransfer.Prometheus.AutoSetPorts {
+			listener, prometheusPort, err = getAutoPort()
+			if err != nil {
+				return err
+			}
+
+			etcdClient := client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
+
+			_, err = etcdClient.Put(context.TODO(), prommetrics.BuildDiscoveryKey(prommetrics.MessageTransferKeyName), jsonutil.StructToJsonString(prommetrics.BuildDefaultTarget(registerIP, prometheusPort)))
+			if err != nil {
+				return errs.WrapMsg(err, "etcd put err")
+			}
+		} else {
+			prometheusPort, err = datautil.GetElemByIndex(config.MsgTransfer.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))
+			}
+		}
+
+		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					log.ZPanic(m.ctx, "MsgTransfer Start Panic", errs.ErrPanic(r))
+				}
+			}()
+			if err := prommetrics.TransferInit(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
+				netErr = errs.WrapMsg(err, "prometheus start error", "prometheusPort", prometheusPort)
+				netDone <- struct{}{}
+			}
+		}()
+	}
+
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGTERM)
+	select {
+	case <-sigs:
+		program.SIGTERMExit()
+		// graceful close kafka client.
+		m.cancel()
+		m.historyCH.redisMessageBatches.Close()
+		m.historyCH.Close()
+		m.historyCH.historyConsumerGroup.Close()
+		m.historyMongoCH.historyConsumerGroup.Close()
+		return nil
+	case <-netDone:
+		m.cancel()
+		m.historyCH.redisMessageBatches.Close()
+		m.historyCH.Close()
+		m.historyCH.historyConsumerGroup.Close()
+		m.historyMongoCH.historyConsumerGroup.Close()
+		close(netDone)
+		return netErr
+	}
 }

internal/msgtransfer/online_history_msg_handler.go

@@ -18,16 +18,18 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/tools/discovery"
+	"strconv"
+	"strings"
 	"sync"
 	"time"
 
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
-	"github.com/openimsdk/tools/discovery"
-
+	"github.com/IBM/sarama"
 	"github.com/go-redis/redis"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/kafka"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
 	"github.com/openimsdk/open-im-server/v3/pkg/tools/batcher"
 	"github.com/openimsdk/protocol/constant"
@@ -62,7 +64,9 @@ type userHasReadSeq struct {
 }
 
 type OnlineHistoryRedisConsumerHandler struct {
-	redisMessageBatches *batcher.Batcher[ConsumerMessage]
+	historyConsumerGroup *kafka.MConsumerGroup
+
+	redisMessageBatches *batcher.Batcher[sarama.ConsumerMessage]
 
 	msgTransferDatabase         controller.MsgTransferDatabase
 	conversationUserHasReadChan chan *userHasReadSeq
@@ -72,13 +76,12 @@ type OnlineHistoryRedisConsumerHandler struct {
 	conversationClient *rpcli.ConversationClient
 }
 
-type ConsumerMessage struct {
-	Ctx   context.Context
-	Key   string
-	Value []byte
-}
-
-func NewOnlineHistoryRedisConsumerHandler(ctx context.Context, client discovery.Conn, config *Config, database controller.MsgTransferDatabase) (*OnlineHistoryRedisConsumerHandler, error) {
+func NewOnlineHistoryRedisConsumerHandler(ctx context.Context, client discovery.SvcDiscoveryRegistry, config *Config, database controller.MsgTransferDatabase) (*OnlineHistoryRedisConsumerHandler, error) {
+	kafkaConf := config.KafkaConfig
+	historyConsumerGroup, err := kafka.NewMConsumerGroup(kafkaConf.Build(), kafkaConf.ToRedisGroupID, []string{kafkaConf.ToRedisTopic}, false)
+	if err != nil {
+		return nil, err
+	}
 	groupConn, err := client.GetConn(ctx, config.Discovery.RpcService.Group)
 	if err != nil {
 		return nil, err
@@ -94,7 +97,7 @@ func NewOnlineHistoryRedisConsumerHandler(ctx context.Context, client discovery.
 	och.conversationClient = rpcli.NewConversationClient(conversationConn)
 	och.wg.Add(1)
 
-	b := batcher.New[ConsumerMessage](
+	b := batcher.New[sarama.ConsumerMessage](
 		batcher.WithSize(size),
 		batcher.WithWorker(worker),
 		batcher.WithInterval(interval),
@@ -106,15 +109,16 @@ func NewOnlineHistoryRedisConsumerHandler(ctx context.Context, client discovery.
 		hashCode := stringutil.GetHashCode(key)
 		return int(hashCode) % och.redisMessageBatches.Worker()
 	}
-	b.Key = func(consumerMessage *ConsumerMessage) string {
-		return consumerMessage.Key
+	b.Key = func(consumerMessage *sarama.ConsumerMessage) string {
+		return string(consumerMessage.Key)
 	}
 	b.Do = och.do
 	och.redisMessageBatches = b
+	och.historyConsumerGroup = historyConsumerGroup
 
 	return &och, nil
 }
-func (och *OnlineHistoryRedisConsumerHandler) do(ctx context.Context, channelID int, val *batcher.Msg[ConsumerMessage]) {
+func (och *OnlineHistoryRedisConsumerHandler) do(ctx context.Context, channelID int, val *batcher.Msg[sarama.ConsumerMessage]) {
 	ctx = mcontext.WithTriggerIDContext(ctx, val.TriggerID())
 	ctxMessages := och.parseConsumerMessages(ctx, val.Val())
 	ctx = withAggregationCtx(ctx, ctxMessages)
@@ -185,7 +189,7 @@ func (och *OnlineHistoryRedisConsumerHandler) doSetReadSeq(ctx context.Context,
 
 }
 
-func (och *OnlineHistoryRedisConsumerHandler) parseConsumerMessages(ctx context.Context, consumerMessages []*ConsumerMessage) []*ContextMsg {
+func (och *OnlineHistoryRedisConsumerHandler) parseConsumerMessages(ctx context.Context, consumerMessages []*sarama.ConsumerMessage) []*ContextMsg {
 	var ctxMessages []*ContextMsg
 	for i := 0; i < len(consumerMessages); i++ {
 		ctxMsg := &ContextMsg{}
@@ -195,9 +199,16 @@ func (och *OnlineHistoryRedisConsumerHandler) parseConsumerMessages(ctx context.
 			log.ZWarn(ctx, "msg_transfer Unmarshal msg err", err, string(consumerMessages[i].Value))
 			continue
 		}
-		ctxMsg.ctx = consumerMessages[i].Ctx
+		var arr []string
+		for i, header := range consumerMessages[i].Headers {
+			arr = append(arr, strconv.Itoa(i), string(header.Key), string(header.Value))
+		}
+		log.ZDebug(ctx, "consumer.kafka.GetContextWithMQHeader", "len", len(consumerMessages[i].Headers),
+			"header", strings.Join(arr, ", "))
+		ctxMsg.ctx = kafka.GetContextWithMQHeader(consumerMessages[i].Headers)
 		ctxMsg.message = msgFromMQ
-		log.ZDebug(ctx, "message parse finish", "message", msgFromMQ, "key", consumerMessages[i].Key)
+		log.ZDebug(ctx, "message parse finish", "message", msgFromMQ, "key",
+			string(consumerMessages[i].Key))
 		ctxMessages = append(ctxMessages, ctxMsg)
 	}
 	return ctxMessages
@@ -372,9 +383,7 @@ func (och *OnlineHistoryRedisConsumerHandler) Close() {
 func (och *OnlineHistoryRedisConsumerHandler) toPushTopic(ctx context.Context, key, conversationID string, msgs []*ContextMsg) {
 	for _, v := range msgs {
 		log.ZDebug(ctx, "push msg to topic", "msg", v.message.String())
-		if err := och.msgTransferDatabase.MsgToPushMQ(v.ctx, key, conversationID, v.message); err != nil {
-			log.ZError(ctx, "msg to push topic error", err, "msg", v.message.String())
-		}
+		_, _, _ = och.msgTransferDatabase.MsgToPushMQ(v.ctx, key, conversationID, v.message)
 	}
 }
 
@@ -392,10 +401,35 @@ func withAggregationCtx(ctx context.Context, values []*ContextMsg) context.Conte
 	return mcontext.SetOperationID(ctx, allMessageOperationID)
 }
 
-func (och *OnlineHistoryRedisConsumerHandler) HandlerRedisMessage(ctx context.Context, key string, value []byte) error { // a instance in the consumer group
-	err := och.redisMessageBatches.Put(ctx, &ConsumerMessage{Ctx: ctx, Key: key, Value: value})
-	if err != nil {
-		log.ZWarn(ctx, "put msg to  error", err, "key", key, "value", value)
-	}
+func (och *OnlineHistoryRedisConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error { return nil }
+func (och *OnlineHistoryRedisConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error {
 	return nil
 }
+
+func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(session sarama.ConsumerGroupSession,
+	claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
+	log.ZDebug(context.Background(), "online new session msg come", "highWaterMarkOffset",
+		claim.HighWaterMarkOffset(), "topic", claim.Topic(), "partition", claim.Partition())
+	och.redisMessageBatches.OnComplete = func(lastMessage *sarama.ConsumerMessage, totalCount int) {
+		session.MarkMessage(lastMessage, "")
+		session.Commit()
+	}
+	for {
+		select {
+		case msg, ok := <-claim.Messages():
+			if !ok {
+				return nil
+			}
+
+			if len(msg.Value) == 0 {
+				continue
+			}
+			err := och.redisMessageBatches.Put(context.Background(), msg)
+			if err != nil {
+				log.ZWarn(context.Background(), "put msg to  error", err, "msg", msg)
+			}
+		case <-session.Context().Done():
+			return nil
+		}
+	}
+}

internal/msgtransfer/online_msg_to_mongo_handler.go

@@ -17,24 +17,36 @@ package msgtransfer
 import (
 	"context"
 
+	"github.com/IBM/sarama"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/kafka"
 	pbmsg "github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/tools/log"
 	"google.golang.org/protobuf/proto"
 )
 
 type OnlineHistoryMongoConsumerHandler struct {
-	msgTransferDatabase controller.MsgTransferDatabase
+	historyConsumerGroup *kafka.MConsumerGroup
+	msgTransferDatabase  controller.MsgTransferDatabase
 }
 
-func NewOnlineHistoryMongoConsumerHandler(database controller.MsgTransferDatabase) *OnlineHistoryMongoConsumerHandler {
-	return &OnlineHistoryMongoConsumerHandler{
-		msgTransferDatabase: database,
+func NewOnlineHistoryMongoConsumerHandler(kafkaConf *config.Kafka, database controller.MsgTransferDatabase) (*OnlineHistoryMongoConsumerHandler, error) {
+	historyConsumerGroup, err := kafka.NewMConsumerGroup(kafkaConf.Build(), kafkaConf.ToMongoGroupID, []string{kafkaConf.ToMongoTopic}, true)
+	if err != nil {
+		return nil, err
 	}
+
+	mc := &OnlineHistoryMongoConsumerHandler{
+		historyConsumerGroup: historyConsumerGroup,
+		msgTransferDatabase:  database,
+	}
+	return mc, nil
 }
 
-func (mc *OnlineHistoryMongoConsumerHandler) HandleChatWs2Mongo(ctx context.Context, key string, msg []byte) {
+func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(ctx context.Context, cMsg *sarama.ConsumerMessage, key string, session sarama.ConsumerGroupSession) {
+	msg := cMsg.Value
 	msgFromMQ := pbmsg.MsgDataToMongoByMQ{}
 	err := proto.Unmarshal(msg, &msgFromMQ)
 	if err != nil {
@@ -42,13 +54,21 @@ func (mc *OnlineHistoryMongoConsumerHandler) HandleChatWs2Mongo(ctx context.Cont
 		return
 	}
 	if len(msgFromMQ.MsgData) == 0 {
-		log.ZError(ctx, "msgFromMQ.MsgData is empty", nil, "key", key, "msg", msg)
+		log.ZError(ctx, "msgFromMQ.MsgData is empty", nil, "cMsg", cMsg)
 		return
 	}
 	log.ZDebug(ctx, "mongo consumer recv msg", "msgs", msgFromMQ.String())
 	err = mc.msgTransferDatabase.BatchInsertChat2DB(ctx, msgFromMQ.ConversationID, msgFromMQ.MsgData, msgFromMQ.LastSeq)
 	if err != nil {
-		log.ZError(ctx, "single data insert to mongo err", err, "msg", msgFromMQ.MsgData, "conversationID", msgFromMQ.ConversationID)
+		log.ZError(
+			ctx,
+			"single data insert to mongo err",
+			err,
+			"msg",
+			msgFromMQ.MsgData,
+			"conversationID",
+			msgFromMQ.ConversationID,
+		)
 		prommetrics.MsgInsertMongoFailedCounter.Inc()
 	} else {
 		prommetrics.MsgInsertMongoSuccessCounter.Inc()
@@ -62,3 +82,22 @@ func (mc *OnlineHistoryMongoConsumerHandler) HandleChatWs2Mongo(ctx context.Cont
 	//		msgFromMQ.MsgData, "conversationID", msgFromMQ.ConversationID)
 	//}
 }
+
+func (*OnlineHistoryMongoConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error { return nil }
+
+func (*OnlineHistoryMongoConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
+
+func (mc *OnlineHistoryMongoConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error { // an instance in the consumer group
+	log.ZDebug(context.Background(), "online new session msg come", "highWaterMarkOffset",
+		claim.HighWaterMarkOffset(), "topic", claim.Topic(), "partition", claim.Partition())
+	for msg := range claim.Messages() {
+		ctx := mc.historyConsumerGroup.GetContextFromMsg(msg)
+		if len(msg.Value) != 0 {
+			mc.handleChatWs2Mongo(ctx, msg, string(msg.Key), sess)
+		} else {
+			log.ZError(ctx, "mongo msg get from kafka but is nil", nil, "conversationID", msg.Key)
+		}
+		sess.MarkMessage(msg, "")
+	}
+	return nil
+}

internal/push/callback.go

@@ -17,7 +17,6 @@ package push
 import (
 	"context"
 	"encoding/json"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"

internal/push/offlinepush_handler.go

@@ -3,9 +3,11 @@ package push
 import (
 	"context"
 
+	"github.com/IBM/sarama"
 	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush"
 	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/options"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/kafka"
 	"github.com/openimsdk/protocol/constant"
 	pbpush "github.com/openimsdk/protocol/push"
 	"github.com/openimsdk/protocol/sdkws"
@@ -16,16 +18,34 @@ import (
 )
 
 type OfflinePushConsumerHandler struct {
-	offlinePusher offlinepush.OfflinePusher
+	OfflinePushConsumerGroup *kafka.MConsumerGroup
+	offlinePusher            offlinepush.OfflinePusher
 }
 
-func NewOfflinePushConsumerHandler(offlinePusher offlinepush.OfflinePusher) *OfflinePushConsumerHandler {
-	return &OfflinePushConsumerHandler{
-		offlinePusher: offlinePusher,
+func NewOfflinePushConsumerHandler(config *Config, offlinePusher offlinepush.OfflinePusher) (*OfflinePushConsumerHandler, error) {
+	var offlinePushConsumerHandler OfflinePushConsumerHandler
+	var err error
+	offlinePushConsumerHandler.offlinePusher = offlinePusher
+	offlinePushConsumerHandler.OfflinePushConsumerGroup, err = kafka.NewMConsumerGroup(config.KafkaConfig.Build(), config.KafkaConfig.ToOfflineGroupID,
+		[]string{config.KafkaConfig.ToOfflinePushTopic}, true)
+	if err != nil {
+		return nil, err
 	}
+	return &offlinePushConsumerHandler, nil
 }
 
-func (o *OfflinePushConsumerHandler) HandleMsg2OfflinePush(ctx context.Context, msg []byte) {
+func (*OfflinePushConsumerHandler) Setup(sarama.ConsumerGroupSession) error   { return nil }
+func (*OfflinePushConsumerHandler) Cleanup(sarama.ConsumerGroupSession) error { return nil }
+func (o *OfflinePushConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error {
+	for msg := range claim.Messages() {
+		ctx := o.OfflinePushConsumerGroup.GetContextFromMsg(msg)
+		o.handleMsg2OfflinePush(ctx, msg.Value)
+		sess.MarkMessage(msg, "")
+	}
+	return nil
+}
+
+func (o *OfflinePushConsumerHandler) handleMsg2OfflinePush(ctx context.Context, msg []byte) {
 	offlinePushMsg := pbpush.PushMsgReq{}
 	if err := proto.Unmarshal(msg, &offlinePushMsg); err != nil {
 		log.ZError(ctx, "offline push Unmarshal msg err", err, "msg", string(msg))

internal/push/onlinepusher.go

@@ -2,7 +2,7 @@ package push
 
 import (
 	"context"
-	"fmt"
+	"errors"
 	"sync"
 
 	"github.com/openimsdk/protocol/msggateway"
@@ -11,7 +11,6 @@ import (
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/utils/datautil"
-	"github.com/openimsdk/tools/utils/runtimeenv"
 	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc"
 
@@ -31,36 +30,37 @@ func newEmptyOnlinePusher() *emptyOnlinePusher {
 	return &emptyOnlinePusher{}
 }
 
-func (emptyOnlinePusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData, pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
+func (emptyOnlinePusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
+	pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
 	log.ZInfo(ctx, "emptyOnlinePusher GetConnsAndOnlinePush", nil)
 	return nil, nil
 }
-func (u emptyOnlinePusher) GetOnlinePushFailedUserIDs(ctx context.Context, msg *sdkws.MsgData, wsResults []*msggateway.SingleMsgToUserResults, pushToUserIDs *[]string) []string {
+func (u emptyOnlinePusher) GetOnlinePushFailedUserIDs(ctx context.Context, msg *sdkws.MsgData,
+	wsResults []*msggateway.SingleMsgToUserResults, pushToUserIDs *[]string) []string {
 	log.ZInfo(ctx, "emptyOnlinePusher GetOnlinePushFailedUserIDs", nil)
 	return nil
 }
 
-func NewOnlinePusher(disCov discovery.Conn, config *Config) (OnlinePusher, error) {
-	if conf.Standalone() {
-		return NewDefaultAllNode(disCov, config), nil
-	}
-	if runtimeenv.RuntimeEnvironment() == conf.KUBERNETES {
-		return NewDefaultAllNode(disCov, config), nil
+func NewOnlinePusher(disCov discovery.SvcDiscoveryRegistry, config *Config) OnlinePusher {
+
+	if config.runTimeEnv == conf.KUBERNETES {
+		return NewDefaultAllNode(disCov, config)
 	}
 	switch config.Discovery.Enable {
 	case conf.ETCD:
-		return NewDefaultAllNode(disCov, config), nil
+		return NewDefaultAllNode(disCov, config)
 	default:
-		return nil, errs.New(fmt.Sprintf("unsupported discovery type %s", config.Discovery.Enable))
+		log.ZError(context.Background(), "NewOnlinePusher is error", errs.Wrap(errors.New("unsupported discovery type")), "type", config.Discovery.Enable)
+		return nil
 	}
 }
 
 type DefaultAllNode struct {
-	disCov discovery.Conn
+	disCov discovery.SvcDiscoveryRegistry
 	config *Config
 }
 
-func NewDefaultAllNode(disCov discovery.Conn, config *Config) *DefaultAllNode {
+func NewDefaultAllNode(disCov discovery.SvcDiscoveryRegistry, config *Config) *DefaultAllNode {
 	return &DefaultAllNode{disCov: disCov, config: config}
 }
 

internal/push/push.go

@@ -2,43 +2,38 @@ package push
 
 import (
 	"context"
-	"math/rand"
-	"strconv"
 
 	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/mcache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
-	"github.com/openimsdk/open-im-server/v3/pkg/dbbuild"
-	"github.com/openimsdk/open-im-server/v3/pkg/mqbuild"
 	pbpush "github.com/openimsdk/protocol/push"
+	"github.com/openimsdk/tools/db/redisutil"
 	"github.com/openimsdk/tools/discovery"
-	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/mcontext"
 	"google.golang.org/grpc"
 )
 
 type pushServer struct {
 	pbpush.UnimplementedPushMsgServiceServer
 	database      controller.PushDatabase
-	disCov        discovery.Conn
+	disCov        discovery.SvcDiscoveryRegistry
 	offlinePusher offlinepush.OfflinePusher
+	pushCh        *ConsumerHandler
+	offlinePushCh *OfflinePushConsumerHandler
 }
 
 type Config struct {
 	RpcConfig          config.Push
 	RedisConfig        config.Redis
-	MongoConfig        config.Mongo
 	KafkaConfig        config.Kafka
 	NotificationConfig config.Notification
 	Share              config.Share
 	WebhooksConfig     config.Webhooks
 	LocalCacheConfig   config.LocalCache
 	Discovery          config.Discovery
-	FcmConfigPath      config.Path
+	FcmConfigPath      string
+
+	runTimeEnv string
 }
 
 func (p pushServer) DelUserPushToken(ctx context.Context,
@@ -49,90 +44,40 @@ func (p pushServer) DelUserPushToken(ctx context.Context,
 	return &pbpush.DelUserPushTokenResp{}, nil
 }
 
-func Start(ctx context.Context, config *Config, client discovery.Conn, server grpc.ServiceRegistrar) error {
-	dbb := dbbuild.NewBuilder(&config.MongoConfig, &config.RedisConfig)
-	rdb, err := dbb.Redis(ctx)
+func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
+	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
 	if err != nil {
 		return err
 	}
-	var cacheModel cache.ThirdCache
-	if rdb == nil {
-		mdb, err := dbb.Mongo(ctx)
-		if err != nil {
-			return err
-		}
-		mc, err := mgo.NewCacheMgo(mdb.GetDB())
-		if err != nil {
-			return err
-		}
-		cacheModel = mcache.NewThirdCache(mc)
-	} else {
-		cacheModel = redis.NewThirdCache(rdb)
-	}
-	offlinePusher, err := offlinepush.NewOfflinePusher(&config.RpcConfig, cacheModel, string(config.FcmConfigPath))
-	if err != nil {
-		return err
-	}
-	builder := mqbuild.NewBuilder(&config.KafkaConfig)
-
-	offlinePushProducer, err := builder.GetTopicProducer(ctx, config.KafkaConfig.ToOfflinePushTopic)
-	if err != nil {
-		return err
-	}
-	database := controller.NewPushDatabase(cacheModel, offlinePushProducer)
-
-	pushConsumer, err := builder.GetTopicConsumer(ctx, config.KafkaConfig.ToPushTopic)
-	if err != nil {
-		return err
-	}
-	offlinePushConsumer, err := builder.GetTopicConsumer(ctx, config.KafkaConfig.ToOfflinePushTopic)
+	cacheModel := redis.NewThirdCache(rdb)
+	offlinePusher, err := offlinepush.NewOfflinePusher(&config.RpcConfig, cacheModel, config.FcmConfigPath)
 	if err != nil {
 		return err
 	}
 
-	pushHandler, err := NewConsumerHandler(ctx, config, database, offlinePusher, rdb, client)
+	database := controller.NewPushDatabase(cacheModel, &config.KafkaConfig)
+
+	consumer, err := NewConsumerHandler(ctx, config, database, offlinePusher, rdb, client)
 	if err != nil {
 		return err
 	}
 
-	offlineHandler := NewOfflinePushConsumerHandler(offlinePusher)
+	offlinePushConsumer, err := NewOfflinePushConsumerHandler(config, offlinePusher)
+	if err != nil {
+		return err
+	}
 
 	pbpush.RegisterPushMsgServiceServer(server, &pushServer{
 		database:      database,
 		disCov:        client,
 		offlinePusher: offlinePusher,
+		pushCh:        consumer,
+		offlinePushCh: offlinePushConsumer,
 	})
 
-	go func() {
-		pushHandler.WaitCache()
-		fn := func(ctx context.Context, key string, value []byte) error {
-			pushHandler.HandleMs2PsChat(ctx, value)
-			return nil
-		}
-		consumerCtx := mcontext.SetOperationID(context.Background(), "push_"+strconv.Itoa(int(rand.Uint32())))
-		log.ZInfo(consumerCtx, "begin consume messages")
-		for {
-			if err := pushConsumer.Subscribe(consumerCtx, fn); err != nil {
-				log.ZError(consumerCtx, "subscribe err", err)
-				return
-			}
-		}
-	}()
+	go consumer.pushConsumerGroup.RegisterHandleAndConsumer(ctx, consumer)
 
-	go func() {
-		fn := func(ctx context.Context, key string, value []byte) error {
-			offlineHandler.HandleMsg2OfflinePush(ctx, value)
-			return nil
-		}
-		consumerCtx := mcontext.SetOperationID(context.Background(), "push_"+strconv.Itoa(int(rand.Uint32())))
-		log.ZInfo(consumerCtx, "begin consume messages")
-		for {
-			if err := offlinePushConsumer.Subscribe(consumerCtx, fn); err != nil {
-				log.ZError(consumerCtx, "subscribe err", err)
-				return
-			}
-		}
-	}()
+	go offlinePushConsumer.OfflinePushConsumerGroup.RegisterHandleAndConsumer(ctx, offlinePushConsumer)
 
 	return nil
 }

internal/push/push_handler.go

@@ -3,16 +3,21 @@ package push
 import (
 	"context"
 	"encoding/json"
+	"math/rand"
+	"strconv"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+
+	"github.com/IBM/sarama"
 	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush"
 	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/options"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/kafka"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpccache"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"github.com/openimsdk/open-im-server/v3/pkg/util/conversationutil"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/msggateway"
@@ -29,11 +34,11 @@ import (
 )
 
 type ConsumerHandler struct {
-	//pushConsumerGroup      mq.Consumer
+	pushConsumerGroup      *kafka.MConsumerGroup
 	offlinePusher          offlinepush.OfflinePusher
 	onlinePusher           OnlinePusher
 	pushDatabase           controller.PushDatabase
-	onlineCache            rpccache.OnlineCache
+	onlineCache            *rpccache.OnlineCache
 	groupLocalCache        *rpccache.GroupLocalCache
 	conversationLocalCache *rpccache.ConversationLocalCache
 	webhookClient          *webhook.Client
@@ -44,7 +49,15 @@ type ConsumerHandler struct {
 	conversationClient     *rpcli.ConversationClient
 }
 
-func NewConsumerHandler(ctx context.Context, config *Config, database controller.PushDatabase, offlinePusher offlinepush.OfflinePusher, rdb redis.UniversalClient, client discovery.Conn) (*ConsumerHandler, error) {
+func NewConsumerHandler(ctx context.Context, config *Config, database controller.PushDatabase, offlinePusher offlinepush.OfflinePusher, rdb redis.UniversalClient,
+	client discovery.SvcDiscoveryRegistry) (*ConsumerHandler, error) {
+	var consumerHandler ConsumerHandler
+	var err error
+	consumerHandler.pushConsumerGroup, err = kafka.NewMConsumerGroup(config.KafkaConfig.Build(), config.KafkaConfig.ToPushGroupID,
+		[]string{config.KafkaConfig.ToPushTopic}, true)
+	if err != nil {
+		return nil, err
+	}
 	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
 	if err != nil {
 		return nil, err
@@ -61,18 +74,13 @@ func NewConsumerHandler(ctx context.Context, config *Config, database controller
 	if err != nil {
 		return nil, err
 	}
-	onlinePusher, err := NewOnlinePusher(client, config)
-	if err != nil {
-		return nil, err
-	}
-	var consumerHandler ConsumerHandler
 	consumerHandler.userClient = rpcli.NewUserClient(userConn)
 	consumerHandler.groupClient = rpcli.NewGroupClient(groupConn)
 	consumerHandler.msgClient = rpcli.NewMsgClient(msgConn)
 	consumerHandler.conversationClient = rpcli.NewConversationClient(conversationConn)
 
 	consumerHandler.offlinePusher = offlinePusher
-	consumerHandler.onlinePusher = onlinePusher
+	consumerHandler.onlinePusher = NewOnlinePusher(client, config)
 	consumerHandler.groupLocalCache = rpccache.NewGroupLocalCache(consumerHandler.groupClient, &config.LocalCacheConfig, rdb)
 	consumerHandler.conversationLocalCache = rpccache.NewConversationLocalCache(consumerHandler.conversationClient, &config.LocalCacheConfig, rdb)
 	consumerHandler.webhookClient = webhook.NewWebhookClient(config.WebhooksConfig.URL)
@@ -85,7 +93,7 @@ func NewConsumerHandler(ctx context.Context, config *Config, database controller
 	return &consumerHandler, nil
 }
 
-func (c *ConsumerHandler) HandleMs2PsChat(ctx context.Context, msg []byte) {
+func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 	msgFromMQ := pbpush.PushMsgReq{}
 	if err := proto.Unmarshal(msg, &msgFromMQ); err != nil {
 		log.ZError(ctx, "push Unmarshal msg err", err, "msg", string(msg))
@@ -119,8 +127,25 @@ func (c *ConsumerHandler) HandleMs2PsChat(ctx context.Context, msg []byte) {
 	}
 }
 
-func (c *ConsumerHandler) WaitCache() {
-	c.onlineCache.WaitCache()
+func (*ConsumerHandler) Setup(sarama.ConsumerGroupSession) error { return nil }
+
+func (*ConsumerHandler) Cleanup(sarama.ConsumerGroupSession) error { return nil }
+
+func (c *ConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error {
+	c.onlineCache.Lock.Lock()
+	for c.onlineCache.CurrentPhase.Load() < rpccache.DoSubscribeOver {
+		c.onlineCache.Cond.Wait()
+	}
+	c.onlineCache.Lock.Unlock()
+	ctx := mcontext.SetOperationID(context.TODO(), strconv.FormatInt(time.Now().UnixNano()+int64(rand.Uint32()), 10))
+	log.ZInfo(ctx, "begin consume messages")
+
+	for msg := range claim.Messages() {
+		ctx := c.pushConsumerGroup.GetContextFromMsg(msg)
+		c.handleMs2PsChat(ctx, msg.Value)
+		sess.MarkMessage(msg, "")
+	}
+	return nil
 }
 
 // Push2User Suitable for two types of conversations, one is SingleChatType and the other is NotificationChatType.

internal/rpc/conversation/conversation.go

@@ -19,23 +19,25 @@ import (
 	"sort"
 	"time"
 
-	"github.com/openimsdk/open-im-server/v3/pkg/dbbuild"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	dbModel "github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
+	"github.com/openimsdk/tools/db/redisutil"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/protocol/constant"
 	pbconversation "github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
@@ -67,13 +69,12 @@ type Config struct {
 	Discovery          config.Discovery
 }
 
-func Start(ctx context.Context, config *Config, client discovery.Conn, server grpc.ServiceRegistrar) error {
-	dbb := dbbuild.NewBuilder(&config.MongodbConfig, &config.RedisConfig)
-	mgocli, err := dbb.Mongo(ctx)
+func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
+	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
 	if err != nil {
 		return err
 	}
-	rdb, err := dbb.Redis(ctx)
+	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
 	if err != nil {
 		return err
 	}

internal/rpc/conversation/notification.go

@@ -16,22 +16,21 @@ package conversation
 
 import (
 	"context"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/notification"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"github.com/openimsdk/protocol/msg"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/sdkws"
 )
 
 type ConversationNotificationSender struct {
-	*notification.NotificationSender
+	*rpcclient.NotificationSender
 }
 
 func NewConversationNotificationSender(conf *config.Notification, msgClient *rpcli.MsgClient) *ConversationNotificationSender {
-	return &ConversationNotificationSender{notification.NewNotificationSender(conf, notification.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+	return &ConversationNotificationSender{rpcclient.NewNotificationSender(conf, rpcclient.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
 		return msgClient.SendMsg(ctx, req)
 	}))}
 }

internal/rpc/group/db_map.go

@@ -16,7 +16,6 @@ package group
 
 import (
 	"context"
-	"strings"
 	"time"
 
 	pbgroup "github.com/openimsdk/protocol/group"
@@ -56,52 +55,41 @@ func UpdateGroupInfoMap(ctx context.Context, group *sdkws.GroupInfoForSet) map[s
 	return m
 }
 
-func UpdateGroupInfoExMap(ctx context.Context, group *pbgroup.SetGroupInfoExReq) (m map[string]any, normalFlag, groupNameFlag, notificationFlag bool, err error) {
-	m = make(map[string]any)
+func UpdateGroupInfoExMap(ctx context.Context, group *pbgroup.SetGroupInfoExReq) (map[string]any, error) {
+	m := make(map[string]any)
 
 	if group.GroupName != nil {
-		if strings.TrimSpace(group.GroupName.Value) != "" {
+		if group.GroupName.Value != "" {
 			m["group_name"] = group.GroupName.Value
-			groupNameFlag = true
 		} else {
-			return nil, normalFlag, notificationFlag, groupNameFlag, errs.ErrArgs.WrapMsg("group name is empty")
+			return nil, errs.ErrArgs.WrapMsg("group name is empty")
 		}
 	}
-
 	if group.Notification != nil {
-		notificationFlag = true
-		group.Notification.Value = strings.TrimSpace(group.Notification.Value) // if Notification only contains spaces, set it to empty string
-
 		m["notification"] = group.Notification.Value
-		m["notification_user_id"] = mcontext.GetOpUserID(ctx)
 		m["notification_update_time"] = time.Now()
+		m["notification_user_id"] = mcontext.GetOpUserID(ctx)
 	}
 	if group.Introduction != nil {
 		m["introduction"] = group.Introduction.Value
-		normalFlag = true
 	}
 	if group.FaceURL != nil {
 		m["face_url"] = group.FaceURL.Value
-		normalFlag = true
 	}
 	if group.NeedVerification != nil {
 		m["need_verification"] = group.NeedVerification.Value
-		normalFlag = true
 	}
 	if group.LookMemberInfo != nil {
 		m["look_member_info"] = group.LookMemberInfo.Value
-		normalFlag = true
 	}
 	if group.ApplyMemberFriend != nil {
 		m["apply_member_friend"] = group.ApplyMemberFriend.Value
-		normalFlag = true
 	}
 	if group.Ex != nil {
 		m["ex"] = group.Ex.Value
-		normalFlag = true
 	}
 
-	return m, normalFlag, groupNameFlag, notificationFlag, nil
+	return m, nil
 }
 
 func UpdateGroupStatusMap(status int) map[string]any {

internal/rpc/group/group.go

@@ -23,11 +23,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/openimsdk/open-im-server/v3/pkg/dbbuild"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
-	"google.golang.org/grpc"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
@@ -46,6 +43,8 @@ import (
 	pbgroup "github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/protocol/wrapperspb"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/redisutil"
 	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
@@ -53,6 +52,7 @@ import (
 	"github.com/openimsdk/tools/mw/specialerror"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/openimsdk/tools/utils/encrypt"
+	"google.golang.org/grpc"
 )
 
 type groupServer struct {
@@ -77,13 +77,12 @@ type Config struct {
 	Discovery          config.Discovery
 }
 
-func Start(ctx context.Context, config *Config, client discovery.Conn, server grpc.ServiceRegistrar) error {
-	dbb := dbbuild.NewBuilder(&config.MongodbConfig, &config.RedisConfig)
-	mgocli, err := dbb.Mongo(ctx)
+func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
+	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
 	if err != nil {
 		return err
 	}
-	rdb, err := dbb.Redis(ctx)
+	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
 	if err != nil {
 		return err
 	}
@@ -99,6 +98,11 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 	if err != nil {
 		return err
 	}
+
+	//userRpcClient := rpcclient.NewUserRpcClient(client, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
+	//msgRpcClient := rpcclient.NewMessageRpcClient(client, config.Share.RpcRegisterName.Msg)
+	//conversationRpcClient := rpcclient.NewConversationRpcClient(client, config.Share.RpcRegisterName.Conversation)
+
 	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
 	if err != nil {
 		return err
@@ -285,14 +289,13 @@ func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 			break
 		}
 	}
-	g.notification.GroupCreatedNotification(ctx, tips, req.SendMessage)
+	g.notification.GroupCreatedNotification(ctx, tips)
 
 	if req.GroupInfo.Notification != "" {
-		notificationFlag := true
 		g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{
 			Group:  tips.Group,
 			OpUser: tips.OpUser,
-		}, &notificationFlag)
+		})
 	}
 
 	reqCallBackAfter := &pbgroup.CreateGroupReq{
@@ -615,7 +618,7 @@ func (g *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
 	for _, userID := range req.KickedUserIDs {
 		tips.KickedUserList = append(tips.KickedUserList, convert.Db2PbGroupMember(memberMap[userID]))
 	}
-	g.notification.MemberKickedNotification(ctx, tips, req.SendMessage)
+	g.notification.MemberKickedNotification(ctx, tips)
 	if err := g.deleteMemberAndSetConversationSeq(ctx, req.GroupID, req.KickedUserIDs); err != nil {
 		return nil, err
 	}
@@ -824,14 +827,8 @@ func (g *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 		if member == nil {
 			log.ZDebug(ctx, "GroupApplicationResponse", "member is nil")
 		} else {
-			if groupRequest.InviterUserID == "" {
-				if err = g.notification.MemberEnterNotification(ctx, req.GroupID, req.FromUserID); err != nil {
-					return nil, err
-				}
-			} else {
-				if err = g.notification.GroupApplicationAgreeMemberEnterNotification(ctx, req.GroupID, nil, groupRequest.InviterUserID, req.FromUserID); err != nil {
-					return nil, err
-				}
+			if err = g.notification.GroupApplicationAgreeMemberEnterNotification(ctx, req.GroupID, groupRequest.InviterUserID, req.FromUserID); err != nil {
+				return nil, err
 			}
 		}
 	case constant.GroupResponseRefuse:
@@ -1033,8 +1030,7 @@ func (g *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
 				log.ZWarn(ctx, "SetConversations", err, "UserIDs", resp.UserIDs, "conversation", conversation)
 			}
 		}()
-		notficationFlag := true
-		g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notficationFlag)
+		g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser})
 	}
 	if req.GroupInfoForSet.GroupName != "" {
 		num--
@@ -1095,7 +1091,7 @@ func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupI
 		return nil, err
 	}
 
-	updatedData, normalFlag, groupNameFlag, notificationFlag, err := UpdateGroupInfoExMap(ctx, req)
+	updatedData, err := UpdateGroupInfoExMap(ctx, req)
 	if len(updatedData) == 0 {
 		return &pbgroup.SetGroupInfoExResp{}, nil
 	}
@@ -1123,38 +1119,41 @@ func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupI
 		tips.OpUser = g.groupMemberDB2PB(opMember, 0)
 	}
 
-	if notificationFlag {
+	num := len(updatedData)
+
+	if req.Notification != nil {
+		num -= 3
+
 		if req.Notification.Value != "" {
-			conversation := &pbconv.ConversationReq{
-				ConversationID:   msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, req.GroupID),
-				ConversationType: constant.ReadGroupChatType,
-				GroupID:          req.GroupID,
-			}
+			func() {
+				conversation := &pbconv.ConversationReq{
+					ConversationID:   msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, req.GroupID),
+					ConversationType: constant.ReadGroupChatType,
+					GroupID:          req.GroupID,
+				}
 
-			resp, err := g.GetGroupMemberUserIDs(ctx, &pbgroup.GetGroupMemberUserIDsReq{GroupID: req.GroupID})
-			if err != nil {
-				log.ZWarn(ctx, "GetGroupMemberIDs is failed.", err)
-				return nil, err
-			}
+				resp, err := g.GetGroupMemberUserIDs(ctx, &pbgroup.GetGroupMemberUserIDsReq{GroupID: req.GroupID})
+				if err != nil {
+					log.ZWarn(ctx, "GetGroupMemberIDs is failed.", err)
+					return
+				}
 
-			conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.GroupNotification}
-			if err := g.conversationClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
-				log.ZWarn(ctx, "SetConversations", err, "UserIDs", resp.UserIDs, "conversation", conversation)
-			}
+				conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.GroupNotification}
+				if err := g.conversationClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
+					log.ZWarn(ctx, "SetConversations", err, "UserIDs", resp.UserIDs, "conversation", conversation)
+				}
+			}()
 
-			g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notificationFlag)
-		} else {
-			notificationFlag = false
-			g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notificationFlag)
+			g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser})
 		}
 	}
 
-	if groupNameFlag {
+	if req.GroupName != nil {
+		num--
 		g.notification.GroupInfoSetNameNotification(ctx, &sdkws.GroupInfoSetNameTips{Group: tips.Group, OpUser: tips.OpUser})
 	}
 
-	// if updatedData > 0, send the normal notification
-	if normalFlag {
+	if num > 0 {
 		g.notification.GroupInfoSetNotification(ctx, tips)
 	}
 
@@ -1375,7 +1374,7 @@ func (g *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGrou
 		if mcontext.GetOpUserID(ctx) == owner.UserID {
 			tips.OpUser = g.groupMemberDB2PB(owner, 0)
 		}
-		g.notification.GroupDismissedNotification(ctx, tips, req.SendMessage)
+		g.notification.GroupDismissedNotification(ctx, tips)
 	}
 	membersID, err := g.db.FindGroupMemberUserID(ctx, group.GroupID)
 	if err != nil {

internal/rpc/group/notification.go

@@ -22,8 +22,6 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
-	"go.mongodb.org/mongo-driver/mongo"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
@@ -43,6 +41,7 @@ import (
 	"github.com/openimsdk/tools/mcontext"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/openimsdk/tools/utils/stringutil"
+	"go.mongodb.org/mongo-driver/mongo"
 )
 
 // GroupApplicationReceiver
@@ -53,11 +52,11 @@ const (
 
 func NewNotificationSender(db controller.GroupDatabase, config *Config, userClient *rpcli.UserClient, msgClient *rpcli.MsgClient, conversationClient *rpcli.ConversationClient) *NotificationSender {
 	return &NotificationSender{
-		NotificationSender: notification.NewNotificationSender(&config.NotificationConfig,
-			notification.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+		NotificationSender: rpcclient.NewNotificationSender(&config.NotificationConfig,
+			rpcclient.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
 				return msgClient.SendMsg(ctx, req)
 			}),
-			notification.WithUserRpcClient(userClient.GetUserInfo),
+			rpcclient.WithUserRpcClient(userClient.GetUserInfo),
 		),
 		getUsersInfo: func(ctx context.Context, userIDs []string) ([]common_user.CommonUser, error) {
 			users, err := userClient.GetUsersInfo(ctx, userIDs)
@@ -74,7 +73,7 @@ func NewNotificationSender(db controller.GroupDatabase, config *Config, userClie
 }
 
 type NotificationSender struct {
-	*notification.NotificationSender
+	*rpcclient.NotificationSender
 	getUsersInfo       func(ctx context.Context, userIDs []string) ([]common_user.CommonUser, error)
 	db                 controller.GroupDatabase
 	config             *Config
@@ -234,12 +233,12 @@ func (g *NotificationSender) groupMemberDB2PB(member *model.GroupMember, appMang
 	return result, nil
 } */
 
-func (g *NotificationSender) fillOpUser(ctx context.Context, targetUser **sdkws.GroupMemberFullInfo, groupID string) (err error) {
-	return g.fillUserByUserID(ctx, mcontext.GetOpUserID(ctx), targetUser, groupID)
+func (g *NotificationSender) fillOpUser(ctx context.Context, opUser **sdkws.GroupMemberFullInfo, groupID string) (err error) {
+	return g.fillOpUserByUserID(ctx, mcontext.GetOpUserID(ctx), opUser, groupID)
 }
 
-func (g *NotificationSender) fillUserByUserID(ctx context.Context, userID string, targetUser **sdkws.GroupMemberFullInfo, groupID string) error {
-	if targetUser == nil {
+func (g *NotificationSender) fillOpUserByUserID(ctx context.Context, userID string, opUser **sdkws.GroupMemberFullInfo, groupID string) error {
+	if opUser == nil {
 		return errs.ErrInternalServer.WrapMsg("**sdkws.GroupMemberFullInfo is nil")
 	}
 	if groupID != "" {
@@ -253,7 +252,7 @@ func (g *NotificationSender) fillUserByUserID(ctx context.Context, userID string
 		} else {
 			member, err := g.db.TakeGroupMember(ctx, groupID, userID)
 			if err == nil {
-				*targetUser = g.groupMemberDB2PB(member, 0)
+				*opUser = g.groupMemberDB2PB(member, 0)
 			} else if !(errors.Is(err, mongo.ErrNoDocuments) || errs.ErrRecordNotFound.Is(err)) {
 				return err
 			}
@@ -263,8 +262,8 @@ func (g *NotificationSender) fillUserByUserID(ctx context.Context, userID string
 	if err != nil {
 		return err
 	}
-	if *targetUser == nil {
-		*targetUser = &sdkws.GroupMemberFullInfo{
+	if *opUser == nil {
+		*opUser = &sdkws.GroupMemberFullInfo{
 			GroupID:        groupID,
 			UserID:         userID,
 			Nickname:       user.Nickname,
@@ -272,11 +271,11 @@ func (g *NotificationSender) fillUserByUserID(ctx context.Context, userID string
 			OperatorUserID: userID,
 		}
 	} else {
-		if (*targetUser).Nickname == "" {
-			(*targetUser).Nickname = user.Nickname
+		if (*opUser).Nickname == "" {
+			(*opUser).Nickname = user.Nickname
 		}
-		if (*targetUser).FaceURL == "" {
-			(*targetUser).FaceURL = user.FaceURL
+		if (*opUser).FaceURL == "" {
+			(*opUser).FaceURL = user.FaceURL
 		}
 	}
 	return nil
@@ -309,7 +308,7 @@ func (g *NotificationSender) setSortVersion(ctx context.Context, version *uint64
 	}
 }
 
-func (g *NotificationSender) GroupCreatedNotification(ctx context.Context, tips *sdkws.GroupCreatedTips, SendMessage *bool) {
+func (g *NotificationSender) GroupCreatedNotification(ctx context.Context, tips *sdkws.GroupCreatedTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -320,7 +319,7 @@ func (g *NotificationSender) GroupCreatedNotification(ctx context.Context, tips
 		return
 	}
 	g.setVersion(ctx, &tips.GroupMemberVersion, &tips.GroupMemberVersionID, database.GroupMemberVersionName, tips.Group.GroupID)
-	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupCreatedNotification, tips, notification.WithSendMessage(SendMessage))
+	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupCreatedNotification, tips)
 }
 
 func (g *NotificationSender) GroupInfoSetNotification(ctx context.Context, tips *sdkws.GroupInfoSetTips) {
@@ -334,7 +333,7 @@ func (g *NotificationSender) GroupInfoSetNotification(ctx context.Context, tips
 		return
 	}
 	g.setVersion(ctx, &tips.GroupMemberVersion, &tips.GroupMemberVersionID, database.GroupMemberVersionName, tips.Group.GroupID)
-	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetNotification, tips, notification.WithRpcGetUserName())
+	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetNotification, tips, rpcclient.WithRpcGetUserName())
 }
 
 func (g *NotificationSender) GroupInfoSetNameNotification(ctx context.Context, tips *sdkws.GroupInfoSetNameTips) {
@@ -351,7 +350,7 @@ func (g *NotificationSender) GroupInfoSetNameNotification(ctx context.Context, t
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetNameNotification, tips)
 }
 
-func (g *NotificationSender) GroupInfoSetAnnouncementNotification(ctx context.Context, tips *sdkws.GroupInfoSetAnnouncementTips, sendMessage *bool) {
+func (g *NotificationSender) GroupInfoSetAnnouncementNotification(ctx context.Context, tips *sdkws.GroupInfoSetAnnouncementTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -362,7 +361,7 @@ func (g *NotificationSender) GroupInfoSetAnnouncementNotification(ctx context.Co
 		return
 	}
 	g.setVersion(ctx, &tips.GroupMemberVersion, &tips.GroupMemberVersionID, database.GroupMemberVersionName, tips.Group.GroupID)
-	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetAnnouncementNotification, tips, notification.WithRpcGetUserName(), notification.WithSendMessage(sendMessage))
+	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetAnnouncementNotification, tips, rpcclient.WithRpcGetUserName())
 }
 
 func (g *NotificationSender) JoinGroupApplicationNotification(ctx context.Context, req *pbgroup.JoinGroupReq) {
@@ -507,7 +506,7 @@ func (g *NotificationSender) GroupOwnerTransferredNotification(ctx context.Conte
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupOwnerTransferredNotification, tips)
 }
 
-func (g *NotificationSender) MemberKickedNotification(ctx context.Context, tips *sdkws.MemberKickedTips, SendMessage *bool) {
+func (g *NotificationSender) MemberKickedNotification(ctx context.Context, tips *sdkws.MemberKickedTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -518,7 +517,7 @@ func (g *NotificationSender) MemberKickedNotification(ctx context.Context, tips
 		return
 	}
 	g.setVersion(ctx, &tips.GroupMemberVersion, &tips.GroupMemberVersionID, database.GroupMemberVersionName, tips.Group.GroupID)
-	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.MemberKickedNotification, tips, notification.WithSendMessage(SendMessage))
+	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.MemberKickedNotification, tips)
 }
 
 func (g *NotificationSender) GroupApplicationAgreeMemberEnterNotification(ctx context.Context, groupID string, SendMessage *bool, invitedOpUserID string, entrantUserID ...string) error {
@@ -562,18 +561,20 @@ func (g *NotificationSender) groupApplicationAgreeMemberEnterNotification(ctx co
 		InvitedUserList: users,
 	}
 	opUserID := mcontext.GetOpUserID(ctx)
-	if err = g.fillUserByUserID(ctx, opUserID, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUserByUserID(ctx, opUserID, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return nil
 	}
-	if invitedOpUserID == opUserID {
+	switch {
+	case invitedOpUserID == "":
+	case invitedOpUserID == opUserID:
 		tips.InviterUser = tips.OpUser
-	} else {
-		if err = g.fillUserByUserID(ctx, invitedOpUserID, &tips.InviterUser, tips.Group.GroupID); err != nil {
+	default:
+		if err = g.fillOpUserByUserID(ctx, invitedOpUserID, &tips.InviterUser, tips.Group.GroupID); err != nil {
 			return err
 		}
 	}
 	g.setVersion(ctx, &tips.GroupMemberVersion, &tips.GroupMemberVersionID, database.GroupMemberVersionName, tips.Group.GroupID)
-	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.MemberInvitedNotification, tips, notification.WithSendMessage(SendMessage))
+	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.MemberInvitedNotification, tips)
 	return nil
 }
 
@@ -618,7 +619,7 @@ func (g *NotificationSender) MemberEnterNotification(ctx context.Context, groupI
 	return nil
 }
 
-func (g *NotificationSender) GroupDismissedNotification(ctx context.Context, tips *sdkws.GroupDismissedTips, SendMessage *bool) {
+func (g *NotificationSender) GroupDismissedNotification(ctx context.Context, tips *sdkws.GroupDismissedTips) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -628,7 +629,7 @@ func (g *NotificationSender) GroupDismissedNotification(ctx context.Context, tip
 	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return
 	}
-	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupDismissedNotification, tips, notification.WithSendMessage(SendMessage))
+	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupDismissedNotification, tips)
 }
 
 func (g *NotificationSender) GroupMemberMutedNotification(ctx context.Context, groupID, groupMemberUserID string, mutedSeconds uint32) {
@@ -785,7 +786,7 @@ func (g *NotificationSender) GroupMemberSetToAdminNotification(ctx context.Conte
 	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return
 	}
-	g.setSortVersion(ctx, &tips.GroupMemberVersion, &tips.GroupMemberVersionID, database.GroupMemberVersionName, tips.Group.GroupID, &tips.GroupSortVersion)
+	g.setVersion(ctx, &tips.GroupMemberVersion, &tips.GroupMemberVersionID, database.GroupMemberVersionName, tips.Group.GroupID)
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberSetToAdminNotification, tips)
 }
 
@@ -810,6 +811,6 @@ func (g *NotificationSender) GroupMemberSetToOrdinaryUserNotification(ctx contex
 	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return
 	}
-	g.setSortVersion(ctx, &tips.GroupMemberVersion, &tips.GroupMemberVersionID, database.GroupMemberVersionName, tips.Group.GroupID, &tips.GroupSortVersion)
+	g.setVersion(ctx, &tips.GroupMemberVersion, &tips.GroupMemberVersionID, database.GroupMemberVersionName, tips.Group.GroupID)
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberSetToOrdinaryUserNotification, tips)
 }

internal/rpc/group/sync.go

@@ -52,7 +52,7 @@ func (g *groupServer) GetFullJoinGroupIDs(ctx context.Context, req *pbgroup.GetF
 	if err != nil {
 		return nil, err
 	}
-	groupIDs, err := g.db.FindJoinGroupID(ctx, req.UserID)
+	groupIDs, err := s.db.FindJoinGroupID(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -68,8 +68,8 @@ func (g *groupServer) GetFullJoinGroupIDs(ctx context.Context, req *pbgroup.GetF
 	}, nil
 }
 
-func (g *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgroup.GetIncrementalGroupMemberReq) (*pbgroup.GetIncrementalGroupMemberResp, error) {
-	group, err := g.db.TakeGroup(ctx, req.GroupID)
+func (s *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgroup.GetIncrementalGroupMemberReq) (*pbgroup.GetIncrementalGroupMemberResp, error) {
+	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -89,7 +89,7 @@ func (g *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgrou
 		VersionID:     req.VersionID,
 		VersionNumber: req.Version,
 		Version: func(ctx context.Context, groupID string, version uint, limit int) (*model.VersionLog, error) {
-			vl, err := g.db.FindMemberIncrVersion(ctx, groupID, version, limit)
+			vl, err := s.db.FindMemberIncrVersion(ctx, groupID, version, limit)
 			if err != nil {
 				return nil, err
 			}
@@ -112,9 +112,9 @@ func (g *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgrou
 			}
 			return vl, nil
 		},
-		CacheMaxVersion: g.db.FindMaxGroupMemberVersionCache,
+		CacheMaxVersion: s.db.FindMaxGroupMemberVersionCache,
 		Find: func(ctx context.Context, ids []string) ([]*sdkws.GroupMemberFullInfo, error) {
-			return g.getGroupMembersInfo(ctx, req.GroupID, ids)
+			return s.getGroupMembersInfo(ctx, req.GroupID, ids)
 		},
 		Resp: func(version *model.VersionLog, delIDs []string, insertList, updateList []*sdkws.GroupMemberFullInfo, full bool) *pbgroup.GetIncrementalGroupMemberResp {
 			return &pbgroup.GetIncrementalGroupMemberResp{
@@ -133,15 +133,15 @@ func (g *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgrou
 		return nil, err
 	}
 	if resp.Full || hasGroupUpdate {
-		count, err := g.db.FindGroupMemberNum(ctx, group.GroupID)
+		count, err := s.db.FindGroupMemberNum(ctx, group.GroupID)
 		if err != nil {
 			return nil, err
 		}
-		owner, err := g.db.TakeGroupOwner(ctx, group.GroupID)
+		owner, err := s.db.TakeGroupOwner(ctx, group.GroupID)
 		if err != nil {
 			return nil, err
 		}
-		resp.Group = g.groupDB2PB(group, owner.UserID, count)
+		resp.Group = s.groupDB2PB(group, owner.UserID, count)
 	}
 	return resp, nil
 }
@@ -155,9 +155,9 @@ func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.
 		VersionKey:      req.UserID,
 		VersionID:       req.VersionID,
 		VersionNumber:   req.Version,
-		Version:         g.db.FindJoinIncrVersion,
-		CacheMaxVersion: g.db.FindMaxJoinGroupVersionCache,
-		Find:            g.getGroupsInfo,
+		Version:         s.db.FindJoinIncrVersion,
+		CacheMaxVersion: s.db.FindMaxJoinGroupVersionCache,
+		Find:            s.getGroupsInfo,
 		Resp: func(version *model.VersionLog, delIDs []string, insertList, updateList []*sdkws.GroupInfo, full bool) *pbgroup.GetIncrementalJoinGroupResp {
 			return &pbgroup.GetIncrementalJoinGroupResp{
 				VersionID: version.ID.Hex(),
@@ -171,23 +171,3 @@ func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.
 	}
 	return opt.Build()
 }
-
-func (g *groupServer) BatchGetIncrementalGroupMember(ctx context.Context, req *pbgroup.BatchGetIncrementalGroupMemberReq) (*pbgroup.BatchGetIncrementalGroupMemberResp, error) {
-	var num int
-	resp := make(map[string]*pbgroup.GetIncrementalGroupMemberResp)
-	for _, memberReq := range req.ReqList {
-		if _, ok := resp[memberReq.GroupID]; ok {
-			continue
-		}
-		memberResp, err := g.GetIncrementalGroupMember(ctx, memberReq)
-		if err != nil {
-			return nil, err
-		}
-		resp[memberReq.GroupID] = memberResp
-		num += len(memberResp.Insert) + len(memberResp.Update) + len(memberResp.Delete)
-		if num >= versionSyncLimit {
-			break
-		}
-	}
-	return &pbgroup.BatchGetIncrementalGroupMemberResp{RespList: resp}, nil
-}

internal/rpc/msg/notification.go

@@ -23,11 +23,11 @@ import (
 )
 
 type MsgNotificationSender struct {
-	*notification.NotificationSender
+	*rpcclient.NotificationSender
 }
 
-func NewMsgNotificationSender(config *Config, opts ...notification.NotificationSenderOptions) *MsgNotificationSender {
-	return &MsgNotificationSender{notification.NewNotificationSender(&config.NotificationConfig, opts...)}
+func NewMsgNotificationSender(config *Config, opts ...rpcclient.NotificationSenderOptions) *MsgNotificationSender {
+	return &MsgNotificationSender{rpcclient.NewNotificationSender(&config.NotificationConfig, opts...)}
 }
 
 func (m *MsgNotificationSender) UserDeleteMsgsNotification(ctx context.Context, userID, conversationID string, seqs []int64) {

internal/rpc/msg/server.go

@@ -17,23 +17,22 @@ package msg
 import (
 	"context"
 
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/mcache"
-	"github.com/openimsdk/open-im-server/v3/pkg/dbbuild"
-	"github.com/openimsdk/open-im-server/v3/pkg/mqbuild"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
+	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/redisutil"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/open-im-server/v3/pkg/notification"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpccache"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/protocol/msg"
-	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/discovery"
 	"google.golang.org/grpc"
 )
@@ -58,14 +57,14 @@ type Config struct {
 // MsgServer encapsulates dependencies required for message handling.
 type msgServer struct {
 	msg.UnimplementedMsgServer
-	RegisterCenter         discovery.Conn                   // Service discovery registry for service registration.
+	RegisterCenter         discovery.SvcDiscoveryRegistry   // Service discovery registry for service registration.
 	MsgDatabase            controller.CommonMsgDatabase     // Interface for message database operations.
 	UserLocalCache         *rpccache.UserLocalCache         // Local cache for user data.
 	FriendLocalCache       *rpccache.FriendLocalCache       // Local cache for friend data.
 	GroupLocalCache        *rpccache.GroupLocalCache        // Local cache for group data.
 	ConversationLocalCache *rpccache.ConversationLocalCache // Local cache for conversation data.
 	Handlers               MessageInterceptorChain          // Chain of handlers for processing messages.
-	notificationSender     *notification.NotificationSender // RPC client for sending notifications.
+	notificationSender     *rpcclient.NotificationSender    // RPC client for sending notifications.
 	msgNotificationSender  *MsgNotificationSender           // RPC client for sending msg notifications.
 	config                 *Config                          // Global configuration settings.
 	webhookClient          *webhook.Client
@@ -77,18 +76,12 @@ func (m *msgServer) addInterceptorHandler(interceptorFunc ...MessageInterceptorF
 
 }
 
-func Start(ctx context.Context, config *Config, client discovery.Conn, server grpc.ServiceRegistrar) error {
-	builder := mqbuild.NewBuilder(&config.KafkaConfig)
-	redisProducer, err := builder.GetTopicProducer(ctx, config.KafkaConfig.ToRedisTopic)
+func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
+	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
 	if err != nil {
 		return err
 	}
-	dbb := dbbuild.NewBuilder(&config.MongodbConfig, &config.RedisConfig)
-	mgocli, err := dbb.Mongo(ctx)
-	if err != nil {
-		return err
-	}
-	rdb, err := dbb.Redis(ctx)
+	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
 	if err != nil {
 		return err
 	}
@@ -96,16 +89,7 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 	if err != nil {
 		return err
 	}
-	var msgModel cache.MsgCache
-	if rdb == nil {
-		cm, err := mgo.NewCacheMgo(mgocli.GetDB())
-		if err != nil {
-			return err
-		}
-		msgModel = mcache.NewMsgCache(cm, msgDocModel)
-	} else {
-		msgModel = redis.NewMsgCache(rdb, msgDocModel)
-	}
+	msgModel := redis.NewMsgCache(rdb, msgDocModel)
 	seqConversation, err := mgo.NewSeqConversationMongo(mgocli.GetDB())
 	if err != nil {
 		return err
@@ -116,6 +100,10 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 		return err
 	}
 	seqUserCache := redis.NewSeqUserCacheRedis(rdb, seqUser)
+	msgDatabase, err := controller.NewCommonMsgDatabase(msgDocModel, msgModel, seqUserCache, seqConversationCache, &config.KafkaConfig)
+	if err != nil {
+		return err
+	}
 	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
 	if err != nil {
 		return err
@@ -133,7 +121,6 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 		return err
 	}
 	conversationClient := rpcli.NewConversationClient(conversationConn)
-	msgDatabase := controller.NewCommonMsgDatabase(msgDocModel, msgModel, seqUserCache, seqConversationCache, redisProducer)
 	s := &msgServer{
 		MsgDatabase:            msgDatabase,
 		RegisterCenter:         client,
@@ -146,8 +133,8 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 		conversationClient:     conversationClient,
 	}
 
-	s.notificationSender = notification.NewNotificationSender(&config.NotificationConfig, notification.WithLocalSendMsg(s.SendMsg))
-	s.msgNotificationSender = NewMsgNotificationSender(config, notification.WithLocalSendMsg(s.SendMsg))
+	s.notificationSender = rpcclient.NewNotificationSender(&config.NotificationConfig, rpcclient.WithLocalSendMsg(s.SendMsg))
+	s.msgNotificationSender = NewMsgNotificationSender(config, rpcclient.WithLocalSendMsg(s.SendMsg))
 
 	msg.RegisterMsgServer(server, s)
 

internal/rpc/relation/friend.go

@@ -17,24 +17,26 @@ package relation
 import (
 	"context"
 
-	"github.com/openimsdk/open-im-server/v3/pkg/dbbuild"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
 	"github.com/openimsdk/tools/mq/memamq"
 
-	"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/convert"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
+	"github.com/openimsdk/tools/db/redisutil"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/relation"
 	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/utils/datautil"
@@ -46,7 +48,7 @@ type friendServer struct {
 	db                 controller.FriendDatabase
 	blackDatabase      controller.BlackDatabase
 	notificationSender *FriendNotificationSender
-	RegisterCenter     discovery.Conn
+	RegisterCenter     discovery.SvcDiscoveryRegistry
 	config             *Config
 	webhookClient      *webhook.Client
 	queue              *memamq.MemoryQueue
@@ -65,13 +67,12 @@ type Config struct {
 	Discovery          config.Discovery
 }
 
-func Start(ctx context.Context, config *Config, client discovery.Conn, server grpc.ServiceRegistrar) error {
-	dbb := dbbuild.NewBuilder(&config.MongodbConfig, &config.RedisConfig)
-	mgocli, err := dbb.Mongo(ctx)
+func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
+	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
 	if err != nil {
 		return err
 	}
-	rdb, err := dbb.Redis(ctx)
+	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
 	if err != nil {
 		return err
 	}
@@ -114,12 +115,12 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 		db: controller.NewFriendDatabase(
 			friendMongoDB,
 			friendRequestMongoDB,
-			redis.NewFriendCacheRedis(rdb, &config.LocalCacheConfig, friendMongoDB),
+			redis.NewFriendCacheRedis(rdb, &config.LocalCacheConfig, friendMongoDB, redis.GetRocksCacheOptions()),
 			mgocli.GetTx(),
 		),
 		blackDatabase: controller.NewBlackDatabase(
 			blackMongoDB,
-			redis.NewBlackCacheRedis(rdb, &config.LocalCacheConfig, blackMongoDB),
+			redis.NewBlackCacheRedis(rdb, &config.LocalCacheConfig, blackMongoDB, redis.GetRocksCacheOptions()),
 		),
 		notificationSender: notificationSender,
 		RegisterCenter:     client,

internal/rpc/relation/notification.go

@@ -16,7 +16,6 @@ package relation
 
 import (
 	"context"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"github.com/openimsdk/protocol/msg"
 
@@ -37,7 +36,7 @@ import (
 )
 
 type FriendNotificationSender struct {
-	*notification.NotificationSender
+	*rpcclient.NotificationSender
 	// Target not found err
 	getUsersInfo func(ctx context.Context, userIDs []string) ([]common_user.CommonUser, error)
 	// db controller
@@ -90,7 +89,7 @@ func WithRpcFunc(
 
 func NewFriendNotificationSender(conf *config.Notification, msgClient *rpcli.MsgClient, opts ...friendNotificationSenderOptions) *FriendNotificationSender {
 	f := &FriendNotificationSender{
-		NotificationSender: notification.NewNotificationSender(conf, notification.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+		NotificationSender: rpcclient.NewNotificationSender(conf, rpcclient.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
 			return msgClient.SendMsg(ctx, req)
 		})),
 	}

internal/rpc/third/third.go

@@ -17,13 +17,8 @@ package third
 import (
 	"context"
 	"fmt"
-	"time"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/mcache"
-	"github.com/openimsdk/open-im-server/v3/pkg/dbbuild"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
-	"github.com/openimsdk/tools/s3/disable"
+	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
@@ -34,6 +29,8 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/protocol/third"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/redisutil"
 	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/s3"
 	"github.com/openimsdk/tools/s3/cos"
@@ -63,17 +60,15 @@ type Config struct {
 	Discovery          config.Discovery
 }
 
-func Start(ctx context.Context, config *Config, client discovery.Conn, server grpc.ServiceRegistrar) error {
-	dbb := dbbuild.NewBuilder(&config.MongodbConfig, &config.RedisConfig)
-	mgocli, err := dbb.Mongo(ctx)
+func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
+	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
 	if err != nil {
 		return err
 	}
-	rdb, err := dbb.Redis(ctx)
+	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
 	if err != nil {
 		return err
 	}
-
 	logdb, err := mgo.NewLogMongo(mgocli.GetDB())
 	if err != nil {
 		return err
@@ -82,31 +77,15 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 	if err != nil {
 		return err
 	}
-	var thirdCache cache.ThirdCache
-	if rdb == nil {
-		tc, err := mgo.NewCacheMgo(mgocli.GetDB())
-		if err != nil {
-			return err
-		}
-		thirdCache = mcache.NewThirdCache(tc)
-	} else {
-		thirdCache = redis.NewThirdCache(rdb)
-	}
+
 	// Select the oss method according to the profile policy
-	var o s3.Interface
-	switch enable := config.RpcConfig.Object.Enable; enable {
+	enable := config.RpcConfig.Object.Enable
+	var (
+		o s3.Interface
+	)
+	switch enable {
 	case "minio":
-		var minioCache minio.Cache
-		if rdb == nil {
-			mc, err := mgo.NewCacheMgo(mgocli.GetDB())
-			if err != nil {
-				return err
-			}
-			minioCache = mcache.NewMinioCache(mc)
-		} else {
-			minioCache = redis.NewMinioCache(rdb)
-		}
-		o, err = minio.NewMinio(ctx, minioCache, *config.MinioConfig.Build())
+		o, err = minio.NewMinio(ctx, redis.NewMinioCache(rdb), *config.MinioConfig.Build())
 	case "cos":
 		o, err = cos.NewCos(*config.RpcConfig.Object.Cos.Build())
 	case "oss":
@@ -115,8 +94,6 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 		o, err = kodo.NewKodo(*config.RpcConfig.Object.Kodo.Build())
 	case "aws":
 		o, err = aws.NewAws(*config.RpcConfig.Object.Aws.Build())
-	case "":
-		o = disable.NewDisable()
 	default:
 		err = fmt.Errorf("invalid object enable: %s", enable)
 	}
@@ -129,7 +106,7 @@ func Start(ctx context.Context, config *Config, client discovery.Conn, server gr
 	}
 	localcache.InitLocalCache(&config.LocalCacheConfig)
 	third.RegisterThirdServer(server, &thirdServer{
-		thirdDatabase: controller.NewThirdDatabase(thirdCache, logdb),
+		thirdDatabase: controller.NewThirdDatabase(redis.NewThirdCache(rdb), logdb),
 		s3dataBase:    controller.NewS3Database(rdb, o, s3db),
 		defaultExpire: time.Hour * 24 * 7,
 		config:        config,

internal/rpc/user/notification.go

@@ -16,7 +16,6 @@ package user
 
 import (
 	"context"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"github.com/openimsdk/protocol/msg"
 
@@ -30,7 +29,7 @@ import (
 )
 
 type UserNotificationSender struct {
-	*notification.NotificationSender
+	*rpcclient.NotificationSender
 	getUsersInfo func(ctx context.Context, userIDs []string) ([]common_user.CommonUser, error)
 	// db controller
 	db controller.UserDatabase
@@ -64,7 +63,7 @@ func WithUserFunc(
 
 func NewUserNotificationSender(config *Config, msgClient *rpcli.MsgClient, opts ...userNotificationSenderOptions) *UserNotificationSender {
 	f := &UserNotificationSender{
-		NotificationSender: notification.NewNotificationSender(&config.NotificationConfig, notification.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+		NotificationSender: rpcclient.NewNotificationSender(&config.NotificationConfig, rpcclient.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
 			return msgClient.SendMsg(ctx, req)
 		})),
 	}

internal/tools/cron_task.go

@@ -1,37 +1,47 @@
-package cron
+package tools
 
 import (
 	"context"
 
 	"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"
 	pbconversation "github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/protocol/third"
-	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/discovery/etcd"
 
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/mw"
+	"github.com/openimsdk/tools/utils/runtimeenv"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/mcontext"
-	"github.com/openimsdk/tools/utils/runtimeenv"
 	"github.com/robfig/cron/v3"
-	"google.golang.org/grpc"
 )
 
-type Config struct {
+type CronTaskConfig struct {
 	CronTask  config.CronTask
 	Share     config.Share
 	Discovery config.Discovery
+
+	runTimeEnv string
 }
 
-func Start(ctx context.Context, conf *Config, client discovery.Conn, service grpc.ServiceRegistrar) error {
-	log.CInfo(ctx, "CRON-TASK server is initializing", "runTimeEnv", runtimeenv.RuntimeEnvironment(), "chatRecordsClearTime", conf.CronTask.CronExecuteTime, "msgDestructTime", conf.CronTask.RetainChatRecords)
+func Start(ctx context.Context, conf *CronTaskConfig) error {
+	conf.runTimeEnv = runtimeenv.RuntimeEnvironment()
+
+	log.CInfo(ctx, "CRON-TASK server is initializing", "runTimeEnv", conf.runTimeEnv, "chatRecordsClearTime", conf.CronTask.CronExecuteTime, "msgDestructTime", conf.CronTask.RetainChatRecords)
 	if conf.CronTask.RetainChatRecords < 1 {
-		log.ZInfo(ctx, "disable cron")
-		<-ctx.Done()
-		return nil
+		return errs.New("msg destruct time must be greater than 1").Wrap()
 	}
+	client, err := kdisc.NewDiscoveryRegister(&conf.Discovery, conf.runTimeEnv, nil)
+	if err != nil {
+		return errs.WrapMsg(err, "failed to register discovery service")
+	}
+	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()))
 	ctx = mcontext.SetOpUserID(ctx, conf.Share.IMAdminUserID[0])
 
 	msgConn, err := client.GetConn(ctx, conf.Discovery.RpcService.Msg)
@@ -78,15 +88,13 @@ func Start(ctx context.Context, conf *Config, client discovery.Conn, service grp
 	}
 	log.ZDebug(ctx, "start cron task", "CronExecuteTime", conf.CronTask.CronExecuteTime)
 	srv.cron.Start()
-	log.ZDebug(ctx, "cron task server is running")
 	<-ctx.Done()
-	log.ZDebug(ctx, "cron task server is shutting down")
 	return nil
 }
 
 type cronServer struct {
 	ctx                context.Context
-	config             *Config
+	config             *CronTaskConfig
 	cron               *cron.Cron
 	msgClient          msg.MsgClient
 	conversationClient pbconversation.ConversationClient

internal/tools/msg.go

@@ -1,13 +1,12 @@
-package cron
+package tools
 
 import (
 	"fmt"
-	"os"
-	"time"
-
 	"github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
+	"os"
+	"time"
 )
 
 func (c *cronServer) deleteMsg() {

internal/tools/s3.go

@@ -1,13 +1,12 @@
-package cron
+package tools
 
 import (
 	"fmt"
-	"os"
-	"time"
-
 	"github.com/openimsdk/protocol/third"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
+	"os"
+	"time"
 )
 
 func (c *cronServer) clearS3() {

internal/tools/user_msg.go

@@ -1,13 +1,12 @@
-package cron
+package tools
 
 import (
 	"fmt"
-	"os"
-	"time"
-
 	pbconversation "github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
+	"os"
+	"time"
 )
 
 func (c *cronServer) clearUserMsg() {

magefile.go

@@ -4,23 +4,14 @@
 package main
 
 import (
-	"flag"
-	"os"
-
 	"github.com/openimsdk/gomake/mageutil"
+	"os"
 )
 
 var Default = Build
 
 func Build() {
-	flag.Parse()
-
-	bin := flag.Args()
-	if len(bin) != 0 {
-		bin = bin[1:]
-	}
-
-	mageutil.Build(bin)
+	mageutil.Build()
 }
 
 func Start() {

pkg/authverify/token.go

@@ -51,15 +51,15 @@ func CheckSystemAccount(ctx context.Context, level int32) bool {
 }
 
 const (
-	CtxAdminUserIDsKey = "CtxAdminUserIDsKey"
+	CtxIsAdminKey = "CtxIsAdminKey"
 )
 
 func WithIMAdminUserIDs(ctx context.Context, imAdminUserID []string) context.Context {
-	return context.WithValue(ctx, CtxAdminUserIDsKey, imAdminUserID)
+	return context.WithValue(ctx, CtxIsAdminKey, imAdminUserID)
 }
 
 func GetIMAdminUserIDs(ctx context.Context) []string {
-	imAdminUserID, _ := ctx.Value(CtxAdminUserIDsKey).([]string)
+	imAdminUserID, _ := ctx.Value(CtxIsAdminKey).([]string)
 	return imAdminUserID
 }
 

pkg/common/cmd/api.go

@@ -19,7 +19,6 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/internal/api"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
 	"github.com/spf13/cobra"
@@ -33,7 +32,7 @@ type ApiCmd struct {
 }
 
 func NewApiCmd() *ApiCmd {
-	var apiConfig api.Config
+	apiConfig := api.Config{AllConfig: &config.AllConfig{}}
 	ret := &ApiCmd{apiConfig: &apiConfig}
 	ret.configMap = map[string]any{
 		config.DiscoveryConfigFilename:          &apiConfig.Discovery,
@@ -62,7 +61,7 @@ func NewApiCmd() *ApiCmd {
 	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)
+		apiConfig.ConfigPath = ret.configPath
 		return ret.runE()
 	}
 	return ret
@@ -73,22 +72,5 @@ func (a *ApiCmd) Exec() error {
 }
 
 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,
-		&prometheus,
-		a.apiConfig.API.Api.ListenIP, "",
-		a.apiConfig.API.Prometheus.AutoSetPorts,
-		nil, int(a.apiConfig.Index),
-		a.apiConfig.Discovery.RpcService.MessageGateway,
-		&a.apiConfig.Notification,
-		a.apiConfig,
-		[]string{},
-		[]string{},
-		api.Start,
-	)
+	return api.Start(a.ctx, a.Index(), a.apiConfig)
 }

pkg/common/cmd/auth.go

@@ -38,7 +38,6 @@ func NewAuthRpcCmd() *AuthRpcCmd {
 	ret.configMap = map[string]any{
 		config.OpenIMRPCAuthCfgFileName: &authConfig.RpcConfig,
 		config.RedisConfigFileName:      &authConfig.RedisConfig,
-		config.MongodbConfigFileName:    &authConfig.MongoConfig,
 		config.ShareFileName:            &authConfig.Share,
 		config.DiscoveryConfigFilename:  &authConfig.Discovery,
 	}

pkg/common/cmd/cron_task.go

@@ -17,9 +17,8 @@ package cmd
 import (
 	"context"
 
-	"github.com/openimsdk/open-im-server/v3/internal/tools/cron"
+	"github.com/openimsdk/open-im-server/v3/internal/tools"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
 	"github.com/spf13/cobra"
@@ -29,11 +28,11 @@ type CronTaskCmd struct {
 	*RootCmd
 	ctx            context.Context
 	configMap      map[string]any
-	cronTaskConfig *cron.Config
+	cronTaskConfig *tools.CronTaskConfig
 }
 
 func NewCronTaskCmd() *CronTaskCmd {
-	var cronTaskConfig cron.Config
+	var cronTaskConfig tools.CronTaskConfig
 	ret := &CronTaskCmd{cronTaskConfig: &cronTaskConfig}
 	ret.configMap = map[string]any{
 		config.OpenIMCronTaskCfgFileName: &cronTaskConfig.CronTask,
@@ -53,18 +52,5 @@ func (a *CronTaskCmd) Exec() error {
 }
 
 func (a *CronTaskCmd) runE() error {
-	var prometheus config.Prometheus
-	return startrpc.Start(
-		a.ctx, &a.cronTaskConfig.Discovery,
-		&prometheus,
-		"", "",
-		true,
-		nil, 0,
-		"",
-		nil,
-		a.cronTaskConfig,
-		[]string{},
-		[]string{},
-		cron.Start,
-	)
+	return tools.Start(a.ctx, a.cronTaskConfig)
 }

pkg/common/cmd/msg_gateway.go

@@ -19,7 +19,6 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/internal/msggateway"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 
 	"github.com/openimsdk/tools/system/program"
@@ -56,20 +55,5 @@ func (m *MsgGatewayCmd) Exec() error {
 }
 
 func (m *MsgGatewayCmd) runE() error {
-	m.msgGatewayConfig.Index = config.Index(m.Index())
-	rpc := m.msgGatewayConfig.MsgGateway.RPC
-	var prometheus config.Prometheus
-	return startrpc.Start(
-		m.ctx, &m.msgGatewayConfig.Discovery,
-		&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,
-	)
+	return msggateway.Start(m.ctx, m.Index(), m.msgGatewayConfig)
 }

pkg/common/cmd/msg_transfer.go

@@ -19,7 +19,6 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/internal/msgtransfer"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
 	"github.com/spf13/cobra"
@@ -57,19 +56,5 @@ func (m *MsgTransferCmd) Exec() error {
 }
 
 func (m *MsgTransferCmd) runE() error {
-	m.msgTransferConfig.Index = config.Index(m.Index())
-	var prometheus config.Prometheus
-	return startrpc.Start(
-		m.ctx, &m.msgTransferConfig.Discovery,
-		&prometheus,
-		"", "",
-		true,
-		nil, int(m.msgTransferConfig.Index),
-		"",
-		nil,
-		m.msgTransferConfig,
-		[]string{},
-		[]string{},
-		msgtransfer.Start,
-	)
+	return msgtransfer.Start(m.ctx, m.Index(), m.msgTransferConfig)
 }

pkg/common/cmd/push.go

@@ -38,7 +38,6 @@ func NewPushRpcCmd() *PushRpcCmd {
 	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,
@@ -49,7 +48,7 @@ func NewPushRpcCmd() *PushRpcCmd {
 	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())
+		ret.pushConfig.FcmConfigPath = ret.ConfigPath()
 		return ret.runE()
 	}
 	return ret

pkg/common/cmd/root.go

@@ -12,6 +12,7 @@ import (
 	"github.com/openimsdk/tools/discovery/etcd"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/utils/runtimeenv"
 	"github.com/spf13/cobra"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
@@ -85,12 +86,14 @@ func (r *RootCmd) initEtcd() error {
 		return err
 	}
 	disConfig := config.Discovery{}
-	err = config.Load(configDirectory, config.DiscoveryConfigFilename, config.EnvPrefixMap[config.DiscoveryConfigFilename], &disConfig)
+	env := runtimeenv.RuntimeEnvironment()
+	err = config.Load(configDirectory, config.DiscoveryConfigFilename, config.EnvPrefixMap[config.DiscoveryConfigFilename],
+		env, &disConfig)
 	if err != nil {
 		return err
 	}
 	if disConfig.Enable == config.ETCD {
-		discov, _ := kdisc.NewDiscoveryRegister(&disConfig, nil)
+		discov, _ := kdisc.NewDiscoveryRegister(&disConfig, env, nil)
 		r.etcdClient = discov.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
 	}
 	return nil
@@ -122,16 +125,18 @@ func (r *RootCmd) initializeConfiguration(cmd *cobra.Command, opts *CmdOpts) err
 		return err
 	}
 
+	runtimeEnv := runtimeenv.RuntimeEnvironment()
+
 	// 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)
+		err := config.Load(configDirectory, configFileName, config.EnvPrefixMap[configFileName], runtimeEnv, configStruct)
 		if err != nil {
 			return err
 		}
 	}
 	// Load common log configuration file
-	return config.Load(configDirectory, config.LogConfigFileName, config.EnvPrefixMap[config.LogConfigFileName], &r.log)
+	return config.Load(configDirectory, config.LogConfigFileName, config.EnvPrefixMap[config.LogConfigFileName], runtimeEnv, &r.log)
 }
 
 func (r *RootCmd) updateConfigFromEtcd(opts *CmdOpts) error {
@@ -203,6 +208,7 @@ func (r *RootCmd) applyOptions(opts ...func(*CmdOpts)) *CmdOpts {
 
 func (r *RootCmd) initializeLogger(cmdOpts *CmdOpts) error {
 	err := log.InitLoggerFromConfig(
+
 		cmdOpts.loggerPrefixName,
 		r.processName,
 		"", "",

pkg/common/config/config.go

@@ -18,9 +18,9 @@ import (
 	"strings"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/kafka"
 	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/db/redisutil"
-	"github.com/openimsdk/tools/mq/kafka"
 	"github.com/openimsdk/tools/s3/aws"
 	"github.com/openimsdk/tools/s3/cos"
 	"github.com/openimsdk/tools/s3/kodo"
@@ -28,309 +28,339 @@ import (
 	"github.com/openimsdk/tools/s3/oss"
 )
 
-const StructTagName = "yaml"
-
-type Path string
-
-type Index int
-
 type CacheConfig struct {
-	Topic         string `yaml:"topic"`
-	SlotNum       int    `yaml:"slotNum"`
-	SlotSize      int    `yaml:"slotSize"`
-	SuccessExpire int    `yaml:"successExpire"`
-	FailedExpire  int    `yaml:"failedExpire"`
+	Topic         string `mapstructure:"topic"`
+	SlotNum       int    `mapstructure:"slotNum"`
+	SlotSize      int    `mapstructure:"slotSize"`
+	SuccessExpire int    `mapstructure:"successExpire"`
+	FailedExpire  int    `mapstructure:"failedExpire"`
 }
 
 type LocalCache struct {
-	User         CacheConfig `yaml:"user"`
-	Group        CacheConfig `yaml:"group"`
-	Friend       CacheConfig `yaml:"friend"`
-	Conversation CacheConfig `yaml:"conversation"`
+	User         CacheConfig `mapstructure:"user"`
+	Group        CacheConfig `mapstructure:"group"`
+	Friend       CacheConfig `mapstructure:"friend"`
+	Conversation CacheConfig `mapstructure:"conversation"`
 }
 
 type Log struct {
-	StorageLocation     string `yaml:"storageLocation"`
-	RotationTime        uint   `yaml:"rotationTime"`
-	RemainRotationCount uint   `yaml:"remainRotationCount"`
-	RemainLogLevel      int    `yaml:"remainLogLevel"`
-	IsStdout            bool   `yaml:"isStdout"`
-	IsJson              bool   `yaml:"isJson"`
-	IsSimplify          bool   `yaml:"isSimplify"`
-	WithStack           bool   `yaml:"withStack"`
+	StorageLocation     string `mapstructure:"storageLocation"`
+	RotationTime        uint   `mapstructure:"rotationTime"`
+	RemainRotationCount uint   `mapstructure:"remainRotationCount"`
+	RemainLogLevel      int    `mapstructure:"remainLogLevel"`
+	IsStdout            bool   `mapstructure:"isStdout"`
+	IsJson              bool   `mapstructure:"isJson"`
+	IsSimplify          bool   `mapstructure:"isSimplify"`
+	WithStack           bool   `mapstructure:"withStack"`
 }
 
 type Minio struct {
-	Bucket          string `yaml:"bucket"`
-	AccessKeyID     string `yaml:"accessKeyID"`
-	SecretAccessKey string `yaml:"secretAccessKey"`
-	SessionToken    string `yaml:"sessionToken"`
-	InternalAddress string `yaml:"internalAddress"`
-	ExternalAddress string `yaml:"externalAddress"`
-	PublicRead      bool   `yaml:"publicRead"`
+	Bucket          string `mapstructure:"bucket"`
+	AccessKeyID     string `mapstructure:"accessKeyID"`
+	SecretAccessKey string `mapstructure:"secretAccessKey"`
+	SessionToken    string `mapstructure:"sessionToken"`
+	InternalAddress string `mapstructure:"internalAddress"`
+	ExternalAddress string `mapstructure:"externalAddress"`
+	PublicRead      bool   `mapstructure:"publicRead"`
 }
 
 type Mongo struct {
-	URI         string   `yaml:"uri"`
-	Address     []string `yaml:"address"`
-	Database    string   `yaml:"database"`
-	Username    string   `yaml:"username"`
-	Password    string   `yaml:"password"`
-	AuthSource  string   `yaml:"authSource"`
-	MaxPoolSize int      `yaml:"maxPoolSize"`
-	MaxRetry    int      `yaml:"maxRetry"`
+	URI         string   `mapstructure:"uri"`
+	Address     []string `mapstructure:"address"`
+	Database    string   `mapstructure:"database"`
+	Username    string   `mapstructure:"username"`
+	Password    string   `mapstructure:"password"`
+	AuthSource  string   `mapstructure:"authSource"`
+	MaxPoolSize int      `mapstructure:"maxPoolSize"`
+	MaxRetry    int      `mapstructure:"maxRetry"`
 }
 type Kafka struct {
-	Username           string   `yaml:"username"`
-	Password           string   `yaml:"password"`
-	ProducerAck        string   `yaml:"producerAck"`
-	CompressType       string   `yaml:"compressType"`
-	Address            []string `yaml:"address"`
-	ToRedisTopic       string   `yaml:"toRedisTopic"`
-	ToMongoTopic       string   `yaml:"toMongoTopic"`
-	ToPushTopic        string   `yaml:"toPushTopic"`
-	ToOfflinePushTopic string   `yaml:"toOfflinePushTopic"`
-	ToRedisGroupID     string   `yaml:"toRedisGroupID"`
-	ToMongoGroupID     string   `yaml:"toMongoGroupID"`
-	ToPushGroupID      string   `yaml:"toPushGroupID"`
-	ToOfflineGroupID   string   `yaml:"toOfflinePushGroupID"`
+	Username           string   `mapstructure:"username"`
+	Password           string   `mapstructure:"password"`
+	ProducerAck        string   `mapstructure:"producerAck"`
+	CompressType       string   `mapstructure:"compressType"`
+	Address            []string `mapstructure:"address"`
+	ToRedisTopic       string   `mapstructure:"toRedisTopic"`
+	ToMongoTopic       string   `mapstructure:"toMongoTopic"`
+	ToPushTopic        string   `mapstructure:"toPushTopic"`
+	ToOfflinePushTopic string   `mapstructure:"toOfflinePushTopic"`
+	ToRedisGroupID     string   `mapstructure:"toRedisGroupID"`
+	ToMongoGroupID     string   `mapstructure:"toMongoGroupID"`
+	ToPushGroupID      string   `mapstructure:"toPushGroupID"`
+	ToOfflineGroupID   string   `mapstructure:"toOfflinePushGroupID"`
 
-	Tls TLSConfig `yaml:"tls"`
+	Tls TLSConfig `mapstructure:"tls"`
 }
 type TLSConfig struct {
-	EnableTLS          bool   `yaml:"enableTLS"`
-	CACrt              string `yaml:"caCrt"`
-	ClientCrt          string `yaml:"clientCrt"`
-	ClientKey          string `yaml:"clientKey"`
-	ClientKeyPwd       string `yaml:"clientKeyPwd"`
-	InsecureSkipVerify bool   `yaml:"insecureSkipVerify"`
+	EnableTLS          bool   `mapstructure:"enableTLS"`
+	CACrt              string `mapstructure:"caCrt"`
+	ClientCrt          string `mapstructure:"clientCrt"`
+	ClientKey          string `mapstructure:"clientKey"`
+	ClientKeyPwd       string `mapstructure:"clientKeyPwd"`
+	InsecureSkipVerify bool   `mapstructure:"insecureSkipVerify"`
 }
 
 type API struct {
 	Api struct {
-		ListenIP         string `yaml:"listenIP"`
-		Ports            []int  `yaml:"ports"`
-		CompressionLevel int    `yaml:"compressionLevel"`
-	} `yaml:"api"`
+		ListenIP         string `mapstructure:"listenIP"`
+		Ports            []int  `mapstructure:"ports"`
+		CompressionLevel int    `mapstructure:"compressionLevel"`
+	} `mapstructure:"api"`
 	Prometheus struct {
-		Enable       bool   `yaml:"enable"`
-		AutoSetPorts bool   `yaml:"autoSetPorts"`
-		Ports        []int  `yaml:"ports"`
-		GrafanaURL   string `yaml:"grafanaURL"`
-	} `yaml:"prometheus"`
+		Enable       bool   `mapstructure:"enable"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+		GrafanaURL   string `mapstructure:"grafanaURL"`
+	} `mapstructure:"prometheus"`
 }
 
 type CronTask struct {
-	CronExecuteTime   string   `yaml:"cronExecuteTime"`
-	RetainChatRecords int      `yaml:"retainChatRecords"`
-	FileExpireTime    int      `yaml:"fileExpireTime"`
-	DeleteObjectType  []string `yaml:"deleteObjectType"`
+	CronExecuteTime   string   `mapstructure:"cronExecuteTime"`
+	RetainChatRecords int      `mapstructure:"retainChatRecords"`
+	FileExpireTime    int      `mapstructure:"fileExpireTime"`
+	DeleteObjectType  []string `mapstructure:"deleteObjectType"`
 }
 
 type OfflinePushConfig struct {
-	Enable bool   `yaml:"enable"`
-	Title  string `yaml:"title"`
-	Desc   string `yaml:"desc"`
-	Ext    string `yaml:"ext"`
+	Enable bool   `mapstructure:"enable"`
+	Title  string `mapstructure:"title"`
+	Desc   string `mapstructure:"desc"`
+	Ext    string `mapstructure:"ext"`
 }
 
 type NotificationConfig struct {
-	IsSendMsg        bool              `yaml:"isSendMsg"`
-	ReliabilityLevel int               `yaml:"reliabilityLevel"`
-	UnreadCount      bool              `yaml:"unreadCount"`
-	OfflinePush      OfflinePushConfig `yaml:"offlinePush"`
+	IsSendMsg        bool              `mapstructure:"isSendMsg"`
+	ReliabilityLevel int               `mapstructure:"reliabilityLevel"`
+	UnreadCount      bool              `mapstructure:"unreadCount"`
+	OfflinePush      OfflinePushConfig `mapstructure:"offlinePush"`
 }
 
 type Notification struct {
-	GroupCreated              NotificationConfig `yaml:"groupCreated"`
-	GroupInfoSet              NotificationConfig `yaml:"groupInfoSet"`
-	JoinGroupApplication      NotificationConfig `yaml:"joinGroupApplication"`
-	MemberQuit                NotificationConfig `yaml:"memberQuit"`
-	GroupApplicationAccepted  NotificationConfig `yaml:"groupApplicationAccepted"`
-	GroupApplicationRejected  NotificationConfig `yaml:"groupApplicationRejected"`
-	GroupOwnerTransferred     NotificationConfig `yaml:"groupOwnerTransferred"`
-	MemberKicked              NotificationConfig `yaml:"memberKicked"`
-	MemberInvited             NotificationConfig `yaml:"memberInvited"`
-	MemberEnter               NotificationConfig `yaml:"memberEnter"`
-	GroupDismissed            NotificationConfig `yaml:"groupDismissed"`
-	GroupMuted                NotificationConfig `yaml:"groupMuted"`
-	GroupCancelMuted          NotificationConfig `yaml:"groupCancelMuted"`
-	GroupMemberMuted          NotificationConfig `yaml:"groupMemberMuted"`
-	GroupMemberCancelMuted    NotificationConfig `yaml:"groupMemberCancelMuted"`
-	GroupMemberInfoSet        NotificationConfig `yaml:"groupMemberInfoSet"`
+	GroupCreated              NotificationConfig `mapstructure:"groupCreated"`
+	GroupInfoSet              NotificationConfig `mapstructure:"groupInfoSet"`
+	JoinGroupApplication      NotificationConfig `mapstructure:"joinGroupApplication"`
+	MemberQuit                NotificationConfig `mapstructure:"memberQuit"`
+	GroupApplicationAccepted  NotificationConfig `mapstructure:"groupApplicationAccepted"`
+	GroupApplicationRejected  NotificationConfig `mapstructure:"groupApplicationRejected"`
+	GroupOwnerTransferred     NotificationConfig `mapstructure:"groupOwnerTransferred"`
+	MemberKicked              NotificationConfig `mapstructure:"memberKicked"`
+	MemberInvited             NotificationConfig `mapstructure:"memberInvited"`
+	MemberEnter               NotificationConfig `mapstructure:"memberEnter"`
+	GroupDismissed            NotificationConfig `mapstructure:"groupDismissed"`
+	GroupMuted                NotificationConfig `mapstructure:"groupMuted"`
+	GroupCancelMuted          NotificationConfig `mapstructure:"groupCancelMuted"`
+	GroupMemberMuted          NotificationConfig `mapstructure:"groupMemberMuted"`
+	GroupMemberCancelMuted    NotificationConfig `mapstructure:"groupMemberCancelMuted"`
+	GroupMemberInfoSet        NotificationConfig `mapstructure:"groupMemberInfoSet"`
 	GroupMemberSetToAdmin     NotificationConfig `yaml:"groupMemberSetToAdmin"`
 	GroupMemberSetToOrdinary  NotificationConfig `yaml:"groupMemberSetToOrdinaryUser"`
-	GroupInfoSetAnnouncement  NotificationConfig `yaml:"groupInfoSetAnnouncement"`
-	GroupInfoSetName          NotificationConfig `yaml:"groupInfoSetName"`
-	FriendApplicationAdded    NotificationConfig `yaml:"friendApplicationAdded"`
-	FriendApplicationApproved NotificationConfig `yaml:"friendApplicationApproved"`
-	FriendApplicationRejected NotificationConfig `yaml:"friendApplicationRejected"`
-	FriendAdded               NotificationConfig `yaml:"friendAdded"`
-	FriendDeleted             NotificationConfig `yaml:"friendDeleted"`
-	FriendRemarkSet           NotificationConfig `yaml:"friendRemarkSet"`
-	BlackAdded                NotificationConfig `yaml:"blackAdded"`
-	BlackDeleted              NotificationConfig `yaml:"blackDeleted"`
-	FriendInfoUpdated         NotificationConfig `yaml:"friendInfoUpdated"`
-	UserInfoUpdated           NotificationConfig `yaml:"userInfoUpdated"`
-	UserStatusChanged         NotificationConfig `yaml:"userStatusChanged"`
-	ConversationChanged       NotificationConfig `yaml:"conversationChanged"`
-	ConversationSetPrivate    NotificationConfig `yaml:"conversationSetPrivate"`
+	GroupInfoSetAnnouncement  NotificationConfig `mapstructure:"groupInfoSetAnnouncement"`
+	GroupInfoSetName          NotificationConfig `mapstructure:"groupInfoSetName"`
+	FriendApplicationAdded    NotificationConfig `mapstructure:"friendApplicationAdded"`
+	FriendApplicationApproved NotificationConfig `mapstructure:"friendApplicationApproved"`
+	FriendApplicationRejected NotificationConfig `mapstructure:"friendApplicationRejected"`
+	FriendAdded               NotificationConfig `mapstructure:"friendAdded"`
+	FriendDeleted             NotificationConfig `mapstructure:"friendDeleted"`
+	FriendRemarkSet           NotificationConfig `mapstructure:"friendRemarkSet"`
+	BlackAdded                NotificationConfig `mapstructure:"blackAdded"`
+	BlackDeleted              NotificationConfig `mapstructure:"blackDeleted"`
+	FriendInfoUpdated         NotificationConfig `mapstructure:"friendInfoUpdated"`
+	UserInfoUpdated           NotificationConfig `mapstructure:"userInfoUpdated"`
+	UserStatusChanged         NotificationConfig `mapstructure:"userStatusChanged"`
+	ConversationChanged       NotificationConfig `mapstructure:"conversationChanged"`
+	ConversationSetPrivate    NotificationConfig `mapstructure:"conversationSetPrivate"`
 }
 
 type Prometheus struct {
-	Enable bool  `yaml:"enable"`
-	Ports  []int `yaml:"ports"`
+	Enable bool  `mapstructure:"enable"`
+	Ports  []int `mapstructure:"ports"`
 }
 
 type MsgGateway struct {
-	RPC         RPC        `yaml:"rpc"`
-	Prometheus  Prometheus `yaml:"prometheus"`
-	ListenIP    string     `yaml:"listenIP"`
+	RPC struct {
+		RegisterIP   string `mapstructure:"registerIP"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+	} `mapstructure:"rpc"`
+	Prometheus  Prometheus `mapstructure:"prometheus"`
+	ListenIP    string     `mapstructure:"listenIP"`
 	LongConnSvr struct {
-		Ports               []int `yaml:"ports"`
-		WebsocketMaxConnNum int   `yaml:"websocketMaxConnNum"`
-		WebsocketMaxMsgLen  int   `yaml:"websocketMaxMsgLen"`
-		WebsocketTimeout    int   `yaml:"websocketTimeout"`
-	} `yaml:"longConnSvr"`
+		Ports               []int `mapstructure:"ports"`
+		WebsocketMaxConnNum int   `mapstructure:"websocketMaxConnNum"`
+		WebsocketMaxMsgLen  int   `mapstructure:"websocketMaxMsgLen"`
+		WebsocketTimeout    int   `mapstructure:"websocketTimeout"`
+	} `mapstructure:"longConnSvr"`
 }
 
 type MsgTransfer struct {
 	Prometheus struct {
-		Enable       bool  `yaml:"enable"`
-		AutoSetPorts bool  `yaml:"autoSetPorts"`
-		Ports        []int `yaml:"ports"`
-	} `yaml:"prometheus"`
+		Enable       bool  `mapstructure:"enable"`
+		AutoSetPorts bool  `mapstructure:"autoSetPorts"`
+		Ports        []int `mapstructure:"ports"`
+	} `mapstructure:"prometheus"`
 }
 
 type Push struct {
-	RPC                  RPC        `yaml:"rpc"`
-	Prometheus           Prometheus `yaml:"prometheus"`
-	MaxConcurrentWorkers int        `yaml:"maxConcurrentWorkers"`
-	Enable               string     `yaml:"enable"`
+	RPC struct {
+		RegisterIP   string `mapstructure:"registerIP"`
+		ListenIP     string `mapstructure:"listenIP"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+	} `mapstructure:"rpc"`
+	Prometheus           Prometheus `mapstructure:"prometheus"`
+	MaxConcurrentWorkers int        `mapstructure:"maxConcurrentWorkers"`
+	Enable               string     `mapstructure:"enable"`
 	GeTui                struct {
-		PushUrl      string `yaml:"pushUrl"`
-		MasterSecret string `yaml:"masterSecret"`
-		AppKey       string `yaml:"appKey"`
-		Intent       string `yaml:"intent"`
-		ChannelID    string `yaml:"channelID"`
-		ChannelName  string `yaml:"channelName"`
-	} `yaml:"geTui"`
+		PushUrl      string `mapstructure:"pushUrl"`
+		MasterSecret string `mapstructure:"masterSecret"`
+		AppKey       string `mapstructure:"appKey"`
+		Intent       string `mapstructure:"intent"`
+		ChannelID    string `mapstructure:"channelID"`
+		ChannelName  string `mapstructure:"channelName"`
+	} `mapstructure:"geTui"`
 	FCM struct {
-		FilePath string `yaml:"filePath"`
-		AuthURL  string `yaml:"authURL"`
-	} `yaml:"fcm"`
+		FilePath string `mapstructure:"filePath"`
+		AuthURL  string `mapstructure:"authURL"`
+	} `mapstructure:"fcm"`
 	JPush struct {
-		AppKey       string `yaml:"appKey"`
-		MasterSecret string `yaml:"masterSecret"`
-		PushURL      string `yaml:"pushURL"`
-		PushIntent   string `yaml:"pushIntent"`
-	} `yaml:"jpush"`
+		AppKey       string `mapstructure:"appKey"`
+		MasterSecret string `mapstructure:"masterSecret"`
+		PushURL      string `mapstructure:"pushURL"`
+		PushIntent   string `mapstructure:"pushIntent"`
+	} `mapstructure:"jpush"`
 	IOSPush struct {
-		PushSound  string `yaml:"pushSound"`
-		BadgeCount bool   `yaml:"badgeCount"`
-		Production bool   `yaml:"production"`
-	} `yaml:"iosPush"`
-	FullUserCache bool `yaml:"fullUserCache"`
+		PushSound  string `mapstructure:"pushSound"`
+		BadgeCount bool   `mapstructure:"badgeCount"`
+		Production bool   `mapstructure:"production"`
+	} `mapstructure:"iosPush"`
+	FullUserCache bool `mapstructure:"fullUserCache"`
 }
 
 type Auth struct {
-	RPC         RPC        `yaml:"rpc"`
-	Prometheus  Prometheus `yaml:"prometheus"`
+	RPC struct {
+		RegisterIP   string `mapstructure:"registerIP"`
+		ListenIP     string `mapstructure:"listenIP"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+	} `mapstructure:"rpc"`
+	Prometheus  Prometheus `mapstructure:"prometheus"`
 	TokenPolicy struct {
-		Expire int64 `yaml:"expire"`
-	} `yaml:"tokenPolicy"`
+		Expire int64 `mapstructure:"expire"`
+	} `mapstructure:"tokenPolicy"`
 }
 
 type Conversation struct {
-	RPC        RPC        `yaml:"rpc"`
-	Prometheus Prometheus `yaml:"prometheus"`
+	RPC struct {
+		RegisterIP   string `mapstructure:"registerIP"`
+		ListenIP     string `mapstructure:"listenIP"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+	} `mapstructure:"rpc"`
+	Prometheus Prometheus `mapstructure:"prometheus"`
 }
 
 type Friend struct {
-	RPC        RPC        `yaml:"rpc"`
-	Prometheus Prometheus `yaml:"prometheus"`
+	RPC struct {
+		RegisterIP   string `mapstructure:"registerIP"`
+		ListenIP     string `mapstructure:"listenIP"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+	} `mapstructure:"rpc"`
+	Prometheus Prometheus `mapstructure:"prometheus"`
 }
 
 type Group struct {
-	RPC                        RPC        `yaml:"rpc"`
-	Prometheus                 Prometheus `yaml:"prometheus"`
-	EnableHistoryForNewMembers bool       `yaml:"enableHistoryForNewMembers"`
+	RPC struct {
+		RegisterIP   string `mapstructure:"registerIP"`
+		ListenIP     string `mapstructure:"listenIP"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+	} `mapstructure:"rpc"`
+	Prometheus                 Prometheus `mapstructure:"prometheus"`
+	EnableHistoryForNewMembers bool       `mapstructure:"enableHistoryForNewMembers"`
 }
 
 type Msg struct {
-	RPC          RPC        `yaml:"rpc"`
-	Prometheus   Prometheus `yaml:"prometheus"`
-	FriendVerify bool       `yaml:"friendVerify"`
+	RPC struct {
+		RegisterIP   string `mapstructure:"registerIP"`
+		ListenIP     string `mapstructure:"listenIP"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+	} `mapstructure:"rpc"`
+	Prometheus   Prometheus `mapstructure:"prometheus"`
+	FriendVerify bool       `mapstructure:"friendVerify"`
 }
 
 type Third struct {
-	RPC        RPC        `yaml:"rpc"`
-	Prometheus Prometheus `yaml:"prometheus"`
+	RPC struct {
+		RegisterIP   string `mapstructure:"registerIP"`
+		ListenIP     string `mapstructure:"listenIP"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+	} `mapstructure:"rpc"`
+	Prometheus Prometheus `mapstructure:"prometheus"`
 	Object     struct {
-		Enable string `yaml:"enable"`
-		Cos    Cos    `yaml:"cos"`
-		Oss    Oss    `yaml:"oss"`
-		Kodo   Kodo   `yaml:"kodo"`
-		Aws    Aws    `yaml:"aws"`
-	} `yaml:"object"`
+		Enable string `mapstructure:"enable"`
+		Cos    Cos    `mapstructure:"cos"`
+		Oss    Oss    `mapstructure:"oss"`
+		Kodo   Kodo   `mapstructure:"kodo"`
+		Aws    Aws    `mapstructure:"aws"`
+	} `mapstructure:"object"`
 }
 type Cos struct {
-	BucketURL    string `yaml:"bucketURL"`
-	SecretID     string `yaml:"secretID"`
-	SecretKey    string `yaml:"secretKey"`
-	SessionToken string `yaml:"sessionToken"`
-	PublicRead   bool   `yaml:"publicRead"`
+	BucketURL    string `mapstructure:"bucketURL"`
+	SecretID     string `mapstructure:"secretID"`
+	SecretKey    string `mapstructure:"secretKey"`
+	SessionToken string `mapstructure:"sessionToken"`
+	PublicRead   bool   `mapstructure:"publicRead"`
 }
 type Oss struct {
-	Endpoint        string `yaml:"endpoint"`
-	Bucket          string `yaml:"bucket"`
-	BucketURL       string `yaml:"bucketURL"`
-	AccessKeyID     string `yaml:"accessKeyID"`
-	AccessKeySecret string `yaml:"accessKeySecret"`
-	SessionToken    string `yaml:"sessionToken"`
-	PublicRead      bool   `yaml:"publicRead"`
+	Endpoint        string `mapstructure:"endpoint"`
+	Bucket          string `mapstructure:"bucket"`
+	BucketURL       string `mapstructure:"bucketURL"`
+	AccessKeyID     string `mapstructure:"accessKeyID"`
+	AccessKeySecret string `mapstructure:"accessKeySecret"`
+	SessionToken    string `mapstructure:"sessionToken"`
+	PublicRead      bool   `mapstructure:"publicRead"`
 }
 
 type Kodo struct {
-	Endpoint        string `yaml:"endpoint"`
-	Bucket          string `yaml:"bucket"`
-	BucketURL       string `yaml:"bucketURL"`
-	AccessKeyID     string `yaml:"accessKeyID"`
-	AccessKeySecret string `yaml:"accessKeySecret"`
-	SessionToken    string `yaml:"sessionToken"`
-	PublicRead      bool   `yaml:"publicRead"`
+	Endpoint        string `mapstructure:"endpoint"`
+	Bucket          string `mapstructure:"bucket"`
+	BucketURL       string `mapstructure:"bucketURL"`
+	AccessKeyID     string `mapstructure:"accessKeyID"`
+	AccessKeySecret string `mapstructure:"accessKeySecret"`
+	SessionToken    string `mapstructure:"sessionToken"`
+	PublicRead      bool   `mapstructure:"publicRead"`
 }
 
 type Aws struct {
-	Region          string `yaml:"region"`
-	Bucket          string `yaml:"bucket"`
-	AccessKeyID     string `yaml:"accessKeyID"`
-	SecretAccessKey string `yaml:"secretAccessKey"`
-	SessionToken    string `yaml:"sessionToken"`
-	PublicRead      bool   `yaml:"publicRead"`
+	Endpoint        string `mapstructure:"endpoint"`
+	Region          string `mapstructure:"region"`
+	Bucket          string `mapstructure:"bucket"`
+	AccessKeyID     string `mapstructure:"accessKeyID"`
+	SecretAccessKey string `mapstructure:"secretAccessKey"`
+	SessionToken    string `mapstructure:"sessionToken"`
 }
 
 type User struct {
-	RPC        RPC        `yaml:"rpc"`
-	Prometheus Prometheus `yaml:"prometheus"`
-}
-
-type RPC struct {
-	RegisterIP   string `yaml:"registerIP"`
-	ListenIP     string `yaml:"listenIP"`
-	AutoSetPorts bool   `yaml:"autoSetPorts"`
-	Ports        []int  `yaml:"ports"`
+	RPC struct {
+		RegisterIP   string `mapstructure:"registerIP"`
+		ListenIP     string `mapstructure:"listenIP"`
+		AutoSetPorts bool   `mapstructure:"autoSetPorts"`
+		Ports        []int  `mapstructure:"ports"`
+	} `mapstructure:"rpc"`
+	Prometheus Prometheus `mapstructure:"prometheus"`
 }
 
 type Redis struct {
-	Disable     bool     `yaml:"-"`
-	Address     []string `yaml:"address"`
-	Username    string   `yaml:"username"`
-	Password    string   `yaml:"password"`
-	ClusterMode bool     `yaml:"clusterMode"`
-	DB          int      `yaml:"storage"`
-	MaxRetry    int      `yaml:"maxRetry"`
-	PoolSize    int      `yaml:"poolSize"`
+	Address     []string `mapstructure:"address"`
+	Username    string   `mapstructure:"username"`
+	Password    string   `mapstructure:"password"`
+	ClusterMode bool     `mapstructure:"clusterMode"`
+	DB          int      `mapstructure:"storage"`
+	MaxRetry    int      `mapstructure:"maxRetry"`
+	PoolSize    int      `mapstructure:"poolSize"`
 }
 
 type BeforeConfig struct {
@@ -360,23 +390,23 @@ type MaxRequestBody struct {
 }
 
 type MultiLogin struct {
-	Policy       int `yaml:"policy"`
-	MaxNumOneEnd int `yaml:"maxNumOneEnd"`
+	Policy       int `mapstructure:"policy"`
+	MaxNumOneEnd int `mapstructure:"maxNumOneEnd"`
 }
 
-type RpcService struct {
-	User           string `yaml:"user"`
-	Friend         string `yaml:"friend"`
-	Msg            string `yaml:"msg"`
-	Push           string `yaml:"push"`
-	MessageGateway string `yaml:"messageGateway"`
-	Group          string `yaml:"group"`
-	Auth           string `yaml:"auth"`
-	Conversation   string `yaml:"conversation"`
-	Third          string `yaml:"third"`
+type RpcRegisterName struct {
+	User           string `mapstructure:"user"`
+	Friend         string `mapstructure:"friend"`
+	Msg            string `mapstructure:"msg"`
+	Push           string `mapstructure:"push"`
+	MessageGateway string `mapstructure:"messageGateway"`
+	Group          string `mapstructure:"group"`
+	Auth           string `mapstructure:"auth"`
+	Conversation   string `mapstructure:"conversation"`
+	Third          string `mapstructure:"third"`
 }
 
-func (r *RpcService) GetServiceNames() []string {
+func (r *RpcRegisterName) GetServiceNames() []string {
 	return []string{
 		r.User,
 		r.Friend,
@@ -448,28 +478,53 @@ type Webhooks struct {
 }
 
 type ZooKeeper struct {
-	Schema   string   `yaml:"schema"`
-	Address  []string `yaml:"address"`
-	Username string   `yaml:"username"`
-	Password string   `yaml:"password"`
+	Schema   string   `mapstructure:"schema"`
+	Address  []string `mapstructure:"address"`
+	Username string   `mapstructure:"username"`
+	Password string   `mapstructure:"password"`
 }
 
 type Discovery struct {
-	Enable     string     `yaml:"enable"`
-	Etcd       Etcd       `yaml:"etcd"`
-	Kubernetes Kubernetes `yaml:"kubernetes"`
-	RpcService RpcService `yaml:"rpcService"`
+	Enable     string     `mapstructure:"enable"`
+	Etcd       Etcd       `mapstructure:"etcd"`
+	Kubernetes Kubernetes `mapstructure:"kubernetes"`
+	RpcService RpcService `mapstructure:"rpcService"`
+}
+
+type RpcService struct {
+	User           string `mapstructure:"user"`
+	Friend         string `mapstructure:"friend"`
+	Msg            string `mapstructure:"msg"`
+	Push           string `mapstructure:"push"`
+	MessageGateway string `mapstructure:"messageGateway"`
+	Group          string `mapstructure:"group"`
+	Auth           string `mapstructure:"auth"`
+	Conversation   string `mapstructure:"conversation"`
+	Third          string `mapstructure:"third"`
+}
+
+func (r *RpcService) GetServiceNames() []string {
+	return []string{
+		r.User,
+		r.Friend,
+		r.Msg,
+		r.Push,
+		r.MessageGateway,
+		r.Group,
+		r.Auth,
+		r.Conversation,
+		r.Third,
+	}
 }
 
 type Kubernetes struct {
 	Namespace string `yaml:"namespace"`
 }
-
 type Etcd struct {
-	RootDirectory string   `yaml:"rootDirectory"`
-	Address       []string `yaml:"address"`
-	Username      string   `yaml:"username"`
-	Password      string   `yaml:"password"`
+	RootDirectory string   `mapstructure:"rootDirectory"`
+	Address       []string `mapstructure:"address"`
+	Username      string   `mapstructure:"username"`
+	Password      string   `mapstructure:"password"`
 }
 
 func (m *Mongo) Build() *mongoutil.Config {
@@ -532,7 +587,6 @@ func (m *Minio) Build() *minio.Config {
 		SignEndpoint:    formatEndpoint(m.ExternalAddress),
 	}
 }
-
 func (c *Cos) Build() *cos.Config {
 	return &cos.Config{
 		BucketURL:    c.BucketURL,
@@ -589,6 +643,119 @@ func (l *CacheConfig) Enable() bool {
 	return l.Topic != "" && l.SlotNum > 0 && l.SlotSize > 0
 }
 
+const (
+	DiscoveryConfigFilename          = "discovery.yml"
+	KafkaConfigFileName              = "kafka.yml"
+	LocalCacheConfigFileName         = "local-cache.yml"
+	LogConfigFileName                = "log.yml"
+	MinioConfigFileName              = "minio.yml"
+	MongodbConfigFileName            = "mongodb.yml"
+	OpenIMAPICfgFileName             = "openim-api.yml"
+	OpenIMCronTaskCfgFileName        = "openim-crontask.yml"
+	OpenIMMsgGatewayCfgFileName      = "openim-msggateway.yml"
+	OpenIMMsgTransferCfgFileName     = "openim-msgtransfer.yml"
+	OpenIMPushCfgFileName            = "openim-push.yml"
+	OpenIMRPCAuthCfgFileName         = "openim-rpc-auth.yml"
+	OpenIMRPCConversationCfgFileName = "openim-rpc-conversation.yml"
+	OpenIMRPCFriendCfgFileName       = "openim-rpc-friend.yml"
+	OpenIMRPCGroupCfgFileName        = "openim-rpc-group.yml"
+	OpenIMRPCMsgCfgFileName          = "openim-rpc-msg.yml"
+	OpenIMRPCThirdCfgFileName        = "openim-rpc-third.yml"
+	OpenIMRPCUserCfgFileName         = "openim-rpc-user.yml"
+	RedisConfigFileName              = "redis.yml"
+	ShareFileName                    = "share.yml"
+	WebhooksConfigFileName           = "webhooks.yml"
+	NotificationFileName             = "notification.yml"
+)
+
+func (d *Discovery) GetConfigFileName() string {
+	return DiscoveryConfigFilename
+}
+
+func (k *Kafka) GetConfigFileName() string {
+	return KafkaConfigFileName
+}
+
+func (lc *LocalCache) GetConfigFileName() string {
+	return LocalCacheConfigFileName
+}
+
+func (l *Log) GetConfigFileName() string {
+	return LogConfigFileName
+}
+
+func (m *Minio) GetConfigFileName() string {
+	return MinioConfigFileName
+}
+
+func (m *Mongo) GetConfigFileName() string {
+	return MongodbConfigFileName
+}
+
+func (n *Notification) GetConfigFileName() string {
+	return NotificationFileName
+}
+
+func (a *API) GetConfigFileName() string {
+	return OpenIMAPICfgFileName
+}
+
+func (ct *CronTask) GetConfigFileName() string {
+	return OpenIMCronTaskCfgFileName
+}
+
+func (mg *MsgGateway) GetConfigFileName() string {
+	return OpenIMMsgGatewayCfgFileName
+}
+
+func (mt *MsgTransfer) GetConfigFileName() string {
+	return OpenIMMsgTransferCfgFileName
+}
+
+func (p *Push) GetConfigFileName() string {
+	return OpenIMPushCfgFileName
+}
+
+func (a *Auth) GetConfigFileName() string {
+	return OpenIMRPCAuthCfgFileName
+}
+
+func (c *Conversation) GetConfigFileName() string {
+	return OpenIMRPCConversationCfgFileName
+}
+
+func (f *Friend) GetConfigFileName() string {
+	return OpenIMRPCFriendCfgFileName
+}
+
+func (g *Group) GetConfigFileName() string {
+	return OpenIMRPCGroupCfgFileName
+}
+
+func (m *Msg) GetConfigFileName() string {
+	return OpenIMRPCMsgCfgFileName
+}
+
+func (t *Third) GetConfigFileName() string {
+	return OpenIMRPCThirdCfgFileName
+}
+
+func (u *User) GetConfigFileName() string {
+	return OpenIMRPCUserCfgFileName
+}
+
+func (r *Redis) GetConfigFileName() string {
+	return RedisConfigFileName
+}
+
+func (s *Share) GetConfigFileName() string {
+	return ShareFileName
+}
+
+func (w *Webhooks) GetConfigFileName() string {
+	return WebhooksConfigFileName
+}
+
 func InitNotification(notification *Notification) {
 	notification.GroupCreated.UnreadCount = false
 	notification.GroupCreated.ReliabilityLevel = 1
@@ -760,117 +927,3 @@ func (a *AllConfig) GetConfigNames() []string {
 		a.Webhooks.GetConfigFileName(),
 	}
 }
-
-const (
-	FileName                         = "config.yaml"
-	DiscoveryConfigFilename          = "discovery.yml"
-	KafkaConfigFileName              = "kafka.yml"
-	LocalCacheConfigFileName         = "local-cache.yml"
-	LogConfigFileName                = "log.yml"
-	MinioConfigFileName              = "minio.yml"
-	MongodbConfigFileName            = "mongodb.yml"
-	NotificationFileName             = "notification.yml"
-	OpenIMAPICfgFileName             = "openim-api.yml"
-	OpenIMCronTaskCfgFileName        = "openim-crontask.yml"
-	OpenIMMsgGatewayCfgFileName      = "openim-msggateway.yml"
-	OpenIMMsgTransferCfgFileName     = "openim-msgtransfer.yml"
-	OpenIMPushCfgFileName            = "openim-push.yml"
-	OpenIMRPCAuthCfgFileName         = "openim-rpc-auth.yml"
-	OpenIMRPCConversationCfgFileName = "openim-rpc-conversation.yml"
-	OpenIMRPCFriendCfgFileName       = "openim-rpc-friend.yml"
-	OpenIMRPCGroupCfgFileName        = "openim-rpc-group.yml"
-	OpenIMRPCMsgCfgFileName          = "openim-rpc-msg.yml"
-	OpenIMRPCThirdCfgFileName        = "openim-rpc-third.yml"
-	OpenIMRPCUserCfgFileName         = "openim-rpc-user.yml"
-	RedisConfigFileName              = "redis.yml"
-	ShareFileName                    = "share.yml"
-	WebhooksConfigFileName           = "webhooks.yml"
-)
-
-func (d *Discovery) GetConfigFileName() string {
-	return DiscoveryConfigFilename
-}
-
-func (k *Kafka) GetConfigFileName() string {
-	return KafkaConfigFileName
-}
-
-func (lc *LocalCache) GetConfigFileName() string {
-	return LocalCacheConfigFileName
-}
-
-func (l *Log) GetConfigFileName() string {
-	return LogConfigFileName
-}
-
-func (m *Minio) GetConfigFileName() string {
-	return MinioConfigFileName
-}
-
-func (m *Mongo) GetConfigFileName() string {
-	return MongodbConfigFileName
-}
-
-func (n *Notification) GetConfigFileName() string {
-	return NotificationFileName
-}
-
-func (a *API) GetConfigFileName() string {
-	return OpenIMAPICfgFileName
-}
-
-func (ct *CronTask) GetConfigFileName() string {
-	return OpenIMCronTaskCfgFileName
-}
-
-func (mg *MsgGateway) GetConfigFileName() string {
-	return OpenIMMsgGatewayCfgFileName
-}
-
-func (mt *MsgTransfer) GetConfigFileName() string {
-	return OpenIMMsgTransferCfgFileName
-}
-
-func (p *Push) GetConfigFileName() string {
-	return OpenIMPushCfgFileName
-}
-
-func (a *Auth) GetConfigFileName() string {
-	return OpenIMRPCAuthCfgFileName
-}
-
-func (c *Conversation) GetConfigFileName() string {
-	return OpenIMRPCConversationCfgFileName
-}
-
-func (f *Friend) GetConfigFileName() string {
-	return OpenIMRPCFriendCfgFileName
-}
-
-func (g *Group) GetConfigFileName() string {
-	return OpenIMRPCGroupCfgFileName
-}
-
-func (m *Msg) GetConfigFileName() string {
-	return OpenIMRPCMsgCfgFileName
-}
-
-func (t *Third) GetConfigFileName() string {
-	return OpenIMRPCThirdCfgFileName
-}
-
-func (u *User) GetConfigFileName() string {
-	return OpenIMRPCUserCfgFileName
-}
-
-func (r *Redis) GetConfigFileName() string {
-	return RedisConfigFileName
-}
-
-func (s *Share) GetConfigFileName() string {
-	return ShareFileName
-}
-
-func (w *Webhooks) GetConfigFileName() string {
-	return WebhooksConfigFileName
-}

pkg/common/config/constant.go

@@ -14,16 +14,13 @@
 
 package config
 
-import "github.com/openimsdk/tools/utils/runtimeenv"
-
 const ConfKey = "conf"
 
 const (
 	MountConfigFilePath = "CONFIG_PATH"
 	DeploymentType      = "DEPLOYMENT_TYPE"
-	KUBERNETES          = runtimeenv.Kubernetes
+	KUBERNETES          = "kubernetes"
 	ETCD                = "etcd"
-	//Standalone          = "standalone"
 )
 
 const (

pkg/common/config/global.go

@@ -1,11 +0,0 @@
-package config
-
-var standalone bool
-
-func SetStandalone() {
-	standalone = true
-}
-
-func Standalone() bool {
-	return standalone
-}

pkg/common/config/load_config.go

@@ -7,12 +7,11 @@ import (
 
 	"github.com/mitchellh/mapstructure"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/utils/runtimeenv"
 	"github.com/spf13/viper"
 )
 
-func Load(configDirectory string, configFileName string, envPrefix string, config any) error {
-	if runtimeenv.RuntimeEnvironment() == KUBERNETES {
+func Load(configDirectory string, configFileName string, envPrefix string, runtimeEnv string, config any) error {
+	if runtimeEnv == KUBERNETES {
 		mountPath := os.Getenv(MountConfigFilePath)
 		if mountPath == "" {
 			return errs.ErrArgs.WrapMsg(MountConfigFilePath + " env is empty")
@@ -36,7 +35,7 @@ func loadConfig(path string, envPrefix string, config any) error {
 	}
 
 	if err := v.Unmarshal(config, func(config *mapstructure.DecoderConfig) {
-		config.TagName = StructTagName
+		config.TagName = "mapstructure"
 	}); err != nil {
 		return errs.WrapMsg(err, "failed to unmarshal config", "path", path, "envPrefix", envPrefix)
 	}

pkg/common/config/load_config_test.go

@@ -1,10 +1,8 @@
 package config
 
 import (
-	"os"
-	"testing"
-
 	"github.com/stretchr/testify/assert"
+	"testing"
 )
 
 func TestLoadLogConfig(t *testing.T) {
@@ -26,14 +24,7 @@ func TestLoadMongoConfig(t *testing.T) {
 	// err := LoadApiConfig("../../../config/mongodb.yml", "IMENV_MONGODB", &mongo)
 
 	assert.Nil(t, err)
-	t.Log(mongo.Password)
-	// assert.Equal(t, "openIM123", mongo.Password)
-	t.Log(os.Getenv("IMENV_MONGODB_PASSWORD"))
-	t.Log(mongo)
-	// //export IMENV_OPENIM_RPC_USER_RPC_LISTENIP="0.0.0.0"
-	// assert.Equal(t, "0.0.0.0", user.RPC.ListenIP)
-	// //export IMENV_OPENIM_RPC_USER_RPC_PORTS="10110,10111,10112"
-	// assert.Equal(t, []int{10110, 10111, 10112}, user.RPC.Ports)
+	assert.Equal(t, "../../../../logs/", log.StorageLocation)
 }
 
 func TestLoadMinioConfig(t *testing.T) {

pkg/common/config/parse.go

@@ -18,16 +18,15 @@ import (
 	"os"
 	"path/filepath"
 
-	"gopkg.in/yaml.v3"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/field"
+	"gopkg.in/yaml.v3"
 )
 
 const (
-	DefaultFolderPath = "../config/"
+	FileName = "config.yaml"
 )
 
 // return absolude path join ../config/, this is k8s container config path.
@@ -57,13 +56,10 @@ func GetProjectRoot() (string, error) {
 	return projectRoot, nil
 }
 
-func GetOptionsByNotification(cfg NotificationConfig, sendMessage *bool) msgprocessor.Options {
+func GetOptionsByNotification(cfg NotificationConfig) msgprocessor.Options {
 	opts := msgprocessor.NewOptions()
 
-	if sendMessage != nil {
-		cfg.IsSendMsg = *sendMessage
-	}
-	if cfg.IsSendMsg {
+	if cfg.UnreadCount {
 		opts = msgprocessor.WithOptions(opts, msgprocessor.WithUnreadCount(true))
 	}
 	if cfg.OfflinePush.Enable {

pkg/common/discovery/discoveryregister.go

@@ -19,8 +19,6 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/tools/discovery"
-	"github.com/openimsdk/tools/discovery/standalone"
-	"github.com/openimsdk/tools/utils/runtimeenv"
 	"google.golang.org/grpc"
 
 	"github.com/openimsdk/tools/discovery/kubernetes"
@@ -30,11 +28,8 @@ import (
 )
 
 // NewDiscoveryRegister creates a new service discovery and registry client based on the provided environment type.
-func NewDiscoveryRegister(discovery *config.Discovery, watchNames []string) (discovery.SvcDiscoveryRegistry, error) {
-	if config.Standalone() {
-		return standalone.GetSvcDiscoveryRegistry(), nil
-	}
-	if runtimeenv.RuntimeEnvironment() == config.KUBERNETES {
+func NewDiscoveryRegister(discovery *config.Discovery, runtimeEnv string, watchNames []string) (discovery.SvcDiscoveryRegistry, error) {
+	if runtimeEnv == config.KUBERNETES {
 		return kubernetes.NewKubernetesConnManager(discovery.Kubernetes.Namespace,
 			grpc.WithDefaultCallOptions(
 				grpc.MaxCallSendMsgSize(1024*1024*20),

pkg/common/prommetrics/api.go

@@ -1,11 +1,10 @@
 package prommetrics
 
 import (
-	"net"
-	"strconv"
-
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"net"
+	"strconv"
 )
 
 var (
@@ -25,10 +24,6 @@ var (
 	)
 )
 
-func RegistryApi() {
-	registry.MustRegister(apiCounter, httpCounter)
-}
-
 func ApiInit(listener net.Listener) error {
 	apiRegistry := prometheus.NewRegistry()
 	cs := append(
@@ -46,3 +41,9 @@ func APICall(path string, method string, apiCode int) {
 func HttpCall(path string, method string, status int) {
 	httpCounter.With(prometheus.Labels{"path": path, "method": method, "status": strconv.Itoa(status)}).Inc()
 }
+
+//func ApiHandler() http.Handler {
+//	return promhttp.InstrumentMetricHandler(
+//		apiRegistry, promhttp.HandlerFor(apiRegistry, promhttp.HandlerOpts{}),
+//	)
+//}

pkg/common/prommetrics/discovery.go

@@ -0,0 +1,31 @@
+package prommetrics
+
+import "fmt"
+
+const (
+	APIKeyName             = "api"
+	MessageTransferKeyName = "message-transfer"
+)
+
+type Target struct {
+	Target string            `json:"target"`
+	Labels map[string]string `json:"labels"`
+}
+
+type RespTarget struct {
+	Targets []string          `json:"targets"`
+	Labels  map[string]string `json:"labels"`
+}
+
+func BuildDiscoveryKey(name string) string {
+	return fmt.Sprintf("%s/%s/%s", "openim", "prometheus_discovery", name)
+}
+
+func BuildDefaultTarget(host string, ip int) Target {
+	return Target{
+		Target: fmt.Sprintf("%s:%d", host, ip),
+		Labels: map[string]string{
+			"namespace": "default",
+		},
+	}
+}

pkg/common/prommetrics/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 prommetrics // import "github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"

pkg/common/prommetrics/grpc_auth.go

@@ -24,7 +24,3 @@ var (
 		Help: "The number of user login",
 	})
 )
-
-func RegistryAuth() {
-	registry.MustRegister(UserLoginCounter)
-}

pkg/common/prommetrics/grpc_msg.go

@@ -36,12 +36,3 @@ var (
 		Help: "The number of group chat msg failed processed",
 	})
 )
-
-func RegistryMsg() {
-	registry.MustRegister(
-		SingleChatMsgProcessSuccessCounter,
-		SingleChatMsgProcessFailedCounter,
-		GroupChatMsgProcessSuccessCounter,
-		GroupChatMsgProcessFailedCounter,
-	)
-}

pkg/common/prommetrics/grpc_msggateway.go

@@ -24,7 +24,3 @@ var (
 		Help: "The number of online user num",
 	})
 )
-
-func RegistryMsgGateway() {
-	registry.MustRegister(OnlineUserGauge)
-}

pkg/common/prommetrics/grpc_push.go

@@ -28,10 +28,3 @@ var (
 		Help: "The number of messages with a push time exceeding 10 seconds",
 	})
 )
-
-func RegistryPush() {
-	registry.MustRegister(
-		MsgOfflinePushFailedCounter,
-		MsgLoneTimePushCounter,
-	)
-}

pkg/common/prommetrics/grpc_user.go

@@ -8,7 +8,3 @@ var (
 		Help: "The number of user login",
 	})
 )
-
-func RegistryUser() {
-	registry.MustRegister(UserRegisterCounter)
-}

pkg/common/prommetrics/prommetrics.go

@@ -15,42 +15,14 @@
 package prommetrics
 
 import (
-	"errors"
-	"fmt"
-	"net"
-	"net/http"
-
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/collectors"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"net"
+	"net/http"
 )
 
 const commonPath = "/metrics"
 
-var registry = &prometheusRegistry{prometheus.NewRegistry()}
-
-type prometheusRegistry struct {
-	*prometheus.Registry
-}
-
-func (x *prometheusRegistry) MustRegister(cs ...prometheus.Collector) {
-	for _, c := range cs {
-		if err := x.Registry.Register(c); err != nil {
-			if errors.As(err, &prometheus.AlreadyRegisteredError{}) {
-				continue
-			}
-			panic(err)
-		}
-	}
-}
-
-func init() {
-	registry.MustRegister(
-		collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}),
-		collectors.NewGoCollector(),
-	)
-}
-
 var (
 	baseCollector = []prometheus.Collector{
 		collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}),
@@ -64,48 +36,3 @@ func Init(registry *prometheus.Registry, listener net.Listener, path string, han
 	srv.Handle(path, handler)
 	return http.Serve(listener, srv)
 }
-
-func RegistryAll() {
-	RegistryApi()
-	RegistryAuth()
-	RegistryMsg()
-	RegistryMsgGateway()
-	RegistryPush()
-	RegistryUser()
-	RegistryRpc()
-	RegistryTransfer()
-}
-
-func Start(listener net.Listener) error {
-	srv := http.NewServeMux()
-	srv.Handle(commonPath, promhttp.HandlerFor(registry, promhttp.HandlerOpts{}))
-	return http.Serve(listener, srv)
-}
-
-const (
-	APIKeyName             = "api"
-	MessageTransferKeyName = "message-transfer"
-)
-
-type Target struct {
-	Target string            `json:"target"`
-	Labels map[string]string `json:"labels"`
-}
-
-type RespTarget struct {
-	Targets []string          `json:"targets"`
-	Labels  map[string]string `json:"labels"`
-}
-
-func BuildDiscoveryKey(name string) string {
-	return fmt.Sprintf("%s/%s/%s", "openim", "prometheus_discovery", name)
-}
-
-func BuildDefaultTarget(host string, ip int) Target {
-	return Target{
-		Target: fmt.Sprintf("%s:%d", host, ip),
-		Labels: map[string]string{
-			"namespace": "default",
-		},
-	}
-}

pkg/common/prommetrics/prommetrics_test.go

@@ -14,8 +14,6 @@
 
 package prommetrics
 
-import "testing"
-
 //func TestNewGrpcPromObj(t *testing.T) {
 //	// Create a custom metric to pass into the NewGrpcPromObj function.
 //	customMetric := prometheus.NewCounter(prometheus.CounterOpts{
@@ -69,9 +67,3 @@ import "testing"
 //		})
 //	}
 //}
-
-func TestName(t *testing.T) {
-	RegistryApi()
-	RegistryApi()
-
-}

pkg/common/prommetrics/rpc.go

@@ -1,13 +1,12 @@
 package prommetrics
 
 import (
-	"net"
-	"strconv"
-
 	gp "github.com/grpc-ecosystem/go-grpc-prometheus"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"net"
+	"strconv"
 )
 
 const rpcPath = commonPath
@@ -23,10 +22,6 @@ var (
 	)
 )
 
-func RegistryRpc() {
-	registry.MustRegister(rpcCounter)
-}
-
 func RpcInit(cs []prometheus.Collector, listener net.Listener) error {
 	reg := prometheus.NewRegistry()
 	cs = append(append(

pkg/common/prommetrics/transfer.go

@@ -15,10 +15,9 @@
 package prommetrics
 
 import (
-	"net"
-
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"net"
 )
 
 var (
@@ -44,16 +43,6 @@ var (
 	})
 )
 
-func RegistryTransfer() {
-	registry.MustRegister(
-		MsgInsertRedisSuccessCounter,
-		MsgInsertRedisFailedCounter,
-		MsgInsertMongoSuccessCounter,
-		MsgInsertMongoFailedCounter,
-		SeqSetFailedCounter,
-	)
-}
-
 func TransferInit(listener net.Listener) error {
 	reg := prometheus.NewRegistry()
 	cs := append(

pkg/common/redispubsub/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 redispubsub // import "github.com/openimsdk/open-im-server/v3/pkg/common/redispubsub"

pkg/common/redispubsub/redispubliser.go

@@ -0,0 +1,30 @@
+// 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 redispubsub
+
+import "github.com/redis/go-redis/v9"
+
+type Publisher struct {
+	client  redis.UniversalClient
+	channel string
+}
+
+func NewPublisher(client redis.UniversalClient, channel string) *Publisher {
+	return &Publisher{client: client, channel: channel}
+}
+
+func (p *Publisher) Publish(message string) error {
+	return p.client.Publish(ctx, p.channel, message).Err()
+}

pkg/common/redispubsub/redissubscriber.go

@@ -0,0 +1,49 @@
+// 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 redispubsub
+
+import (
+	"context"
+
+	"github.com/redis/go-redis/v9"
+)
+
+var ctx = context.Background()
+
+type Subscriber struct {
+	client  redis.UniversalClient
+	channel string
+}
+
+func NewSubscriber(client redis.UniversalClient, channel string) *Subscriber {
+	return &Subscriber{client: client, channel: channel}
+}
+
+func (s *Subscriber) OnMessage(ctx context.Context, callback func(string)) error {
+	messageChannel := s.client.Subscribe(ctx, s.channel).Channel()
+
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case msg := <-messageChannel:
+				callback(msg.Payload)
+			}
+		}
+	}()
+
+	return nil
+}

pkg/common/startrpc/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 startrpc // import "github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"

pkg/common/startrpc/start.go

@@ -47,6 +47,64 @@ func init() {
 	prommetrics.RegistryAll()
 }
 
+func getConfigRpcMaxRequestBody(value reflect.Value) *conf.MaxRequestBody {
+	for value.Kind() == reflect.Pointer {
+		value = value.Elem()
+	}
+	if value.Kind() == reflect.Struct {
+		num := value.NumField()
+		for i := 0; i < num; i++ {
+			field := value.Field(i)
+			if !field.CanInterface() {
+				continue
+			}
+			for field.Kind() == reflect.Pointer {
+				field = field.Elem()
+			}
+			switch elem := field.Interface().(type) {
+			case conf.Share:
+				return &elem.RPCMaxBodySize
+			case conf.MaxRequestBody:
+				return &elem
+			}
+			if field.Kind() == reflect.Struct {
+				if elem := getConfigRpcMaxRequestBody(field); elem != nil {
+					return elem
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func getConfigShare(value reflect.Value) *conf.Share {
+	for value.Kind() == reflect.Pointer {
+		value = value.Elem()
+	}
+	if value.Kind() == reflect.Struct {
+		num := value.NumField()
+		for i := 0; i < num; i++ {
+			field := value.Field(i)
+			if !field.CanInterface() {
+				continue
+			}
+			for field.Kind() == reflect.Pointer {
+				field = field.Elem()
+			}
+			switch elem := field.Interface().(type) {
+			case conf.Share:
+				return &elem
+			}
+			if field.Kind() == reflect.Struct {
+				if elem := getConfigShare(field); elem != nil {
+					return elem
+				}
+			}
+		}
+	}
+	return nil
+}
+
 func Start[T any](ctx context.Context, disc *conf.Discovery, prometheusConfig *conf.Prometheus, listenIP,
 	registerIP string, autoSetPorts bool, rpcPorts []int, index int, rpcRegisterName string, notification *conf.Notification, config T,
 	watchConfigNames []string, watchServiceNames []string,
@@ -64,8 +122,8 @@ func Start[T any](ctx context.Context, disc *conf.Discovery, prometheusConfig *c
 
 	options = append(options,
 		grpcsrv.GrpcServerMetadataContext(),
-		grpcsrv.GrpcServerErrorConvert(),
 		grpcsrv.GrpcServerLogger(),
+		grpcsrv.GrpcServerErrorConvert(),
 		grpcsrv.GrpcServerRequestValidate(),
 		grpcsrv.GrpcServerPanicCapture(),
 	)

pkg/common/startrpc/tools.go

@@ -1,39 +0,0 @@
-package startrpc
-
-import (
-	"reflect"
-
-	conf "github.com/openimsdk/open-im-server/v3/pkg/common/config"
-)
-
-func getConfig[T any](value reflect.Value) *T {
-	for value.Kind() == reflect.Pointer {
-		value = value.Elem()
-	}
-	if value.Kind() == reflect.Struct {
-		num := value.NumField()
-		for i := 0; i < num; i++ {
-			field := value.Field(i)
-			for field.Kind() == reflect.Pointer {
-				field = field.Elem()
-			}
-			if field.Kind() == reflect.Struct {
-				if elem, ok := field.Interface().(T); ok {
-					return &elem
-				}
-				if elem := getConfig[T](field); elem != nil {
-					return elem
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func getConfigRpcMaxRequestBody(value reflect.Value) *conf.MaxRequestBody {
-	return getConfig[conf.MaxRequestBody](value)
-}
-
-func getConfigShare(value reflect.Value) *conf.Share {
-	return getConfig[conf.Share](value)
-}

pkg/common/storage/cache/mcache/minio.go

@@ -1,50 +0,0 @@
-package mcache
-
-import (
-	"context"
-	"time"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
-	"github.com/openimsdk/tools/s3/minio"
-)
-
-func NewMinioCache(cache database.Cache) minio.Cache {
-	return &minioCache{
-		cache:      cache,
-		expireTime: time.Hour * 24 * 7,
-	}
-}
-
-type minioCache struct {
-	cache      database.Cache
-	expireTime time.Duration
-}
-
-func (g *minioCache) getObjectImageInfoKey(key string) string {
-	return cachekey.GetObjectImageInfoKey(key)
-}
-
-func (g *minioCache) getMinioImageThumbnailKey(key string, format string, width int, height int) string {
-	return cachekey.GetMinioImageThumbnailKey(key, format, width, height)
-}
-
-func (g *minioCache) DelObjectImageInfoKey(ctx context.Context, keys ...string) error {
-	ks := make([]string, 0, len(keys))
-	for _, key := range keys {
-		ks = append(ks, g.getObjectImageInfoKey(key))
-	}
-	return g.cache.Del(ctx, ks)
-}
-
-func (g *minioCache) DelImageThumbnailKey(ctx context.Context, key string, format string, width int, height int) error {
-	return g.cache.Del(ctx, []string{g.getMinioImageThumbnailKey(key, format, width, height)})
-}
-
-func (g *minioCache) GetImageObjectKeyInfo(ctx context.Context, key string, fn func(ctx context.Context) (*minio.ImageInfo, error)) (*minio.ImageInfo, error) {
-	return getCache[*minio.ImageInfo](ctx, g.cache, g.getObjectImageInfoKey(key), g.expireTime, fn)
-}
-
-func (g *minioCache) GetThumbnailKey(ctx context.Context, key string, format string, width int, height int, minioCache func(ctx context.Context) (string, error)) (string, error) {
-	return getCache[string](ctx, g.cache, g.getMinioImageThumbnailKey(key, format, width, height), g.expireTime, minioCache)
-}

pkg/common/storage/cache/mcache/msg_cache.go

@@ -1,132 +0,0 @@
-package mcache
-
-import (
-	"context"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
-	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
-	"github.com/openimsdk/open-im-server/v3/pkg/localcache/lru"
-	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/utils/datautil"
-	"github.com/redis/go-redis/v9"
-)
-
-var (
-	memMsgCache     lru.LRU[string, *model.MsgInfoModel]
-	initMemMsgCache sync.Once
-)
-
-func NewMsgCache(cache database.Cache, msgDocDatabase database.Msg) cache.MsgCache {
-	initMemMsgCache.Do(func() {
-		memMsgCache = lru.NewLayLRU[string, *model.MsgInfoModel](1024*8, time.Hour, time.Second*10, localcache.EmptyTarget{}, nil)
-	})
-	return &msgCache{
-		cache:          cache,
-		msgDocDatabase: msgDocDatabase,
-		memMsgCache:    memMsgCache,
-	}
-}
-
-type msgCache struct {
-	cache          database.Cache
-	msgDocDatabase database.Msg
-	memMsgCache    lru.LRU[string, *model.MsgInfoModel]
-}
-
-func (x *msgCache) getSendMsgKey(id string) string {
-	return cachekey.GetSendMsgKey(id)
-}
-
-func (x *msgCache) SetSendMsgStatus(ctx context.Context, id string, status int32) error {
-	return x.cache.Set(ctx, x.getSendMsgKey(id), strconv.Itoa(int(status)), time.Hour*24)
-}
-
-func (x *msgCache) GetSendMsgStatus(ctx context.Context, id string) (int32, error) {
-	key := x.getSendMsgKey(id)
-	res, err := x.cache.Get(ctx, []string{key})
-	if err != nil {
-		return 0, err
-	}
-	val, ok := res[key]
-	if !ok {
-		return 0, errs.Wrap(redis.Nil)
-	}
-	status, err := strconv.Atoi(val)
-	if err != nil {
-		return 0, errs.WrapMsg(err, "GetSendMsgStatus strconv.Atoi error", "val", val)
-	}
-	return int32(status), nil
-}
-
-func (x *msgCache) getMsgCacheKey(conversationID string, seq int64) string {
-	return cachekey.GetMsgCacheKey(conversationID, seq)
-
-}
-
-func (x *msgCache) GetMessageBySeqs(ctx context.Context, conversationID string, seqs []int64) ([]*model.MsgInfoModel, error) {
-	if len(seqs) == 0 {
-		return nil, nil
-	}
-	keys := make([]string, 0, len(seqs))
-	keySeq := make(map[string]int64, len(seqs))
-	for _, seq := range seqs {
-		key := x.getMsgCacheKey(conversationID, seq)
-		keys = append(keys, key)
-		keySeq[key] = seq
-	}
-	res, err := x.memMsgCache.GetBatch(keys, func(keys []string) (map[string]*model.MsgInfoModel, error) {
-		findSeqs := make([]int64, 0, len(keys))
-		for _, key := range keys {
-			seq, ok := keySeq[key]
-			if !ok {
-				continue
-			}
-			findSeqs = append(findSeqs, seq)
-		}
-		res, err := x.msgDocDatabase.FindSeqs(ctx, conversationID, seqs)
-		if err != nil {
-			return nil, err
-		}
-		kv := make(map[string]*model.MsgInfoModel)
-		for i := range res {
-			msg := res[i]
-			if msg == nil || msg.Msg == nil || msg.Msg.Seq <= 0 {
-				continue
-			}
-			key := x.getMsgCacheKey(conversationID, msg.Msg.Seq)
-			kv[key] = msg
-		}
-		return kv, nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return datautil.Values(res), nil
-}
-
-func (x msgCache) DelMessageBySeqs(ctx context.Context, conversationID string, seqs []int64) error {
-	if len(seqs) == 0 {
-		return nil
-	}
-	for _, seq := range seqs {
-		x.memMsgCache.Del(x.getMsgCacheKey(conversationID, seq))
-	}
-	return nil
-}
-
-func (x *msgCache) SetMessageBySeqs(ctx context.Context, conversationID string, msgs []*model.MsgInfoModel) error {
-	for i := range msgs {
-		msg := msgs[i]
-		if msg == nil || msg.Msg == nil || msg.Msg.Seq <= 0 {
-			continue
-		}
-		x.memMsgCache.Set(x.getMsgCacheKey(conversationID, msg.Msg.Seq), msg)
-	}
-	return nil
-}

pkg/common/storage/cache/mcache/online.go

@@ -1,82 +0,0 @@
-package mcache
-
-import (
-	"context"
-	"sync"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
-)
-
-var (
-	globalOnlineCache cache.OnlineCache
-	globalOnlineOnce  sync.Once
-)
-
-func NewOnlineCache() cache.OnlineCache {
-	globalOnlineOnce.Do(func() {
-		globalOnlineCache = &onlineCache{
-			user: make(map[string]map[int32]struct{}),
-		}
-	})
-	return globalOnlineCache
-}
-
-type onlineCache struct {
-	lock sync.RWMutex
-	user map[string]map[int32]struct{}
-}
-
-func (x *onlineCache) GetOnline(ctx context.Context, userID string) ([]int32, error) {
-	x.lock.RLock()
-	defer x.lock.RUnlock()
-	pSet, ok := x.user[userID]
-	if !ok {
-		return nil, nil
-	}
-	res := make([]int32, 0, len(pSet))
-	for k := range pSet {
-		res = append(res, k)
-	}
-	return res, nil
-}
-
-func (x *onlineCache) SetUserOnline(ctx context.Context, userID string, online, offline []int32) error {
-	x.lock.Lock()
-	defer x.lock.Unlock()
-	pSet, ok := x.user[userID]
-	if ok {
-		for _, p := range offline {
-			delete(pSet, p)
-		}
-	}
-	if len(online) > 0 {
-		if !ok {
-			pSet = make(map[int32]struct{})
-			x.user[userID] = pSet
-		}
-		for _, p := range online {
-			pSet[p] = struct{}{}
-		}
-	}
-	if len(pSet) == 0 {
-		delete(x.user, userID)
-	}
-	return nil
-}
-
-func (x *onlineCache) GetAllOnlineUsers(ctx context.Context, cursor uint64) (map[string][]int32, uint64, error) {
-	if cursor != 0 {
-		return nil, 0, nil
-	}
-	x.lock.RLock()
-	defer x.lock.RUnlock()
-	res := make(map[string][]int32)
-	for k, v := range x.user {
-		pSet := make([]int32, 0, len(v))
-		for p := range v {
-			pSet = append(pSet, p)
-		}
-		res[k] = pSet
-	}
-	return res, 0, nil
-}

pkg/common/storage/cache/mcache/seq_conversation.go

@@ -1,79 +0,0 @@
-package mcache
-
-import (
-	"context"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
-)
-
-func NewSeqConversationCache(sc database.SeqConversation) cache.SeqConversationCache {
-	return &seqConversationCache{
-		sc: sc,
-	}
-}
-
-type seqConversationCache struct {
-	sc database.SeqConversation
-}
-
-func (x *seqConversationCache) Malloc(ctx context.Context, conversationID string, size int64) (int64, error) {
-	return x.sc.Malloc(ctx, conversationID, size)
-}
-
-func (x *seqConversationCache) SetMinSeq(ctx context.Context, conversationID string, seq int64) error {
-	return x.sc.SetMinSeq(ctx, conversationID, seq)
-}
-
-func (x *seqConversationCache) GetMinSeq(ctx context.Context, conversationID string) (int64, error) {
-	return x.sc.GetMinSeq(ctx, conversationID)
-}
-
-func (x *seqConversationCache) GetMaxSeqs(ctx context.Context, conversationIDs []string) (map[string]int64, error) {
-	res := make(map[string]int64)
-	for _, conversationID := range conversationIDs {
-		seq, err := x.GetMinSeq(ctx, conversationID)
-		if err != nil {
-			return nil, err
-		}
-		res[conversationID] = seq
-	}
-	return res, nil
-}
-
-func (x *seqConversationCache) GetMaxSeqsWithTime(ctx context.Context, conversationIDs []string) (map[string]database.SeqTime, error) {
-	res := make(map[string]database.SeqTime)
-	for _, conversationID := range conversationIDs {
-		seq, err := x.GetMinSeq(ctx, conversationID)
-		if err != nil {
-			return nil, err
-		}
-		res[conversationID] = database.SeqTime{Seq: seq}
-	}
-	return res, nil
-}
-
-func (x *seqConversationCache) GetMaxSeq(ctx context.Context, conversationID string) (int64, error) {
-	return x.sc.GetMaxSeq(ctx, conversationID)
-}
-
-func (x *seqConversationCache) GetMaxSeqWithTime(ctx context.Context, conversationID string) (database.SeqTime, error) {
-	seq, err := x.GetMinSeq(ctx, conversationID)
-	if err != nil {
-		return database.SeqTime{}, err
-	}
-	return database.SeqTime{Seq: seq}, nil
-}
-
-func (x *seqConversationCache) SetMinSeqs(ctx context.Context, seqs map[string]int64) error {
-	for conversationID, seq := range seqs {
-		if err := x.sc.SetMinSeq(ctx, conversationID, seq); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (x *seqConversationCache) GetCacheMaxSeqWithTime(ctx context.Context, conversationIDs []string) (map[string]database.SeqTime, error) {
-	return x.GetMaxSeqsWithTime(ctx, conversationIDs)
-}

pkg/common/storage/cache/mcache/third.go

@@ -1,98 +0,0 @@
-package mcache
-
-import (
-	"context"
-	"strconv"
-	"time"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
-	"github.com/openimsdk/tools/errs"
-	"github.com/redis/go-redis/v9"
-)
-
-func NewThirdCache(cache database.Cache) cache.ThirdCache {
-	return &thirdCache{
-		cache: cache,
-	}
-}
-
-type thirdCache struct {
-	cache database.Cache
-}
-
-func (c *thirdCache) getGetuiTokenKey() string {
-	return cachekey.GetGetuiTokenKey()
-}
-
-func (c *thirdCache) getGetuiTaskIDKey() string {
-	return cachekey.GetGetuiTaskIDKey()
-}
-
-func (c *thirdCache) getUserBadgeUnreadCountSumKey(userID string) string {
-	return cachekey.GetUserBadgeUnreadCountSumKey(userID)
-}
-
-func (c *thirdCache) getFcmAccountTokenKey(account string, platformID int) string {
-	return cachekey.GetFcmAccountTokenKey(account, platformID)
-}
-
-func (c *thirdCache) get(ctx context.Context, key string) (string, error) {
-	res, err := c.cache.Get(ctx, []string{key})
-	if err != nil {
-		return "", err
-	}
-	if val, ok := res[key]; ok {
-		return val, nil
-	}
-	return "", errs.Wrap(redis.Nil)
-}
-
-func (c *thirdCache) SetFcmToken(ctx context.Context, account string, platformID int, fcmToken string, expireTime int64) (err error) {
-	return errs.Wrap(c.cache.Set(ctx, c.getFcmAccountTokenKey(account, platformID), fcmToken, time.Duration(expireTime)*time.Second))
-}
-
-func (c *thirdCache) GetFcmToken(ctx context.Context, account string, platformID int) (string, error) {
-	return c.get(ctx, c.getFcmAccountTokenKey(account, platformID))
-}
-
-func (c *thirdCache) DelFcmToken(ctx context.Context, account string, platformID int) error {
-	return c.cache.Del(ctx, []string{c.getFcmAccountTokenKey(account, platformID)})
-}
-
-func (c *thirdCache) IncrUserBadgeUnreadCountSum(ctx context.Context, userID string) (int, error) {
-	return c.cache.Incr(ctx, c.getUserBadgeUnreadCountSumKey(userID), 1)
-}
-
-func (c *thirdCache) SetUserBadgeUnreadCountSum(ctx context.Context, userID string, value int) error {
-	return c.cache.Set(ctx, c.getUserBadgeUnreadCountSumKey(userID), strconv.Itoa(value), 0)
-}
-
-func (c *thirdCache) GetUserBadgeUnreadCountSum(ctx context.Context, userID string) (int, error) {
-	str, err := c.get(ctx, c.getUserBadgeUnreadCountSumKey(userID))
-	if err != nil {
-		return 0, err
-	}
-	val, err := strconv.Atoi(str)
-	if err != nil {
-		return 0, errs.WrapMsg(err, "strconv.Atoi", "str", str)
-	}
-	return val, nil
-}
-
-func (c *thirdCache) SetGetuiToken(ctx context.Context, token string, expireTime int64) error {
-	return c.cache.Set(ctx, c.getGetuiTokenKey(), token, time.Duration(expireTime)*time.Second)
-}
-
-func (c *thirdCache) GetGetuiToken(ctx context.Context) (string, error) {
-	return c.get(ctx, c.getGetuiTokenKey())
-}
-
-func (c *thirdCache) SetGetuiTaskID(ctx context.Context, taskID string, expireTime int64) error {
-	return c.cache.Set(ctx, c.getGetuiTaskIDKey(), taskID, time.Duration(expireTime)*time.Second)
-}
-
-func (c *thirdCache) GetGetuiTaskID(ctx context.Context) (string, error) {
-	return c.get(ctx, c.getGetuiTaskIDKey())
-}

pkg/common/storage/cache/mcache/tools.go

@@ -1,63 +0,0 @@
-package mcache
-
-import (
-	"context"
-	"encoding/json"
-	"time"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
-	"github.com/openimsdk/tools/log"
-)
-
-func getCache[V any](ctx context.Context, cache database.Cache, key string, expireTime time.Duration, fn func(ctx context.Context) (V, error)) (V, error) {
-	getDB := func() (V, bool, error) {
-		res, err := cache.Get(ctx, []string{key})
-		if err != nil {
-			var val V
-			return val, false, err
-		}
-		var val V
-		if str, ok := res[key]; ok {
-			if json.Unmarshal([]byte(str), &val) != nil {
-				return val, false, err
-			}
-			return val, true, nil
-		}
-		return val, false, nil
-	}
-	dbVal, ok, err := getDB()
-	if err != nil {
-		return dbVal, err
-	}
-	if ok {
-		return dbVal, nil
-	}
-	lockValue, err := cache.Lock(ctx, key, time.Minute)
-	if err != nil {
-		return dbVal, err
-	}
-	defer func() {
-		if err := cache.Unlock(ctx, key, lockValue); err != nil {
-			log.ZError(ctx, "unlock cache key", err, "key", key, "value", lockValue)
-		}
-	}()
-	dbVal, ok, err = getDB()
-	if err != nil {
-		return dbVal, err
-	}
-	if ok {
-		return dbVal, nil
-	}
-	val, err := fn(ctx)
-	if err != nil {
-		return val, err
-	}
-	data, err := json.Marshal(val)
-	if err != nil {
-		return val, err
-	}
-	if err := cache.Set(ctx, key, string(data), expireTime); err != nil {
-		return val, err
-	}
-	return val, nil
-}

pkg/common/storage/cache/redis/batch.go

@@ -3,65 +3,28 @@ package redis
 import (
 	"context"
 	"encoding/json"
-	"time"
-
 	"github.com/dtm-labs/rockscache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/redis/go-redis/v9"
+	"golang.org/x/sync/singleflight"
+	"time"
+	"unsafe"
 )
 
-// GetRocksCacheOptions returns the default configuration options for RocksCache.
-func GetRocksCacheOptions() *rockscache.Options {
-	opts := rockscache.NewDefaultOptions()
-	opts.LockExpire = rocksCacheTimeout
-	opts.WaitReplicasTimeout = rocksCacheTimeout
-	opts.StrongConsistency = true
-	opts.RandomExpireAdjustment = 0.2
-
-	return &opts
-}
-
-func newRocksCacheClient(rdb redis.UniversalClient) *rocksCacheClient {
-	if rdb == nil {
-		return &rocksCacheClient{}
+func getRocksCacheRedisClient(cli *rockscache.Client) redis.UniversalClient {
+	type Client struct {
+		rdb redis.UniversalClient
+		_   rockscache.Options
+		_   singleflight.Group
 	}
-	rc := &rocksCacheClient{
-		rdb:    rdb,
-		client: rockscache.NewClient(rdb, *GetRocksCacheOptions()),
-	}
-	return rc
+	return (*Client)(unsafe.Pointer(cli)).rdb
 }
 
-type rocksCacheClient struct {
-	rdb    redis.UniversalClient
-	client *rockscache.Client
-}
-
-func (x *rocksCacheClient) GetClient() *rockscache.Client {
-	return x.client
-}
-
-func (x *rocksCacheClient) Disable() bool {
-	return x.client == nil
-}
-
-func (x *rocksCacheClient) GetRedis() redis.UniversalClient {
-	return x.rdb
-}
-
-func (x *rocksCacheClient) GetBatchDeleter(topics ...string) cache.BatchDeleter {
-	return NewBatchDeleterRedis(x, topics)
-}
-
-func batchGetCache2[K comparable, V any](ctx context.Context, rcClient *rocksCacheClient, expire time.Duration, ids []K, idKey func(id K) string, vId func(v *V) K, fn func(ctx context.Context, ids []K) ([]*V, error)) ([]*V, error) {
+func batchGetCache2[K comparable, V any](ctx context.Context, rcClient *rockscache.Client, expire time.Duration, ids []K, idKey func(id K) string, vId func(v *V) K, fn func(ctx context.Context, ids []K) ([]*V, error)) ([]*V, error) {
 	if len(ids) == 0 {
 		return nil, nil
 	}
-	if rcClient.Disable() {
-		return fn(ctx, ids)
-	}
 	findKeys := make([]string, 0, len(ids))
 	keyId := make(map[string]K)
 	for _, id := range ids {
@@ -72,13 +35,13 @@ func batchGetCache2[K comparable, V any](ctx context.Context, rcClient *rocksCac
 		keyId[key] = id
 		findKeys = append(findKeys, key)
 	}
-	slotKeys, err := groupKeysBySlot(ctx, rcClient.GetRedis(), findKeys)
+	slotKeys, err := groupKeysBySlot(ctx, getRocksCacheRedisClient(rcClient), findKeys)
 	if err != nil {
 		return nil, err
 	}
 	result := make([]*V, 0, len(findKeys))
 	for _, keys := range slotKeys {
-		indexCache, err := rcClient.GetClient().FetchBatch2(ctx, keys, expire, func(idx []int) (map[int]string, error) {
+		indexCache, err := rcClient.FetchBatch2(ctx, keys, expire, func(idx []int) (map[int]string, error) {
 			queryIds := make([]K, 0, len(idx))
 			idIndex := make(map[K]int)
 			for _, index := range idx {

pkg/common/storage/cache/redis/batch_handler.go

@@ -1,11 +1,23 @@
+// 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 redis
 
 import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"time"
-
 	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
@@ -13,6 +25,7 @@ import (
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/redis/go-redis/v9"
+	"time"
 )
 
 const (
@@ -28,10 +41,10 @@ type BatchDeleterRedis struct {
 }
 
 // NewBatchDeleterRedis creates a new BatchDeleterRedis instance.
-func NewBatchDeleterRedis(rcClient *rocksCacheClient, redisPubTopics []string) *BatchDeleterRedis {
+func NewBatchDeleterRedis(redisClient redis.UniversalClient, options *rockscache.Options, redisPubTopics []string) *BatchDeleterRedis {
 	return &BatchDeleterRedis{
-		redisClient:    rcClient.GetRedis(),
-		rocksClient:    rcClient.GetClient(),
+		redisClient:    redisClient,
+		rocksClient:    rockscache.NewClient(redisClient, *options),
 		redisPubTopics: redisPubTopics,
 	}
 }
@@ -94,29 +107,21 @@ func (c *BatchDeleterRedis) AddKeys(keys ...string) {
 	c.keys = append(c.keys, keys...)
 }
 
-type disableBatchDeleter struct{}
+// GetRocksCacheOptions returns the default configuration options for RocksCache.
+func GetRocksCacheOptions() *rockscache.Options {
+	opts := rockscache.NewDefaultOptions()
+	opts.LockExpire = rocksCacheTimeout
+	opts.WaitReplicasTimeout = rocksCacheTimeout
+	opts.StrongConsistency = true
+	opts.RandomExpireAdjustment = 0.2
 
-func (x disableBatchDeleter) ChainExecDel(ctx context.Context) error {
-	return nil
+	return &opts
 }
 
-func (x disableBatchDeleter) ExecDelWithKeys(ctx context.Context, keys []string) error {
-	return nil
-}
-
-func (x disableBatchDeleter) Clone() cache.BatchDeleter {
-	return x
-}
-
-func (x disableBatchDeleter) AddKeys(keys ...string) {}
-
-func getCache[T any](ctx context.Context, rcClient *rocksCacheClient, key string, expire time.Duration, fn func(ctx context.Context) (T, error)) (T, error) {
-	if rcClient.Disable() {
-		return fn(ctx)
-	}
+func getCache[T any](ctx context.Context, rcClient *rockscache.Client, key string, expire time.Duration, fn func(ctx context.Context) (T, error)) (T, error) {
 	var t T
 	var write bool
-	v, err := rcClient.GetClient().Fetch2(ctx, key, expire, func() (s string, err error) {
+	v, err := rcClient.Fetch2(ctx, key, expire, func() (s string, err error) {
 		t, err = fn(ctx)
 		if err != nil {
 			//log.ZError(ctx, "getCache query database failed", err, "key", key)
@@ -147,3 +152,31 @@ func getCache[T any](ctx context.Context, rcClient *rocksCacheClient, key string
 
 	return t, nil
 }
+
+//func batchGetCache[T any, K comparable](
+//	ctx context.Context,
+//	rcClient *rockscache.Client,
+//	expire time.Duration,
+//	keys []K,
+//	keyFn func(key K) string,
+//	fns func(ctx context.Context, key K) (T, error),
+//) ([]T, error) {
+//	if len(keys) == 0 {
+//		return nil, nil
+//	}
+//	res := make([]T, 0, len(keys))
+//	for _, key := range keys {
+//		val, err := getCache(ctx, rcClient, keyFn(key), expire, func(ctx context.Context) (T, error) {
+//			return fns(ctx, key)
+//		})
+//		if err != nil {
+//			if errs.ErrRecordNotFound.Is(specialerror.ErrCode(errs.Unwrap(err))) {
+//				continue
+//			}
+//			return nil, errs.Wrap(err)
+//		}
+//		res = append(res, val)
+//	}
+//
+//	return res, nil
+//}

pkg/common/storage/cache/redis/black.go

@@ -1,14 +1,29 @@
+// 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 redis
 
 import (
 	"context"
-	"time"
-
+	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
+	"github.com/openimsdk/tools/log"
 	"github.com/redis/go-redis/v9"
+	"time"
 )
 
 const (
@@ -18,16 +33,18 @@ const (
 type BlackCacheRedis struct {
 	cache.BatchDeleter
 	expireTime time.Duration
-	rcClient   *rocksCacheClient
+	rcClient   *rockscache.Client
 	blackDB    database.Black
 }
 
-func NewBlackCacheRedis(rdb redis.UniversalClient, localCache *config.LocalCache, blackDB database.Black) cache.BlackCache {
-	rc := newRocksCacheClient(rdb)
+func NewBlackCacheRedis(rdb redis.UniversalClient, localCache *config.LocalCache, blackDB database.Black, options *rockscache.Options) cache.BlackCache {
+	batchHandler := NewBatchDeleterRedis(rdb, options, []string{localCache.Friend.Topic})
+	b := localCache.Friend
+	log.ZDebug(context.Background(), "black local cache init", "Topic", b.Topic, "SlotNum", b.SlotNum, "SlotSize", b.SlotSize, "enable", b.Enable())
 	return &BlackCacheRedis{
-		BatchDeleter: rc.GetBatchDeleter(localCache.Friend.Topic),
+		BatchDeleter: batchHandler,
 		expireTime:   blackExpireTime,
-		rcClient:     rc,
+		rcClient:     rockscache.NewClient(rdb, *options),
 		blackDB:      blackDB,
 	}
 }

pkg/common/storage/cache/redis/conversation.go

@@ -1,30 +1,47 @@
+// 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 redis
 
 import (
 	"context"
-	"math/big"
-	"strings"
-	"time"
-
+	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
+	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/openimsdk/tools/utils/encrypt"
 	"github.com/redis/go-redis/v9"
+	"math/big"
+	"strings"
+	"time"
 )
 
 const (
 	conversationExpireTime = time.Second * 60 * 60 * 12
 )
 
-func NewConversationRedis(rdb redis.UniversalClient, localCache *config.LocalCache, db database.Conversation) cache.ConversationCache {
-	rc := newRocksCacheClient(rdb)
+func NewConversationRedis(rdb redis.UniversalClient, localCache *config.LocalCache, opts *rockscache.Options, db database.Conversation) cache.ConversationCache {
+	batchHandler := NewBatchDeleterRedis(rdb, opts, []string{localCache.Conversation.Topic})
+	c := localCache.Conversation
+	log.ZDebug(context.Background(), "conversation local cache init", "Topic", c.Topic, "SlotNum", c.SlotNum, "SlotSize", c.SlotSize, "enable", c.Enable())
 	return &ConversationRedisCache{
-		BatchDeleter:   rc.GetBatchDeleter(localCache.Conversation.Topic),
-		rcClient:       rc,
+		BatchDeleter:   batchHandler,
+		rcClient:       rockscache.NewClient(rdb, *opts),
 		conversationDB: db,
 		expireTime:     conversationExpireTime,
 	}
@@ -32,7 +49,7 @@ func NewConversationRedis(rdb redis.UniversalClient, localCache *config.LocalCac
 
 type ConversationRedisCache struct {
 	cache.BatchDeleter
-	rcClient       *rocksCacheClient
+	rcClient       *rockscache.Client
 	conversationDB database.Conversation
 	expireTime     time.Duration
 }

pkg/common/storage/cache/redis/doc.go

@@ -0,0 +1,15 @@
+// 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 redis

pkg/common/storage/cache/redis/friend.go

@@ -1,14 +1,30 @@
+// 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 redis
 
 import (
 	"context"
 	"time"
 
+	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
+	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/redis/go-redis/v9"
 )
@@ -22,18 +38,21 @@ type FriendCacheRedis struct {
 	cache.BatchDeleter
 	friendDB   database.Friend
 	expireTime time.Duration
-	rcClient   *rocksCacheClient
+	rcClient   *rockscache.Client
 	syncCount  int
 }
 
 // NewFriendCacheRedis creates a new instance of FriendCacheRedis.
-func NewFriendCacheRedis(rdb redis.UniversalClient, localCache *config.LocalCache, friendDB database.Friend) cache.FriendCache {
-	rc := newRocksCacheClient(rdb)
+func NewFriendCacheRedis(rdb redis.UniversalClient, localCache *config.LocalCache, friendDB database.Friend,
+	options *rockscache.Options) cache.FriendCache {
+	batchHandler := NewBatchDeleterRedis(rdb, options, []string{localCache.Friend.Topic})
+	f := localCache.Friend
+	log.ZDebug(context.Background(), "friend local cache init", "Topic", f.Topic, "SlotNum", f.SlotNum, "SlotSize", f.SlotSize, "enable", f.Enable())
 	return &FriendCacheRedis{
-		BatchDeleter: rc.GetBatchDeleter(localCache.Friend.Topic),
+		BatchDeleter: batchHandler,
 		friendDB:     friendDB,
 		expireTime:   friendExpireTime,
-		rcClient:     rc,
+		rcClient:     rockscache.NewClient(rdb, *options),
 	}
 }
 

pkg/common/storage/cache/redis/group.go

@@ -1,3 +1,17 @@
+// 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 redis
 
 import (
@@ -5,6 +19,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
@@ -21,21 +36,34 @@ const (
 	groupExpireTime = time.Second * 60 * 60 * 12
 )
 
+var errIndex = errs.New("err index")
+
 type GroupCacheRedis struct {
 	cache.BatchDeleter
 	groupDB        database.Group
 	groupMemberDB  database.GroupMember
 	groupRequestDB database.GroupRequest
 	expireTime     time.Duration
-	rcClient       *rocksCacheClient
+	rcClient       *rockscache.Client
 	groupHash      cache.GroupHash
 }
 
-func NewGroupCacheRedis(rdb redis.UniversalClient, localCache *config.LocalCache, groupDB database.Group, groupMemberDB database.GroupMember, groupRequestDB database.GroupRequest, hashCode cache.GroupHash) cache.GroupCache {
-	rc := newRocksCacheClient(rdb)
+func NewGroupCacheRedis(
+	rdb redis.UniversalClient,
+	localCache *config.LocalCache,
+	groupDB database.Group,
+	groupMemberDB database.GroupMember,
+	groupRequestDB database.GroupRequest,
+	hashCode cache.GroupHash,
+	opts *rockscache.Options,
+) cache.GroupCache {
+	batchHandler := NewBatchDeleterRedis(rdb, opts, []string{localCache.Group.Topic})
+	g := localCache.Group
+	log.ZDebug(context.Background(), "group local cache init", "Topic", g.Topic, "SlotNum", g.SlotNum, "SlotSize", g.SlotSize, "enable", g.Enable())
+
 	return &GroupCacheRedis{
-		BatchDeleter:   rc.GetBatchDeleter(localCache.Group.Topic),
-		rcClient:       rc,
+		BatchDeleter:   batchHandler,
+		rcClient:       rockscache.NewClient(rdb, *opts),
 		expireTime:     groupExpireTime,
 		groupDB:        groupDB,
 		groupMemberDB:  groupMemberDB,

pkg/common/storage/cache/redis/minio.go

@@ -1,59 +0,0 @@
-package redis
-
-import (
-	"context"
-	"time"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
-	"github.com/openimsdk/tools/s3/minio"
-	"github.com/redis/go-redis/v9"
-)
-
-func NewMinioCache(rdb redis.UniversalClient) minio.Cache {
-	rc := newRocksCacheClient(rdb)
-	return &minioCacheRedis{
-		BatchDeleter: rc.GetBatchDeleter(),
-		rcClient:     rc,
-		expireTime:   time.Hour * 24 * 7,
-	}
-}
-
-type minioCacheRedis struct {
-	cache.BatchDeleter
-	rcClient   *rocksCacheClient
-	expireTime time.Duration
-}
-
-func (g *minioCacheRedis) getObjectImageInfoKey(key string) string {
-	return cachekey.GetObjectImageInfoKey(key)
-}
-
-func (g *minioCacheRedis) getMinioImageThumbnailKey(key string, format string, width int, height int) string {
-	return cachekey.GetMinioImageThumbnailKey(key, format, width, height)
-}
-
-func (g *minioCacheRedis) DelObjectImageInfoKey(ctx context.Context, keys ...string) error {
-	ks := make([]string, 0, len(keys))
-	for _, key := range keys {
-		ks = append(ks, g.getObjectImageInfoKey(key))
-	}
-	return g.BatchDeleter.ExecDelWithKeys(ctx, ks)
-}
-
-func (g *minioCacheRedis) DelImageThumbnailKey(ctx context.Context, key string, format string, width int, height int) error {
-	return g.BatchDeleter.ExecDelWithKeys(ctx, []string{g.getMinioImageThumbnailKey(key, format, width, height)})
-
-}
-
-func (g *minioCacheRedis) GetImageObjectKeyInfo(ctx context.Context, key string, fn func(ctx context.Context) (*minio.ImageInfo, error)) (*minio.ImageInfo, error) {
-	info, err := getCache(ctx, g.rcClient, g.getObjectImageInfoKey(key), g.expireTime, fn)
-	if err != nil {
-		return nil, err
-	}
-	return info, nil
-}
-
-func (g *minioCacheRedis) GetThumbnailKey(ctx context.Context, key string, format string, width int, height int, minioCache func(ctx context.Context) (string, error)) (string, error) {
-	return getCache(ctx, g.rcClient, g.getMinioImageThumbnailKey(key, format, width, height), g.expireTime, minioCache)
-}

pkg/common/storage/cache/redis/msg.go

@@ -3,8 +3,7 @@ package redis
 import (
 	"context"
 	"encoding/json"
-	"time"
-
+	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
@@ -12,6 +11,7 @@ import (
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/redis/go-redis/v9"
+	"time"
 ) //
 
 // msgCacheTimeout is  expiration time of message cache, 86400 seconds
@@ -19,13 +19,15 @@ const msgCacheTimeout = time.Hour * 24
 
 func NewMsgCache(client redis.UniversalClient, db database.Msg) cache.MsgCache {
 	return &msgCache{
-		rcClient:       newRocksCacheClient(client),
+		rdb:            client,
+		rcClient:       rockscache.NewClient(client, *GetRocksCacheOptions()),
 		msgDocDatabase: db,
 	}
 }
 
 type msgCache struct {
-	rcClient       *rocksCacheClient
+	rdb            redis.UniversalClient
+	rcClient       *rockscache.Client
 	msgDocDatabase database.Msg
 }
 
@@ -34,11 +36,11 @@ func (c *msgCache) getSendMsgKey(id string) string {
 }
 
 func (c *msgCache) SetSendMsgStatus(ctx context.Context, id string, status int32) error {
-	return errs.Wrap(c.rcClient.GetRedis().Set(ctx, c.getSendMsgKey(id), status, time.Hour*24).Err())
+	return errs.Wrap(c.rdb.Set(ctx, c.getSendMsgKey(id), status, time.Hour*24).Err())
 }
 
 func (c *msgCache) GetSendMsgStatus(ctx context.Context, id string) (int32, error) {
-	result, err := c.rcClient.GetRedis().Get(ctx, c.getSendMsgKey(id)).Int()
+	result, err := c.rdb.Get(ctx, c.getSendMsgKey(id)).Int()
 	return int32(result), errs.Wrap(err)
 }
 
@@ -65,12 +67,12 @@ func (c *msgCache) DelMessageBySeqs(ctx context.Context, conversationID string,
 	keys := datautil.Slice(seqs, func(seq int64) string {
 		return cachekey.GetMsgCacheKey(conversationID, seq)
 	})
-	slotKeys, err := groupKeysBySlot(ctx, c.rcClient.GetRedis(), keys)
+	slotKeys, err := groupKeysBySlot(ctx, getRocksCacheRedisClient(c.rcClient), keys)
 	if err != nil {
 		return err
 	}
 	for _, keys := range slotKeys {
-		if err := c.rcClient.GetClient().TagAsDeletedBatch2(ctx, keys); err != nil {
+		if err := c.rcClient.TagAsDeletedBatch2(ctx, keys); err != nil {
 			return err
 		}
 	}
@@ -86,7 +88,7 @@ func (c *msgCache) SetMessageBySeqs(ctx context.Context, conversationID string,
 		if err != nil {
 			return err
 		}
-		if err := c.rcClient.GetClient().RawSet(ctx, cachekey.GetMsgCacheKey(conversationID, msg.Msg.Seq), string(data), msgCacheTimeout); err != nil {
+		if err := c.rcClient.RawSet(ctx, cachekey.GetMsgCacheKey(conversationID, msg.Msg.Seq), string(data), msgCacheTimeout); err != nil {
 			return err
 		}
 	}

pkg/common/storage/cache/redis/online.go

@@ -3,24 +3,18 @@ package redis
 import (
 	"context"
 	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/mcache"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/redis/go-redis/v9"
+	"strconv"
+	"strings"
+	"time"
 )
 
 func NewUserOnline(rdb redis.UniversalClient) cache.OnlineCache {
-	if rdb == nil || config.Standalone() {
-		return mcache.NewOnlineCache()
-	}
 	return &userOnline{
 		rdb:         rdb,
 		expire:      cachekey.OnlineExpire,

pkg/common/storage/cache/redis/redis_shard_manager.go

@@ -2,7 +2,7 @@ package redis
 
 import (
 	"context"
-
+	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/redis/go-redis/v9"
@@ -28,83 +28,83 @@ type Config struct {
 // Option is a function type for configuring Config
 type Option func(c *Config)
 
-//// NewRedisShardManager creates a new RedisShardManager instance
-//func NewRedisShardManager(redisClient redis.UniversalClient, opts ...Option) *RedisShardManager {
-//	config := &Config{
-//		batchSize:       defaultBatchSize, // Default batch size is 50 keys
-//		continueOnError: false,
-//		concurrentLimit: defaultConcurrentLimit, // Default concurrent limit is 3
-//	}
-//	for _, opt := range opts {
-//		opt(config)
-//	}
-//	rsm := &RedisShardManager{
-//		redisClient: redisClient,
-//		config:      config,
-//	}
-//	return rsm
-//}
-//
-//// WithBatchSize sets the number of keys to process per batch
-//func WithBatchSize(size int) Option {
-//	return func(c *Config) {
-//		c.batchSize = size
-//	}
-//}
-//
-//// WithContinueOnError sets whether to continue processing on error
-//func WithContinueOnError(continueOnError bool) Option {
-//	return func(c *Config) {
-//		c.continueOnError = continueOnError
-//	}
-//}
-//
-//// WithConcurrentLimit sets the concurrency limit
-//func WithConcurrentLimit(limit int) Option {
-//	return func(c *Config) {
-//		c.concurrentLimit = limit
-//	}
-//}
-//
-//// ProcessKeysBySlot groups keys by their Redis cluster hash slots and processes them using the provided function.
-//func (rsm *RedisShardManager) ProcessKeysBySlot(
-//	ctx context.Context,
-//	keys []string,
-//	processFunc func(ctx context.Context, slot int64, keys []string) error,
-//) error {
-//
-//	// Group keys by slot
-//	slots, err := groupKeysBySlot(ctx, rsm.redisClient, keys)
-//	if err != nil {
-//		return err
-//	}
-//
-//	g, ctx := errgroup.WithContext(ctx)
-//	g.SetLimit(rsm.config.concurrentLimit)
-//
-//	// Process keys in each slot using the provided function
-//	for slot, singleSlotKeys := range slots {
-//		batches := splitIntoBatches(singleSlotKeys, rsm.config.batchSize)
-//		for _, batch := range batches {
-//			slot, batch := slot, batch // Avoid closure capture issue
-//			g.Go(func() error {
-//				err := processFunc(ctx, slot, batch)
-//				if err != nil {
-//					log.ZWarn(ctx, "Batch processFunc failed", err, "slot", slot, "keys", batch)
-//					if !rsm.config.continueOnError {
-//						return err
-//					}
-//				}
-//				return nil
-//			})
-//		}
-//	}
-//
-//	if err := g.Wait(); err != nil {
-//		return err
-//	}
-//	return nil
-//}
+// NewRedisShardManager creates a new RedisShardManager instance
+func NewRedisShardManager(redisClient redis.UniversalClient, opts ...Option) *RedisShardManager {
+	config := &Config{
+		batchSize:       defaultBatchSize, // Default batch size is 50 keys
+		continueOnError: false,
+		concurrentLimit: defaultConcurrentLimit, // Default concurrent limit is 3
+	}
+	for _, opt := range opts {
+		opt(config)
+	}
+	rsm := &RedisShardManager{
+		redisClient: redisClient,
+		config:      config,
+	}
+	return rsm
+}
+
+// WithBatchSize sets the number of keys to process per batch
+func WithBatchSize(size int) Option {
+	return func(c *Config) {
+		c.batchSize = size
+	}
+}
+
+// WithContinueOnError sets whether to continue processing on error
+func WithContinueOnError(continueOnError bool) Option {
+	return func(c *Config) {
+		c.continueOnError = continueOnError
+	}
+}
+
+// WithConcurrentLimit sets the concurrency limit
+func WithConcurrentLimit(limit int) Option {
+	return func(c *Config) {
+		c.concurrentLimit = limit
+	}
+}
+
+// ProcessKeysBySlot groups keys by their Redis cluster hash slots and processes them using the provided function.
+func (rsm *RedisShardManager) ProcessKeysBySlot(
+	ctx context.Context,
+	keys []string,
+	processFunc func(ctx context.Context, slot int64, keys []string) error,
+) error {
+
+	// Group keys by slot
+	slots, err := groupKeysBySlot(ctx, rsm.redisClient, keys)
+	if err != nil {
+		return err
+	}
+
+	g, ctx := errgroup.WithContext(ctx)
+	g.SetLimit(rsm.config.concurrentLimit)
+
+	// Process keys in each slot using the provided function
+	for slot, singleSlotKeys := range slots {
+		batches := splitIntoBatches(singleSlotKeys, rsm.config.batchSize)
+		for _, batch := range batches {
+			slot, batch := slot, batch // Avoid closure capture issue
+			g.Go(func() error {
+				err := processFunc(ctx, slot, batch)
+				if err != nil {
+					log.ZWarn(ctx, "Batch processFunc failed", err, "slot", slot, "keys", batch)
+					if !rsm.config.continueOnError {
+						return err
+					}
+				}
+				return nil
+			})
+		}
+	}
+
+	if err := g.Wait(); err != nil {
+		return err
+	}
+	return nil
+}
 
 // groupKeysBySlot groups keys by their Redis cluster hash slots.
 func groupKeysBySlot(ctx context.Context, redisClient redis.UniversalClient, keys []string) (map[int64][]string, error) {
@@ -197,15 +197,15 @@ func ProcessKeysBySlot(
 	return nil
 }
 
-func DeleteCacheBySlot(ctx context.Context, rcClient *rocksCacheClient, keys []string) error {
+func DeleteCacheBySlot(ctx context.Context, rcClient *rockscache.Client, keys []string) error {
 	switch len(keys) {
 	case 0:
 		return nil
 	case 1:
-		return rcClient.GetClient().TagAsDeletedBatch2(ctx, keys)
+		return rcClient.TagAsDeletedBatch2(ctx, keys)
 	default:
-		return ProcessKeysBySlot(ctx, rcClient.GetRedis(), keys, func(ctx context.Context, slot int64, keys []string) error {
-			return rcClient.GetClient().TagAsDeletedBatch2(ctx, keys)
+		return ProcessKeysBySlot(ctx, getRocksCacheRedisClient(rcClient), keys, func(ctx context.Context, slot int64, keys []string) error {
+			return rcClient.TagAsDeletedBatch2(ctx, keys)
 		})
 	}
 }

pkg/common/storage/cache/redis/s3.go

@@ -1,23 +1,39 @@
+// 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 redis
 
 import (
 	"context"
-	"time"
-
+	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/tools/s3"
 	"github.com/openimsdk/tools/s3/cont"
+	"github.com/openimsdk/tools/s3/minio"
 	"github.com/redis/go-redis/v9"
+	"time"
 )
 
 func NewObjectCacheRedis(rdb redis.UniversalClient, objDB database.ObjectInfo) cache.ObjectCache {
-	rc := newRocksCacheClient(rdb)
+	opts := rockscache.NewDefaultOptions()
+	batchHandler := NewBatchDeleterRedis(rdb, &opts, nil)
 	return &objectCacheRedis{
-		BatchDeleter: rc.GetBatchDeleter(),
-		rcClient:     rc,
+		BatchDeleter: batchHandler,
+		rcClient:     rockscache.NewClient(rdb, opts),
 		expireTime:   time.Hour * 12,
 		objDB:        objDB,
 	}
@@ -26,7 +42,7 @@ func NewObjectCacheRedis(rdb redis.UniversalClient, objDB database.ObjectInfo) c
 type objectCacheRedis struct {
 	cache.BatchDeleter
 	objDB      database.ObjectInfo
-	rcClient   *rocksCacheClient
+	rcClient   *rockscache.Client
 	expireTime time.Duration
 }
 
@@ -60,10 +76,11 @@ func (g *objectCacheRedis) GetName(ctx context.Context, engine string, name stri
 }
 
 func NewS3Cache(rdb redis.UniversalClient, s3 s3.Interface) cont.S3Cache {
-	rc := newRocksCacheClient(rdb)
+	opts := rockscache.NewDefaultOptions()
+	batchHandler := NewBatchDeleterRedis(rdb, &opts, nil)
 	return &s3CacheRedis{
-		BatchDeleter: rc.GetBatchDeleter(),
-		rcClient:     rc,
+		BatchDeleter: batchHandler,
+		rcClient:     rockscache.NewClient(rdb, opts),
 		expireTime:   time.Hour * 12,
 		s3:           s3,
 	}
@@ -72,7 +89,7 @@ func NewS3Cache(rdb redis.UniversalClient, s3 s3.Interface) cont.S3Cache {
 type s3CacheRedis struct {
 	cache.BatchDeleter
 	s3         s3.Interface
-	rcClient   *rocksCacheClient
+	rcClient   *rockscache.Client
 	expireTime time.Duration
 }
 
@@ -93,3 +110,52 @@ func (g *s3CacheRedis) GetKey(ctx context.Context, engine string, name string) (
 		return g.s3.StatObject(ctx, name)
 	})
 }
+
+func NewMinioCache(rdb redis.UniversalClient) minio.Cache {
+	opts := rockscache.NewDefaultOptions()
+	batchHandler := NewBatchDeleterRedis(rdb, &opts, nil)
+	return &minioCacheRedis{
+		BatchDeleter: batchHandler,
+		rcClient:     rockscache.NewClient(rdb, opts),
+		expireTime:   time.Hour * 24 * 7,
+	}
+}
+
+type minioCacheRedis struct {
+	cache.BatchDeleter
+	rcClient   *rockscache.Client
+	expireTime time.Duration
+}
+
+func (g *minioCacheRedis) getObjectImageInfoKey(key string) string {
+	return cachekey.GetObjectImageInfoKey(key)
+}
+
+func (g *minioCacheRedis) getMinioImageThumbnailKey(key string, format string, width int, height int) string {
+	return cachekey.GetMinioImageThumbnailKey(key, format, width, height)
+}
+
+func (g *minioCacheRedis) DelObjectImageInfoKey(ctx context.Context, keys ...string) error {
+	ks := make([]string, 0, len(keys))
+	for _, key := range keys {
+		ks = append(ks, g.getObjectImageInfoKey(key))
+	}
+	return g.BatchDeleter.ExecDelWithKeys(ctx, ks)
+}
+
+func (g *minioCacheRedis) DelImageThumbnailKey(ctx context.Context, key string, format string, width int, height int) error {
+	return g.BatchDeleter.ExecDelWithKeys(ctx, []string{g.getMinioImageThumbnailKey(key, format, width, height)})
+
+}
+
+func (g *minioCacheRedis) GetImageObjectKeyInfo(ctx context.Context, key string, fn func(ctx context.Context) (*minio.ImageInfo, error)) (*minio.ImageInfo, error) {
+	info, err := getCache(ctx, g.rcClient, g.getObjectImageInfoKey(key), g.expireTime, fn)
+	if err != nil {
+		return nil, err
+	}
+	return info, nil
+}
+
+func (g *minioCacheRedis) GetThumbnailKey(ctx context.Context, key string, format string, width int, height int, minioCache func(ctx context.Context) (string, error)) (string, error) {
+	return getCache(ctx, g.rcClient, g.getMinioImageThumbnailKey(key, format, width, height), g.expireTime, minioCache)
+}

pkg/common/storage/cache/redis/seq_conversation.go

@@ -4,35 +4,33 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"strconv"
-	"time"
-
+	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/mcache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/redis/go-redis/v9"
+	"strconv"
+	"time"
 )
 
 func NewSeqConversationCacheRedis(rdb redis.UniversalClient, mgo database.SeqConversation) cache.SeqConversationCache {
-	if rdb == nil {
-		return mcache.NewSeqConversationCache(mgo)
-	}
 	return &seqConversationCacheRedis{
+		rdb:              rdb,
 		mgo:              mgo,
 		lockTime:         time.Second * 3,
 		dataTime:         time.Hour * 24 * 365,
 		minSeqExpireTime: time.Hour,
-		rcClient:         newRocksCacheClient(rdb),
+		rocks:            rockscache.NewClient(rdb, *GetRocksCacheOptions()),
 	}
 }
 
 type seqConversationCacheRedis struct {
+	rdb              redis.UniversalClient
 	mgo              database.SeqConversation
-	rcClient         *rocksCacheClient
+	rocks            *rockscache.Client
 	lockTime         time.Duration
 	dataTime         time.Duration
 	minSeqExpireTime time.Duration
@@ -47,7 +45,7 @@ func (s *seqConversationCacheRedis) SetMinSeq(ctx context.Context, conversationI
 }
 
 func (s *seqConversationCacheRedis) GetMinSeq(ctx context.Context, conversationID string) (int64, error) {
-	return getCache(ctx, s.rcClient, s.getMinSeqKey(conversationID), s.minSeqExpireTime, func(ctx context.Context) (int64, error) {
+	return getCache(ctx, s.rocks, s.getMinSeqKey(conversationID), s.minSeqExpireTime, func(ctx context.Context) (int64, error) {
 		return s.mgo.GetMinSeq(ctx, conversationID)
 	})
 }
@@ -70,7 +68,7 @@ func (s *seqConversationCacheRedis) getSingleMaxSeqWithTime(ctx context.Context,
 
 func (s *seqConversationCacheRedis) batchGetMaxSeq(ctx context.Context, keys []string, keyConversationID map[string]string, seqs map[string]int64) error {
 	result := make([]*redis.StringCmd, len(keys))
-	pipe := s.rcClient.GetRedis().Pipeline()
+	pipe := s.rdb.Pipeline()
 	for i, key := range keys {
 		result[i] = pipe.HGet(ctx, key, "CURR")
 	}
@@ -101,7 +99,7 @@ func (s *seqConversationCacheRedis) batchGetMaxSeq(ctx context.Context, keys []s
 
 func (s *seqConversationCacheRedis) batchGetMaxSeqWithTime(ctx context.Context, keys []string, keyConversationID map[string]string, seqs map[string]database.SeqTime) error {
 	result := make([]*redis.SliceCmd, len(keys))
-	pipe := s.rcClient.GetRedis().Pipeline()
+	pipe := s.rdb.Pipeline()
 	for i, key := range keys {
 		result[i] = pipe.HMGet(ctx, key, "CURR", "TIME")
 	}
@@ -159,7 +157,7 @@ func (s *seqConversationCacheRedis) GetMaxSeqs(ctx context.Context, conversation
 	if len(keys) == 1 {
 		return s.getSingleMaxSeq(ctx, conversationIDs[0])
 	}
-	slotKeys, err := groupKeysBySlot(ctx, s.rcClient.GetRedis(), keys)
+	slotKeys, err := groupKeysBySlot(ctx, s.rdb, keys)
 	if err != nil {
 		return nil, err
 	}
@@ -192,7 +190,7 @@ func (s *seqConversationCacheRedis) GetMaxSeqsWithTime(ctx context.Context, conv
 	if len(keys) == 1 {
 		return s.getSingleMaxSeqWithTime(ctx, conversationIDs[0])
 	}
-	slotKeys, err := groupKeysBySlot(ctx, s.rcClient.GetRedis(), keys)
+	slotKeys, err := groupKeysBySlot(ctx, s.rdb, keys)
 	if err != nil {
 		return nil, err
 	}
@@ -236,7 +234,7 @@ redis.call("HSET", key, "CURR", curr_seq, "LAST", last_seq, "TIME", mallocTime)
 redis.call("EXPIRE", key, dataSecond)
 return 0
 `
-	result, err := s.rcClient.GetRedis().Eval(ctx, script, []string{key}, owner, int64(s.dataTime/time.Second), currSeq, lastSeq, mill).Int64()
+	result, err := s.rdb.Eval(ctx, script, []string{key}, owner, int64(s.dataTime/time.Second), currSeq, lastSeq, mill).Int64()
 	if err != nil {
 		return 0, errs.Wrap(err)
 	}
@@ -307,7 +305,7 @@ table.insert(result, last_seq)
 table.insert(result, mallocTime)
 return result
 `
-	result, err := s.rcClient.GetRedis().Eval(ctx, script, []string{key}, size, int64(s.lockTime/time.Second), int64(s.dataTime/time.Second), time.Now().UnixMilli()).Int64Slice()
+	result, err := s.rdb.Eval(ctx, script, []string{key}, size, int64(s.lockTime/time.Second), int64(s.dataTime/time.Second), time.Now().UnixMilli()).Int64Slice()
 	if err != nil {
 		return nil, errs.Wrap(err)
 	}
@@ -440,7 +438,7 @@ func (s *seqConversationCacheRedis) SetMinSeqs(ctx context.Context, seqs map[str
 			return err
 		}
 	}
-	return DeleteCacheBySlot(ctx, s.rcClient, keys)
+	return DeleteCacheBySlot(ctx, s.rocks, keys)
 }
 
 // GetCacheMaxSeqWithTime only get the existing cache, if there is no cache, no cache will be generated
@@ -458,7 +456,7 @@ func (s *seqConversationCacheRedis) GetCacheMaxSeqWithTime(ctx context.Context,
 		key2conversationID[key] = conversationID
 		keys = append(keys, key)
 	}
-	slotKeys, err := groupKeysBySlot(ctx, s.rcClient.GetRedis(), keys)
+	slotKeys, err := groupKeysBySlot(ctx, s.rdb, keys)
 	if err != nil {
 		return nil, err
 	}
@@ -467,7 +465,7 @@ func (s *seqConversationCacheRedis) GetCacheMaxSeqWithTime(ctx context.Context,
 		if len(keys) == 0 {
 			continue
 		}
-		pipe := s.rcClient.GetRedis().Pipeline()
+		pipe := s.rdb.Pipeline()
 		cmds := make([]*redis.SliceCmd, 0, len(keys))
 		for _, key := range keys {
 			cmds = append(cmds, pipe.HMGet(ctx, key, "CURR", "TIME"))

pkg/common/storage/cache/redis/seq_user.go

@@ -2,29 +2,31 @@ package redis
 
 import (
 	"context"
-	"strconv"
-	"time"
-
+	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/tools/errs"
 	"github.com/redis/go-redis/v9"
+	"strconv"
+	"time"
 )
 
 func NewSeqUserCacheRedis(rdb redis.UniversalClient, mgo database.SeqUser) cache.SeqUser {
 	return &seqUserCacheRedis{
+		rdb:               rdb,
 		mgo:               mgo,
 		readSeqWriteRatio: 100,
 		expireTime:        time.Hour * 24 * 7,
 		readExpireTime:    time.Hour * 24 * 30,
-		rocks:             newRocksCacheClient(rdb),
+		rocks:             rockscache.NewClient(rdb, *GetRocksCacheOptions()),
 	}
 }
 
 type seqUserCacheRedis struct {
+	rdb               redis.UniversalClient
 	mgo               database.SeqUser
-	rocks             *rocksCacheClient
+	rocks             *rockscache.Client
 	expireTime        time.Duration
 	readExpireTime    time.Duration
 	readSeqWriteRatio int64
@@ -52,7 +54,7 @@ func (s *seqUserCacheRedis) SetUserMaxSeq(ctx context.Context, conversationID st
 	if err := s.mgo.SetUserMaxSeq(ctx, conversationID, userID, seq); err != nil {
 		return err
 	}
-	return s.rocks.GetClient().TagAsDeleted2(ctx, s.getSeqUserMaxSeqKey(conversationID, userID))
+	return s.rocks.TagAsDeleted2(ctx, s.getSeqUserMaxSeqKey(conversationID, userID))
 }
 
 func (s *seqUserCacheRedis) GetUserMinSeq(ctx context.Context, conversationID string, userID string) (int64, error) {
@@ -72,15 +74,12 @@ func (s *seqUserCacheRedis) GetUserReadSeq(ctx context.Context, conversationID s
 }
 
 func (s *seqUserCacheRedis) SetUserReadSeq(ctx context.Context, conversationID string, userID string, seq int64) error {
-	if s.rocks.GetRedis() == nil {
-		return s.SetUserReadSeqToDB(ctx, conversationID, userID, seq)
-	}
 	dbSeq, err := s.GetUserReadSeq(ctx, conversationID, userID)
 	if err != nil {
 		return err
 	}
 	if dbSeq < seq {
-		if err := s.rocks.GetClient().RawSet(ctx, s.getSeqUserReadSeqKey(conversationID, userID), strconv.Itoa(int(seq)), s.readExpireTime); err != nil {
+		if err := s.rocks.RawSet(ctx, s.getSeqUserReadSeqKey(conversationID, userID), strconv.Itoa(int(seq)), s.readExpireTime); err != nil {
 			return errs.Wrap(err)
 		}
 	}
@@ -110,12 +109,12 @@ func (s *seqUserCacheRedis) setUserRedisReadSeqs(ctx context.Context, userID str
 		keys = append(keys, key)
 		keySeq[key] = seq
 	}
-	slotKeys, err := groupKeysBySlot(ctx, s.rocks.GetRedis(), keys)
+	slotKeys, err := groupKeysBySlot(ctx, s.rdb, keys)
 	if err != nil {
 		return err
 	}
 	for _, keys := range slotKeys {
-		pipe := s.rocks.GetRedis().Pipeline()
+		pipe := s.rdb.Pipeline()
 		for _, key := range keys {
 			pipe.HSet(ctx, key, "value", strconv.FormatInt(keySeq[key], 10))
 			pipe.Expire(ctx, key, s.readExpireTime)

pkg/common/storage/cache/redis/third.go

@@ -1,13 +1,26 @@
+// 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 redis
 
 import (
 	"context"
-	"time"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/tools/errs"
 	"github.com/redis/go-redis/v9"
+	"time"
 )
 
 func NewThirdCache(rdb redis.UniversalClient) cache.ThirdCache {

pkg/common/storage/cache/redis/user.go

@@ -1,16 +1,30 @@
+// 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 redis
 
 import (
 	"context"
-	"time"
-
 	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
+	"github.com/openimsdk/tools/log"
 	"github.com/redis/go-redis/v9"
+	"time"
 )
 
 const (
@@ -24,17 +38,19 @@ type UserCacheRedis struct {
 	rdb        redis.UniversalClient
 	userDB     database.User
 	expireTime time.Duration
-	rcClient   *rocksCacheClient
+	rcClient   *rockscache.Client
 }
 
 func NewUserCacheRedis(rdb redis.UniversalClient, localCache *config.LocalCache, userDB database.User, options *rockscache.Options) cache.UserCache {
-	rc := newRocksCacheClient(rdb)
+	batchHandler := NewBatchDeleterRedis(rdb, options, []string{localCache.User.Topic})
+	u := localCache.User
+	log.ZDebug(context.Background(), "user local cache init", "Topic", u.Topic, "SlotNum", u.SlotNum, "SlotSize", u.SlotSize, "enable", u.Enable())
 	return &UserCacheRedis{
-		BatchDeleter: rc.GetBatchDeleter(localCache.User.Topic),
+		BatchDeleter: batchHandler,
 		rdb:          rdb,
 		userDB:       userDB,
 		expireTime:   userExpireTime,
-		rcClient:     rc,
+		rcClient:     rockscache.NewClient(rdb, *options),
 	}
 }
 

pkg/common/storage/controller/auth.go

@@ -44,8 +44,7 @@ func NewAuthDatabase(cache cache.TokenModel, accessSecret string, accessExpire i
 	return &authDatabase{cache: cache, accessSecret: accessSecret, accessExpire: accessExpire, multiLogin: multiLoginConfig{
 		Policy:       multiLogin.Policy,
 		MaxNumOneEnd: multiLogin.MaxNumOneEnd,
-	},
-		adminUserIDs: adminUserIDs,
+	}, adminUserIDs: adminUserIDs,
 	}
 }
 
@@ -86,10 +85,12 @@ func (a *authDatabase) BatchSetTokenMapByUidPid(ctx context.Context, tokens []st
 
 // Create Token.
 func (a *authDatabase) CreateToken(ctx context.Context, userID string, platformID int) (string, error) {
-	tokens, err := a.cache.GetAllTokensWithoutError(ctx, userID)
-	if err != nil {
-		return "", err
-	}
+	isAdmin := authverify.IsManagerUserID(userID, a.adminUserIDs)
+	if !isAdmin {
+		tokens, err := a.cache.GetAllTokensWithoutError(ctx, userID)
+		if err != nil {
+			return "", err
+		}
 
 	deleteTokenKey, kickedTokenKey, adminTokens, err := a.checkToken(ctx, tokens, platformID)
 	if err != nil {
@@ -125,8 +126,10 @@ func (a *authDatabase) CreateToken(ctx context.Context, userID string, platformI
 		return "", errs.WrapMsg(err, "token.SignedString")
 	}
 
-	if err = a.cache.SetTokenFlagEx(ctx, userID, platformID, tokenString, constant.NormalToken); err != nil {
-		return "", err
+	if !isAdmin {
+		if err = a.cache.SetTokenFlagEx(ctx, userID, platformID, tokenString, constant.NormalToken); err != nil {
+			return "", err
+		}
 	}
 
 	return tokenString, nil
@@ -238,6 +241,9 @@ func (a *authDatabase) checkToken(ctx context.Context, tokens map[int]map[string
 	}
 
 	//var adminTokenMaxNum = a.multiLogin.MaxNumOneEnd
+	//if a.multiLogin.Policy == constant.Customize {
+	//	adminTokenMaxNum = a.multiLogin.CustomizeLoginNum[constant.AdminPlatformID]
+	//}
 	//l := len(adminToken)
 	//if platformID == constant.AdminPlatformID {
 	//	l++

pkg/common/storage/controller/group.go

@@ -140,7 +140,7 @@ func NewGroupDatabase(
 		groupMemberDB:  groupMemberDB,
 		groupRequestDB: groupRequestDB,
 		ctxTx:          ctxTx,
-		cache:          redis2.NewGroupCacheRedis(rdb, localCache, groupDB, groupMemberDB, groupRequestDB, groupHash),
+		cache:          redis2.NewGroupCacheRedis(rdb, localCache, groupDB, groupMemberDB, groupRequestDB, groupHash, redis2.GetRocksCacheOptions()),
 	}
 }
 

pkg/common/storage/controller/msg.go

@@ -18,23 +18,22 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-
-	"github.com/openimsdk/tools/mq"
-	"github.com/openimsdk/tools/utils/jsonutil"
-	"google.golang.org/protobuf/proto"
-
 	"strconv"
 	"strings"
 	"time"
 
+	"github.com/openimsdk/tools/utils/jsonutil"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 
 	"github.com/redis/go-redis/v9"
 	"go.mongodb.org/mongo-driver/mongo"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/kafka"
 	"github.com/openimsdk/protocol/constant"
 	pbmsg "github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/protocol/sdkws"
@@ -103,14 +102,22 @@ type CommonMsgDatabase interface {
 	GetLastMessage(ctx context.Context, conversationIDS []string, userID string) (map[string]*sdkws.MsgData, error)
 }
 
-func NewCommonMsgDatabase(msgDocModel database.Msg, msg cache.MsgCache, seqUser cache.SeqUser, seqConversation cache.SeqConversationCache, producer mq.Producer) CommonMsgDatabase {
+func NewCommonMsgDatabase(msgDocModel database.Msg, msg cache.MsgCache, seqUser cache.SeqUser, seqConversation cache.SeqConversationCache, kafkaConf *config.Kafka) (CommonMsgDatabase, error) {
+	conf, err := kafka.BuildProducerConfig(*kafkaConf.Build())
+	if err != nil {
+		return nil, err
+	}
+	producerToRedis, err := kafka.NewKafkaProducer(conf, kafkaConf.Address, kafkaConf.ToRedisTopic)
+	if err != nil {
+		return nil, err
+	}
 	return &commonMsgDatabase{
 		msgDocDatabase:  msgDocModel,
 		msgCache:        msg,
 		seqUser:         seqUser,
 		seqConversation: seqConversation,
-		producer:        producer,
-	}
+		producer:        producerToRedis,
+	}, nil
 }
 
 type commonMsgDatabase struct {
@@ -119,15 +126,12 @@ type commonMsgDatabase struct {
 	msgCache        cache.MsgCache
 	seqConversation cache.SeqConversationCache
 	seqUser         cache.SeqUser
-	producer        mq.Producer
+	producer        *kafka.Producer
 }
 
 func (db *commonMsgDatabase) MsgToMQ(ctx context.Context, key string, msg2mq *sdkws.MsgData) error {
-	data, err := proto.Marshal(msg2mq)
-	if err != nil {
-		return err
-	}
-	return db.producer.SendMessage(ctx, key, data)
+	_, _, err := db.producer.SendMessage(ctx, key, msg2mq)
+	return err
 }
 
 func (db *commonMsgDatabase) batchInsertBlock(ctx context.Context, conversationID string, fields []any, key int8, firstSeq int64) error {

pkg/common/storage/controller/msg_transfer.go

@@ -2,15 +2,14 @@ package controller
 
 import (
 	"context"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	"github.com/openimsdk/protocol/constant"
-	"github.com/openimsdk/tools/mq"
 	"github.com/openimsdk/tools/utils/datautil"
-	"google.golang.org/protobuf/proto"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/kafka"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	pbmsg "github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/protocol/sdkws"
@@ -33,30 +32,30 @@ type MsgTransferDatabase interface {
 	SetHasReadSeqToDB(ctx context.Context, conversationID string, userSeqMap map[string]int64) error
 
 	// to mq
-	MsgToPushMQ(ctx context.Context, key, conversationID string, msg2mq *sdkws.MsgData) error
+	MsgToPushMQ(ctx context.Context, key, conversationID string, msg2mq *sdkws.MsgData) (int32, int64, error)
 	MsgToMongoMQ(ctx context.Context, key, conversationID string, msgs []*sdkws.MsgData, lastSeq int64) error
 }
 
-func NewMsgTransferDatabase(msgDocModel database.Msg, msg cache.MsgCache, seqUser cache.SeqUser, seqConversation cache.SeqConversationCache, mongoProducer, pushProducer mq.Producer) (MsgTransferDatabase, error) {
-	//conf, err := kafka.BuildProducerConfig(*kafkaConf.Build())
-	//if err != nil {
-	//	return nil, err
-	//}
-	//producerToMongo, err := kafka.NewKafkaProducerV2(conf, kafkaConf.Address, kafkaConf.ToMongoTopic)
-	//if err != nil {
-	//	return nil, err
-	//}
-	//producerToPush, err := kafka.NewKafkaProducerV2(conf, kafkaConf.Address, kafkaConf.ToPushTopic)
-	//if err != nil {
-	//	return nil, err
-	//}
+func NewMsgTransferDatabase(msgDocModel database.Msg, msg cache.MsgCache, seqUser cache.SeqUser, seqConversation cache.SeqConversationCache, kafkaConf *config.Kafka) (MsgTransferDatabase, error) {
+	conf, err := kafka.BuildProducerConfig(*kafkaConf.Build())
+	if err != nil {
+		return nil, err
+	}
+	producerToMongo, err := kafka.NewKafkaProducer(conf, kafkaConf.Address, kafkaConf.ToMongoTopic)
+	if err != nil {
+		return nil, err
+	}
+	producerToPush, err := kafka.NewKafkaProducer(conf, kafkaConf.Address, kafkaConf.ToPushTopic)
+	if err != nil {
+		return nil, err
+	}
 	return &msgTransferDatabase{
 		msgDocDatabase:  msgDocModel,
 		msgCache:        msg,
 		seqUser:         seqUser,
 		seqConversation: seqConversation,
-		producerToMongo: mongoProducer,
-		producerToPush:  pushProducer,
+		producerToMongo: producerToMongo,
+		producerToPush:  producerToPush,
 	}, nil
 }
 
@@ -66,8 +65,8 @@ type msgTransferDatabase struct {
 	msgCache        cache.MsgCache
 	seqConversation cache.SeqConversationCache
 	seqUser         cache.SeqUser
-	producerToMongo mq.Producer
-	producerToPush  mq.Producer
+	producerToMongo *kafka.Producer
+	producerToPush  *kafka.Producer
 }
 
 func (db *msgTransferDatabase) BatchInsertChat2DB(ctx context.Context, conversationID string, msgList []*sdkws.MsgData, currentMaxSeq int64) error {
@@ -81,10 +80,42 @@ func (db *msgTransferDatabase) BatchInsertChat2DB(ctx context.Context, conversat
 			continue
 		}
 		seqs[i] = msg.Seq
+		var offlinePushModel *model.OfflinePushModel
+		if msg.OfflinePushInfo != nil {
+			offlinePushModel = &model.OfflinePushModel{
+				Title:         msg.OfflinePushInfo.Title,
+				Desc:          msg.OfflinePushInfo.Desc,
+				Ex:            msg.OfflinePushInfo.Ex,
+				IOSPushSound:  msg.OfflinePushInfo.IOSPushSound,
+				IOSBadgeCount: msg.OfflinePushInfo.IOSBadgeCount,
+			}
+		}
 		if msg.Status == constant.MsgStatusSending {
 			msg.Status = constant.MsgStatusSendSuccess
 		}
-		msgs[i] = convert.MsgPb2DB(msg)
+		msgs[i] = &model.MsgDataModel{
+			SendID:           msg.SendID,
+			RecvID:           msg.RecvID,
+			GroupID:          msg.GroupID,
+			ClientMsgID:      msg.ClientMsgID,
+			ServerMsgID:      msg.ServerMsgID,
+			SenderPlatformID: msg.SenderPlatformID,
+			SenderNickname:   msg.SenderNickname,
+			SenderFaceURL:    msg.SenderFaceURL,
+			SessionType:      msg.SessionType,
+			MsgFrom:          msg.MsgFrom,
+			ContentType:      msg.ContentType,
+			Content:          string(msg.Content),
+			Seq:              msg.Seq,
+			SendTime:         msg.SendTime,
+			CreateTime:       msg.CreateTime,
+			Status:           msg.Status,
+			Options:          msg.Options,
+			OfflinePush:      offlinePushModel,
+			AtUserIDList:     msg.AtUserIDList,
+			AttachedInfo:     msg.AttachedInfo,
+			Ex:               msg.Ex,
+		}
 	}
 	if err := db.BatchInsertBlock(ctx, conversationID, msgs, updateKeyMsg, msgList[0].Seq); err != nil {
 		return err
@@ -250,25 +281,19 @@ func (db *msgTransferDatabase) SetHasReadSeqToDB(ctx context.Context, conversati
 	return nil
 }
 
-func (db *msgTransferDatabase) MsgToPushMQ(ctx context.Context, key, conversationID string, msg2mq *sdkws.MsgData) error {
-	data, err := proto.Marshal(&pbmsg.PushMsgDataToMQ{MsgData: msg2mq, ConversationID: conversationID})
+func (db *msgTransferDatabase) MsgToPushMQ(ctx context.Context, key, conversationID string, msg2mq *sdkws.MsgData) (int32, int64, error) {
+	partition, offset, err := db.producerToPush.SendMessage(ctx, key, &pbmsg.PushMsgDataToMQ{MsgData: msg2mq, ConversationID: conversationID})
 	if err != nil {
-		return err
+		log.ZError(ctx, "MsgToPushMQ", err, "key", key, "msg2mq", msg2mq)
+		return 0, 0, err
 	}
-	if err := db.producerToPush.SendMessage(ctx, key, data); err != nil {
-		log.ZError(ctx, "MsgToPushMQ", err, "key", key, "conversationID", conversationID)
-		return err
-	}
-	return nil
+	return partition, offset, nil
 }
 
 func (db *msgTransferDatabase) MsgToMongoMQ(ctx context.Context, key, conversationID string, messages []*sdkws.MsgData, lastSeq int64) error {
 	if len(messages) > 0 {
-		data, err := proto.Marshal(&pbmsg.MsgDataToMongoByMQ{LastSeq: lastSeq, ConversationID: conversationID, MsgData: messages})
+		_, _, err := db.producerToMongo.SendMessage(ctx, key, &pbmsg.MsgDataToMongoByMQ{LastSeq: lastSeq, ConversationID: conversationID, MsgData: messages})
 		if err != nil {
-			return err
-		}
-		if err := db.producerToMongo.SendMessage(ctx, key, data); err != nil {
 			log.ZError(ctx, "MsgToMongoMQ", err, "key", key, "conversationID", conversationID, "lastSeq", lastSeq)
 			return err
 		}

pkg/common/storage/controller/push.go

@@ -17,12 +17,12 @@ package controller
 import (
 	"context"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/kafka"
 	"github.com/openimsdk/protocol/push"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/mq"
-	"google.golang.org/protobuf/proto"
 )
 
 type PushDatabase interface {
@@ -32,13 +32,21 @@ type PushDatabase interface {
 
 type pushDataBase struct {
 	cache                 cache.ThirdCache
-	producerToOfflinePush mq.Producer
+	producerToOfflinePush *kafka.Producer
 }
 
-func NewPushDatabase(cache cache.ThirdCache, offlinePushProducer mq.Producer) PushDatabase {
+func NewPushDatabase(cache cache.ThirdCache, kafkaConf *config.Kafka) PushDatabase {
+	conf, err := kafka.BuildProducerConfig(*kafkaConf.Build())
+	if err != nil {
+		return nil
+	}
+	producerToOfflinePush, err := kafka.NewKafkaProducer(conf, kafkaConf.Address, kafkaConf.ToOfflinePushTopic)
+	if err != nil {
+		return nil
+	}
 	return &pushDataBase{
 		cache:                 cache,
-		producerToOfflinePush: offlinePushProducer,
+		producerToOfflinePush: producerToOfflinePush,
 	}
 }
 
@@ -47,12 +55,7 @@ func (p *pushDataBase) DelFcmToken(ctx context.Context, userID string, platformI
 }
 
 func (p *pushDataBase) MsgToOfflinePushMQ(ctx context.Context, key string, userIDs []string, msg2mq *sdkws.MsgData) error {
-	data, err := proto.Marshal(&push.PushMsgReq{MsgData: msg2mq, UserIDs: userIDs})
-	if err != nil {
-		return err
-	}
-	if err := p.producerToOfflinePush.SendMessage(ctx, key, data); err != nil {
-		log.ZError(ctx, "message is push to offlinePush topic", err, "key", key, "userIDs", userIDs, "msg", msg2mq.String())
-	}
+	_, _, err := p.producerToOfflinePush.SendMessage(ctx, key, &push.PushMsgReq{MsgData: msg2mq, UserIDs: userIDs})
+	log.ZInfo(ctx, "message is push to offlinePush topic", "key", key, "userIDs", userIDs, "msg", msg2mq.String())
 	return err
 }

pkg/common/storage/controller/user.go

@@ -21,12 +21,13 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/protocol/constant"
-	"github.com/openimsdk/protocol/user"
 	"github.com/openimsdk/tools/db/pagination"
 	"github.com/openimsdk/tools/db/tx"
-	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/utils/datautil"
 
+	"github.com/openimsdk/protocol/user"
+	"github.com/openimsdk/tools/errs"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 )
 

pkg/common/storage/database/black.go

@@ -16,7 +16,6 @@ package database
 
 import (
 	"context"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/tools/db/pagination"
 )
@@ -30,85 +29,3 @@ type Black interface {
 	FindOwnerBlackInfos(ctx context.Context, ownerUserID string, userIDs []string) (blacks []*model.Black, err error)
 	FindBlackUserIDs(ctx context.Context, ownerUserID string) (blackUserIDs []string, err error)
 }
-
-var (
-	_ Black = (*mgoImpl)(nil)
-	_ Black = (*redisImpl)(nil)
-)
-
-type mgoImpl struct {
-}
-
-func (m *mgoImpl) Create(ctx context.Context, blacks []*model.Black) (err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (m *mgoImpl) Delete(ctx context.Context, blacks []*model.Black) (err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (m *mgoImpl) Find(ctx context.Context, blacks []*model.Black) (blackList []*model.Black, err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (m *mgoImpl) Take(ctx context.Context, ownerUserID, blockUserID string) (black *model.Black, err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (m *mgoImpl) FindOwnerBlacks(ctx context.Context, ownerUserID string, pagination pagination.Pagination) (total int64, blacks []*model.Black, err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (m *mgoImpl) FindOwnerBlackInfos(ctx context.Context, ownerUserID string, userIDs []string) (blacks []*model.Black, err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (m *mgoImpl) FindBlackUserIDs(ctx context.Context, ownerUserID string) (blackUserIDs []string, err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-type redisImpl struct {
-}
-
-func (r *redisImpl) Create(ctx context.Context, blacks []*model.Black) (err error) {
-
-	//TODO implement me
-	panic("implement me")
-}
-
-func (r *redisImpl) Delete(ctx context.Context, blacks []*model.Black) (err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (r *redisImpl) Find(ctx context.Context, blacks []*model.Black) (blackList []*model.Black, err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (r *redisImpl) Take(ctx context.Context, ownerUserID, blockUserID string) (black *model.Black, err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (r *redisImpl) FindOwnerBlacks(ctx context.Context, ownerUserID string, pagination pagination.Pagination) (total int64, blacks []*model.Black, err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (r *redisImpl) FindOwnerBlackInfos(ctx context.Context, ownerUserID string, userIDs []string) (blacks []*model.Black, err error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (r *redisImpl) FindBlackUserIDs(ctx context.Context, ownerUserID string) (blackUserIDs []string, err error) {
-	//TODO implement me
-	panic("implement me")
-}