Merge b48fadcc8c3f8309f6fdf94e858ad19305930761 into bc4057f5e13c8cf7d449d71ae13e12c17cf2ccfd

feat: add rpc interface permission check [Created by @withchao from #3366]

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

@@ -113,14 +113,33 @@ jobs:
 
               echo "Cherry-picking commit: $merge_commit"
               if ! git cherry-pick "$merge_commit" --strategy=recursive -X theirs; then
-                echo "Cherry-pick encountered conflicts, attempting to continue..."
-                git cherry-pick --continue || { echo "Cherry-pick failed"; exit 1; }
+                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."
               fi
 
               git remote set-url origin "https://${BOT_TOKEN}@github.com/${{ github.repository }}.git"
               
               echo "Pushing branch: $cherry_pick_branch"
-              git push origin $cherry_pick_branch --force || { echo "Push failed"; exit 1; }
+              if ! git push origin $cherry_pick_branch --force; then
+                echo "Push failed, but continuing to create PR..."
+              fi
 
               new_pr_title="$pr_title [Created by @$pr_creator from #$pr_number]"
               new_pr_body="$pr_body

cmd/main.go

@@ -0,0 +1,419 @@
+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.81
+	github.com/openimsdk/tools v0.0.50-alpha.83
 	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.14-alpha.5
+	github.com/openimsdk/gomake v0.0.15-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,5 +219,3 @@ 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.81 h1:VbuJKtigNXLkCKB/Q6f2UHsqoSaTOAwS8F51c1nhOCA=
-github.com/openimsdk/tools v0.0.50-alpha.81/go.mod h1:n2poR3asX1e1XZce4O+MOWAp+X02QJRFvhcLCXZdzRo=
+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/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,16 +30,14 @@ type ConfigManager struct {
 	client        *clientv3.Client
 
 	configPath string
-	runtimeEnv string
 }
 
-func NewConfigManager(IMAdminUserID []string, cfg *config.AllConfig, client *clientv3.Client, configPath string, runtimeEnv string) *ConfigManager {
+func NewConfigManager(IMAdminUserID []string, cfg *config.AllConfig, client *clientv3.Client, configPath string) *ConfigManager {
 	cm := &ConfigManager{
 		imAdminUserID: IMAdminUserID,
 		config:        cfg,
 		client:        client,
 		configPath:    configPath,
-		runtimeEnv:    runtimeEnv,
 	}
 	return cm
 }
@@ -209,13 +207,7 @@ func (cm *ConfigManager) resetConfig(c *gin.Context, checkChange bool, ops ...cl
 
 	changedKeys := make([]string, 0, len(configMap))
 	for k, v := range configMap {
-		err := config.Load(
-			cm.configPath,
-			k,
-			config.EnvPrefixMap[k],
-			cm.runtimeEnv,
-			v.new,
-		)
+		err := config.Load(cm.configPath, k, config.EnvPrefixMap[k], v.new)
 		if err != nil {
 			log.ZError(c, "load config failed", err)
 			continue

internal/api/conversation.go

@@ -48,9 +48,9 @@ func (o *ConversationApi) SetConversations(c *gin.Context) {
 	a2r.Call(c, conversation.ConversationClient.SetConversations, o.Client)
 }
 
-func (o *ConversationApi) GetConversationOfflinePushUserIDs(c *gin.Context) {
-	a2r.Call(c, conversation.ConversationClient.GetConversationOfflinePushUserIDs, o.Client)
-}
+//func (o *ConversationApi) GetConversationOfflinePushUserIDs(c *gin.Context) {
+//	a2r.Call(c, conversation.ConversationClient.GetConversationOfflinePushUserIDs, o.Client)
+//}
 
 func (o *ConversationApi) GetFullOwnerConversationIDs(c *gin.Context) {
 	a2r.Call(c, conversation.ConversationClient.GetFullOwnerConversationIDs, o.Client)

internal/api/init.go

@@ -20,128 +20,61 @@ import (
 	"fmt"
 	"net"
 	"net/http"
-	"os"
-	"os/signal"
 	"strconv"
-	"syscall"
 	"time"
 
 	conf "github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	kdisc "github.com/openimsdk/open-im-server/v3/pkg/common/discovery"
-	disetcd "github.com/openimsdk/open-im-server/v3/pkg/common/discovery/etcd"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
-	"github.com/openimsdk/tools/discovery/etcd"
-	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/mw"
-	"github.com/openimsdk/tools/system/program"
 	"github.com/openimsdk/tools/utils/datautil"
-	"github.com/openimsdk/tools/utils/jsonutil"
 	"github.com/openimsdk/tools/utils/network"
 	"github.com/openimsdk/tools/utils/runtimeenv"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
 )
 
 type Config struct {
-	*conf.AllConfig
+	conf.AllConfig
 
-	RuntimeEnv string
-	ConfigPath string
+	ConfigPath conf.Path
+	Index      conf.Index
 }
 
-func Start(ctx context.Context, index int, config *Config) error {
-	apiPort, err := datautil.GetElemByIndex(config.API.Api.Ports, index)
+func Start(ctx context.Context, config *Config, client discovery.Conn, service grpc.ServiceRegistrar) error {
+	apiPort, err := datautil.GetElemByIndex(config.API.Api.Ports, int(config.Index))
 	if err != nil {
 		return err
 	}
 
-	config.RuntimeEnv = runtimeenv.RuntimeEnvironment()
-
-	client, err := kdisc.NewDiscoveryRegister(&config.Discovery, config.RuntimeEnv, []string{
-		config.Discovery.RpcService.MessageGateway,
-	})
-	if err != nil {
-		return errs.WrapMsg(err, "failed to register discovery service")
-	}
-	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")))
-
-	var (
-		netDone        = make(chan struct{}, 1)
-		netErr         error
-		prometheusPort int
-	)
-
-	registerIP, err := network.GetRpcRegisterIP("")
-	if err != nil {
-		return err
-	}
-
-	getAutoPort := func() (net.Listener, int, error) {
-		registerAddr := net.JoinHostPort(registerIP, "0")
-		listener, err := net.Listen("tcp", registerAddr)
-		if err != nil {
-			return nil, 0, errs.WrapMsg(err, "listen err", "registerAddr", registerAddr)
-		}
-		_, portStr, _ := net.SplitHostPort(listener.Addr().String())
-		port, _ := strconv.Atoi(portStr)
-		return listener, port, nil
-	}
-
-	if config.API.Prometheus.AutoSetPorts && config.Discovery.Enable != conf.ETCD {
-		return errs.New("only etcd support autoSetPorts", "RegisterName", "api").Wrap()
-	}
-
 	router, err := newGinRouter(ctx, client, config)
 	if err != nil {
 		return err
 	}
-	if config.API.Prometheus.Enable {
-		var (
-			listener net.Listener
-		)
 
-		if config.API.Prometheus.AutoSetPorts {
-			listener, prometheusPort, err = getAutoPort()
-			if err != nil {
-				return err
-			}
-
-			etcdClient := client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
-
-			_, err = etcdClient.Put(ctx, prommetrics.BuildDiscoveryKey(prommetrics.APIKeyName), jsonutil.StructToJsonString(prommetrics.BuildDefaultTarget(registerIP, prometheusPort)))
-			if err != nil {
-				return errs.WrapMsg(err, "etcd put err")
-			}
-		} else {
-			prometheusPort, err = datautil.GetElemByIndex(config.API.Prometheus.Ports, index)
-			if err != nil {
-				return err
-			}
-			listener, err = net.Listen("tcp", fmt.Sprintf(":%d", prometheusPort))
-			if err != nil {
-				return errs.WrapMsg(err, "listen err", "addr", fmt.Sprintf(":%d", prometheusPort))
-			}
+	apiCtx, apiCancel := context.WithCancelCause(context.Background())
+	done := make(chan struct{})
+	go func() {
+		httpServer := &http.Server{
+			Handler: router,
+			Addr:    net.JoinHostPort(network.GetListenIP(config.API.Api.ListenIP), strconv.Itoa(apiPort)),
 		}
-
 		go func() {
-			if err := prommetrics.ApiInit(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
-				netErr = errs.WrapMsg(err, fmt.Sprintf("api prometheus start err: %d", prometheusPort))
-				netDone <- struct{}{}
+			defer close(done)
+			select {
+			case <-ctx.Done():
+				apiCancel(fmt.Errorf("recv ctx %w", context.Cause(ctx)))
+			case <-apiCtx.Done():
+			}
+			log.ZDebug(ctx, "api server is shutting down")
+			if err := httpServer.Shutdown(context.Background()); err != nil {
+				log.ZWarn(ctx, "api server shutdown err", err)
 			}
 		}()
-
-	}
-	address := net.JoinHostPort(network.GetListenIP(config.API.Api.ListenIP), strconv.Itoa(apiPort))
-
-	server := http.Server{Addr: address, Handler: router}
-	log.CInfo(ctx, "API server is initializing", "runtimeEnv", config.RuntimeEnv, "address", address, "apiPort", apiPort, "prometheusPort", prometheusPort)
-	go func() {
-		err = server.ListenAndServe()
-		if err != nil && !errors.Is(err, http.ErrServerClosed) {
-			netErr = errs.WrapMsg(err, fmt.Sprintf("api start err: %s", server.Addr))
-			netDone <- struct{}{}
+		log.CInfo(ctx, "api server is init", "runtimeEnv", runtimeenv.RuntimeEnvironment(), "address", httpServer.Addr, "apiPort", apiPort)
+		err := httpServer.ListenAndServe()
+		if err == nil {
+			err = errors.New("api done")
 		}
+		apiCancel(err)
 	}()
 
 	//if config.Discovery.Enable == conf.ETCD {
@@ -157,19 +90,15 @@ func Start(ctx context.Context, index int, config *Config) error {
 	//case <-ctx.Done():
 	//}
 	<-apiCtx.Done()
-	exitCause := context.Cause(apiCtx)
+	exitCause := context.Cause(ctx)
 	log.ZWarn(ctx, "api server exit", exitCause)
 	timer := time.NewTimer(time.Second * 15)
 	defer timer.Stop()
 	select {
-	case <-sigs:
-		program.SIGTERMExit()
-		if err := shutdown(); err != nil {
-			return err
-		}
-	case <-netDone:
-		close(netDone)
-		return netErr
+	case <-timer.C:
+		log.ZWarn(ctx, "api server graceful stop timeout", nil)
+	case <-done:
+		log.ZDebug(ctx, "api server graceful stop done")
 	}
-	return nil
+	return exitCause
 }

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,6 +524,7 @@ func (m *MessageApi) SendSimpleMessage(c *gin.Context) {
 		apiresp.GinError(c, err)
 		return
 	}
+
 	m.ginRespSendMsg(c, sendReq, respPb)
 }
 

internal/api/prometheus_discovery.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"encoding/json"
+	"errors"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -11,16 +12,16 @@ import (
 	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/discovery/etcd"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/log"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
 
 type PrometheusDiscoveryApi struct {
 	config *Config
 	client *clientv3.Client
+	kv     discovery.KeyValue
 }
 
-func NewPrometheusDiscoveryApi(config *Config, client discovery.SvcDiscoveryRegistry) *PrometheusDiscoveryApi {
+func NewPrometheusDiscoveryApi(config *Config, client discovery.Conn) *PrometheusDiscoveryApi {
 	api := &PrometheusDiscoveryApi{
 		config: config,
 	}
@@ -30,43 +31,26 @@ func NewPrometheusDiscoveryApi(config *Config, client discovery.SvcDiscoveryRegi
 	return api
 }
 
-func (p *PrometheusDiscoveryApi) Enable(c *gin.Context) {
-	if p.config.Discovery.Enable != conf.ETCD {
-		c.JSON(http.StatusOK, []struct{}{})
-		c.Abort()
-	}
-}
-
 func (p *PrometheusDiscoveryApi) discovery(c *gin.Context, key string) {
-	eResp, err := p.client.Get(c, prommetrics.BuildDiscoveryKey(key))
+	value, err := p.kv.GetKey(c, prommetrics.BuildDiscoveryKey(key))
 	if err != nil {
-		// Log and respond with an error if preparation fails.
-		apiresp.GinError(c, errs.WrapMsg(err, "etcd get err"))
+		if errors.Is(err, discovery.ErrNotSupportedKeyValue) {
+			c.JSON(http.StatusOK, []struct{}{})
+			return
+		}
+		apiresp.GinError(c, errs.WrapMsg(err, "get key value"))
 		return
 	}
-	if len(eResp.Kvs) == 0 {
-		c.JSON(http.StatusOK, []*prommetrics.Target{})
+	if len(value) == 0 {
+		c.JSON(http.StatusOK, []*prommetrics.RespTarget{})
+		return
 	}
-
-	var (
-		resp = &prommetrics.RespTarget{
-			Targets: make([]string, 0, len(eResp.Kvs)),
-		}
-	)
-
-	for i := range eResp.Kvs {
-		var target prommetrics.Target
-		err = json.Unmarshal(eResp.Kvs[i].Value, &target)
-		if err != nil {
-			log.ZError(c, "prometheus unmarshal err", errs.Wrap(err))
-		}
-		resp.Targets = append(resp.Targets, target.Target)
-		if resp.Labels == nil {
-			resp.Labels = target.Labels
-		}
+	var resp prommetrics.RespTarget
+	if err := json.Unmarshal(value, &resp); err != nil {
+		apiresp.GinError(c, errs.WrapMsg(err, "json unmarshal err"))
+		return
 	}
-
-	c.JSON(200, []*prommetrics.RespTarget{resp})
+	c.JSON(http.StatusOK, []*prommetrics.RespTarget{&resp})
 }
 
 func (p *PrometheusDiscoveryApi) Api(c *gin.Context) {

internal/api/router.go

@@ -9,12 +9,8 @@ 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/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/authverify"
 	"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"
@@ -57,7 +53,7 @@ func prommetricsGin() gin.HandlerFunc {
 	}
 }
 
-func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, cfg *Config) (*gin.Engine, error) {
+func newGinRouter(ctx context.Context, client discovery.Conn, cfg *Config) (*gin.Engine, error) {
 	authConn, err := client.GetConn(ctx, cfg.Discovery.RpcService.Auth)
 	if err != nil {
 		return nil, err
@@ -266,7 +262,7 @@ func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, cf
 		conversationGroup.POST("/get_conversation", c.GetConversation)
 		conversationGroup.POST("/get_conversations", c.GetConversations)
 		conversationGroup.POST("/set_conversations", c.SetConversations)
-		conversationGroup.POST("/get_conversation_offline_push_user_ids", c.GetConversationOfflinePushUserIDs)
+		//conversationGroup.POST("/get_conversation_offline_push_user_ids", c.GetConversationOfflinePushUserIDs)
 		conversationGroup.POST("/get_full_conversation_ids", c.GetFullOwnerConversationIDs)
 		conversationGroup.POST("/get_incremental_conversations", c.GetIncrementalConversation)
 		conversationGroup.POST("/get_owner_conversation", c.GetOwnerConversation)
@@ -291,7 +287,7 @@ func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, cf
 	}
 	{
 		pd := NewPrometheusDiscoveryApi(cfg, client)
-		proDiscoveryGroup := r.Group("/prometheus_discovery", pd.Enable)
+		proDiscoveryGroup := r.Group("/prometheus_discovery")
 		proDiscoveryGroup.GET("/api", pd.Api)
 		proDiscoveryGroup.GET("/user", pd.User)
 		proDiscoveryGroup.GET("/group", pd.Group)
@@ -309,9 +305,8 @@ func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, cf
 	if cfg.Discovery.Enable == config.ETCD {
 		etcdClient = client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
 	}
-	cm := NewConfigManager(cfg.Share.IMAdminUserID, cfg.AllConfig, etcdClient, cfg.ConfigPath, cfg.RuntimeEnv)
+	cm := NewConfigManager(cfg.Share.IMAdminUserID, &cfg.AllConfig, etcdClient, string(cfg.ConfigPath))
 	{
-
 		configGroup := r.Group("/config", cm.CheckAdmin)
 		configGroup.POST("/get_config_list", cm.GetConfigList)
 		configGroup.POST("/get_config", cm.GetConfig)
@@ -359,9 +354,7 @@ func GinParseToken(authClient *rpcli.AuthClient) gin.HandlerFunc {
 
 func setGinIsAdmin(imAdminUserID []string) gin.HandlerFunc {
 	return func(c *gin.Context) {
-		opUserID := mcontext.GetOpUserID(c)
-		admin := datautil.Contain(opUserID, imAdminUserID...)
-		c.Set(authverify.CtxIsAdminKey, admin)
+		c.Set(authverify.CtxAdminUserIDsKey, imAdminUserID)
 	}
 }
 

internal/api/user.go

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

internal/msggateway/hub_server.go

@@ -22,7 +22,6 @@ 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"
@@ -35,7 +34,7 @@ import (
 	"google.golang.org/grpc"
 )
 
-func (s *Server) InitServer(ctx context.Context, config *Config, disCov discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
+func (s *Server) InitServer(ctx context.Context, config *Config, disCov discovery.Conn, server grpc.ServiceRegistrar) error {
 	userConn, err := disCov.GetConn(ctx, config.Discovery.RpcService.User)
 	if err != nil {
 		return err
@@ -51,26 +50,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,10 +19,14 @@ 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/db/redisutil"
-	"github.com/openimsdk/tools/log"
+	"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/log"
 )
 
 type Config struct {
@@ -31,21 +35,25 @@ type Config struct {
 	RedisConfig    config.Redis
 	WebhooksConfig config.Webhooks
 	Discovery      config.Discovery
+	Index          config.Index
 }
 
 // Start run ws server.
-func Start(ctx context.Context, index int, conf *Config) error {
-	log.CInfo(ctx, "MSG-GATEWAY server is initializing", "autoSetPorts", conf.MsgGateway.RPC.AutoSetPorts,
+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(),
 		"rpcPorts", conf.MsgGateway.RPC.Ports,
 		"wsPort", conf.MsgGateway.LongConnSvr.Ports, "prometheusPorts", conf.MsgGateway.Prometheus.Ports)
-	wsPort, err := datautil.GetElemByIndex(conf.MsgGateway.LongConnSvr.Ports, index)
+	wsPort, err := datautil.GetElemByIndex(conf.MsgGateway.LongConnSvr.Ports, int(conf.Index))
 	if err != nil {
 		return err
 	}
-	rdb, err := redisutil.NewRedisClient(ctx, conf.RedisConfig.Build())
+
+	dbb := dbbuild.NewBuilder(nil, &conf.RedisConfig)
+	rdb, err := dbb.Redis(ctx)
 	if err != nil {
 		return err
 	}
+
 	longServer := NewWsServer(
 		conf,
 		WithPort(wsPort),
@@ -60,12 +68,50 @@ func Start(ctx context.Context, index int, conf *Config) error {
 		return err
 	})
 
+	if err := hubServer.InitServer(ctx, conf, client, server); err != nil {
+		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)
+	return hubServer.LongConnServer.Run(ctx)
 }
+
+//
+//// 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,7 +2,6 @@ package msggateway
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"net/http"
 	"sync"
@@ -11,7 +10,6 @@ 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"
@@ -23,19 +21,18 @@ 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(done chan error) error
+	Run(ctx context.Context) 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.SvcDiscoveryRegistry, config *Config) error
+	SetDiscoveryRegistry(ctx context.Context, client discovery.Conn, config *Config) error
 	KickUserConn(client *Client) error
 	UnRegister(c *Client)
 	SetKickHandlerInfo(i *kickHandler)
@@ -52,7 +49,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
@@ -60,7 +57,7 @@ type WsServer struct {
 	handshakeTimeout  time.Duration
 	writeBufferSize   int
 	validate          *validator.Validate
-	disCov            discovery.SvcDiscoveryRegistry
+	disCov            discovery.Conn
 	Compressor
 	//Encoder
 	MessageHandler
@@ -75,7 +72,7 @@ type kickHandler struct {
 	newClient  *Client
 }
 
-func (ws *WsServer) SetDiscoveryRegistry(ctx context.Context, disCov discovery.SvcDiscoveryRegistry, config *Config) error {
+func (ws *WsServer) SetDiscoveryRegistry(ctx context.Context, disCov discovery.Conn, config *Config) error {
 	userConn, err := disCov.GetConn(ctx, config.Discovery.RpcService.User)
 	if err != nil {
 		return err
@@ -158,19 +155,14 @@ func NewWsServer(msgGatewayConfig *Config, opts ...Option) *WsServer {
 	}
 }
 
-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}
+func (ws *WsServer) Run(ctx context.Context) error {
+	var client *Client
 
+	ctx, cancel := context.WithCancelCause(ctx)
 	go func() {
 		for {
 			select {
-			case <-shutdownDone:
+			case <-ctx.Done():
 				return
 			case client = <-ws.registerChan:
 				ws.registerClient(client)
@@ -181,42 +173,37 @@ func (ws *WsServer) Run(done chan error) error {
 			}
 		}
 	}()
-	netDone := make(chan struct{}, 1)
-	go func() {
-		http.HandleFunc("/", ws.wsHandler)
-		err := server.ListenAndServe()
-		if err != nil && !errors.Is(err, http.ErrServerClosed) {
-			netErr = errs.WrapMsg(err, "ws start err", server.Addr)
-			netDone <- struct{}{}
-		}
-	}()
-	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
-	}
-	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
 
+	done := make(chan struct{})
+	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")
+		}
+		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")
+	}
+	return context.Cause(ctx)
 }
 
-var concurrentRequest = 3
+const concurrentRequest = 3
 
 func (ws *WsServer) sendUserOnlineInfoToOtherNode(ctx context.Context, client *Client) error {
 	conns, err := ws.disCov.GetConns(ctx, ws.msgGatewayConfig.Discovery.RpcService.MessageGateway)
@@ -353,6 +340,15 @@ func (ws *WsServer) multiTerminalLoginChecker(clientOK bool, oldClients []*Clien
 		if constant.PlatformIDToClass(newClient.PlatformID) == constant.TerminalPC {
 			return
 		}
+		clients, ok := ws.clients.GetAll(newClient.UserID)
+		clientOK = ok
+		oldClients = make([]*Client, 0, len(clients))
+		for _, c := range clients {
+			if constant.PlatformIDToClass(c.PlatformID) == constant.TerminalPC {
+				continue
+			}
+			oldClients = append(oldClients, c)
+		}
 		fallthrough
 	case constant.AllLoginButSameTermKick:
 		if !clientOK {

internal/msgtransfer/init.go

@@ -16,51 +16,35 @@ package msgtransfer
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"net"
-	"net/http"
-	"os"
-	"os/signal"
-	"strconv"
-	"syscall"
 
-	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"
+	"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/database/mgo"
-	"github.com/openimsdk/tools/db/mongoutil"
-	"github.com/openimsdk/tools/db/redisutil"
-	"github.com/openimsdk/tools/utils/datautil"
+	"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/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
-	historyCH *OnlineHistoryRedisConsumerHandler
+	historyHandler *OnlineHistoryRedisConsumerHandler
 	//This consumer handle message to mongo
-	historyMongoCH *OnlineHistoryMongoConsumerHandler
-	ctx            context.Context
-	cancel         context.CancelFunc
-
-	runTimeEnv string
+	historyMongoHandler *OnlineHistoryMongoConsumerHandler
+	ctx                 context.Context
+	//cancel              context.CancelFunc
 }
 
 type Config struct {
@@ -71,48 +55,59 @@ type Config struct {
 	Share          conf.Share
 	WebhooksConfig conf.Webhooks
 	Discovery      conf.Discovery
+	Index          conf.Index
 }
 
-func Start(ctx context.Context, index int, config *Config) error {
-	runTimeEnv := runtimeenv.RuntimeEnvironment()
+func Start(ctx context.Context, config *Config, client discovery.Conn, server grpc.ServiceRegistrar) error {
+	builder := mqbuild.NewBuilder(&config.KafkaConfig)
 
-	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())
+	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)
 	if err != nil {
 		return err
 	}
-	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
+	rdb, err := dbb.Redis(ctx)
 	if err != nil {
 		return err
 	}
-	client, err := discRegister.NewDiscoveryRegister(&config.Discovery, runTimeEnv, nil)
+
+	//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
 	}
-	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)
+	pushProducer, err := builder.GetTopicProducer(ctx, config.KafkaConfig.ToPushTopic)
+	if err != nil {
+		return err
 	}
-
 	msgDocModel, err := mgo.NewMsgMongo(mgocli.GetDB())
 	if err != nil {
 		return err
 	}
-	msgModel := redis.NewMsgCache(rdb, msgDocModel)
+	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)
+	}
 	seqConversation, err := mgo.NewSeqConversationMongo(mgocli.GetDB())
 	if err != nil {
 		return err
@@ -123,124 +118,68 @@ func Start(ctx context.Context, index int, config *Config) error {
 		return err
 	}
 	seqUserCache := redis.NewSeqUserCacheRedis(rdb, seqUser)
-	msgTransferDatabase, err := controller.NewMsgTransferDatabase(msgDocModel, msgModel, seqUserCache, seqConversationCache, &config.KafkaConfig)
+	msgTransferDatabase, err := controller.NewMsgTransferDatabase(msgDocModel, msgModel, seqUserCache, seqConversationCache, mongoProducer, pushProducer)
 	if err != nil {
 		return err
 	}
-	historyCH, err := NewOnlineHistoryRedisConsumerHandler(ctx, client, config, msgTransferDatabase)
+	historyConsumer, err := builder.GetTopicConsumer(ctx, config.KafkaConfig.ToRedisTopic)
 	if err != nil {
 		return err
 	}
-	historyMongoCH, err := NewOnlineHistoryMongoConsumerHandler(&config.KafkaConfig, msgTransferDatabase)
+	historyMongoConsumer, err := builder.GetTopicConsumer(ctx, config.KafkaConfig.ToMongoTopic)
 	if err != nil {
 		return err
 	}
+	historyHandler, err := NewOnlineHistoryRedisConsumerHandler(ctx, client, config, msgTransferDatabase)
+	if err != nil {
+		return err
+	}
+	historyMongoHandler := NewOnlineHistoryMongoConsumerHandler(msgTransferDatabase)
 
 	msgTransfer := &MsgTransfer{
-		historyCH:      historyCH,
-		historyMongoCH: historyMongoCH,
-		runTimeEnv:     runTimeEnv,
+		historyConsumer:      historyConsumer,
+		historyMongoConsumer: historyMongoConsumer,
+		historyHandler:       historyHandler,
+		historyMongoHandler:  historyMongoHandler,
 	}
 
-	return msgTransfer.Start(index, config, client)
+	return msgTransfer.Start(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
-	)
+func (m *MsgTransfer) Start(ctx context.Context) error {
+	var cancel context.CancelCauseFunc
+	m.ctx, cancel = context.WithCancelCause(ctx)
 
-	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()
+	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()
 	if err != nil {
 		return err
 	}
-
-	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
-	}
+	<-m.ctx.Done()
+	return context.Cause(m.ctx)
 }

internal/msgtransfer/online_history_msg_handler.go

@@ -18,18 +18,16 @@ 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/IBM/sarama"
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/tools/discovery"
+
 	"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"
@@ -64,9 +62,7 @@ type userHasReadSeq struct {
 }
 
 type OnlineHistoryRedisConsumerHandler struct {
-	historyConsumerGroup *kafka.MConsumerGroup
-
-	redisMessageBatches *batcher.Batcher[sarama.ConsumerMessage]
+	redisMessageBatches *batcher.Batcher[ConsumerMessage]
 
 	msgTransferDatabase         controller.MsgTransferDatabase
 	conversationUserHasReadChan chan *userHasReadSeq
@@ -76,12 +72,13 @@ type OnlineHistoryRedisConsumerHandler struct {
 	conversationClient *rpcli.ConversationClient
 }
 
-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
-	}
+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) {
 	groupConn, err := client.GetConn(ctx, config.Discovery.RpcService.Group)
 	if err != nil {
 		return nil, err
@@ -97,7 +94,7 @@ func NewOnlineHistoryRedisConsumerHandler(ctx context.Context, client discovery.
 	och.conversationClient = rpcli.NewConversationClient(conversationConn)
 	och.wg.Add(1)
 
-	b := batcher.New[sarama.ConsumerMessage](
+	b := batcher.New[ConsumerMessage](
 		batcher.WithSize(size),
 		batcher.WithWorker(worker),
 		batcher.WithInterval(interval),
@@ -109,16 +106,15 @@ func NewOnlineHistoryRedisConsumerHandler(ctx context.Context, client discovery.
 		hashCode := stringutil.GetHashCode(key)
 		return int(hashCode) % och.redisMessageBatches.Worker()
 	}
-	b.Key = func(consumerMessage *sarama.ConsumerMessage) string {
-		return string(consumerMessage.Key)
+	b.Key = func(consumerMessage *ConsumerMessage) string {
+		return 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[sarama.ConsumerMessage]) {
+func (och *OnlineHistoryRedisConsumerHandler) do(ctx context.Context, channelID int, val *batcher.Msg[ConsumerMessage]) {
 	ctx = mcontext.WithTriggerIDContext(ctx, val.TriggerID())
 	ctxMessages := och.parseConsumerMessages(ctx, val.Val())
 	ctx = withAggregationCtx(ctx, ctxMessages)
@@ -189,7 +185,7 @@ func (och *OnlineHistoryRedisConsumerHandler) doSetReadSeq(ctx context.Context,
 
 }
 
-func (och *OnlineHistoryRedisConsumerHandler) parseConsumerMessages(ctx context.Context, consumerMessages []*sarama.ConsumerMessage) []*ContextMsg {
+func (och *OnlineHistoryRedisConsumerHandler) parseConsumerMessages(ctx context.Context, consumerMessages []*ConsumerMessage) []*ContextMsg {
 	var ctxMessages []*ContextMsg
 	for i := 0; i < len(consumerMessages); i++ {
 		ctxMsg := &ContextMsg{}
@@ -199,16 +195,9 @@ func (och *OnlineHistoryRedisConsumerHandler) parseConsumerMessages(ctx context.
 			log.ZWarn(ctx, "msg_transfer Unmarshal msg err", err, string(consumerMessages[i].Value))
 			continue
 		}
-		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.ctx = consumerMessages[i].Ctx
 		ctxMsg.message = msgFromMQ
-		log.ZDebug(ctx, "message parse finish", "message", msgFromMQ, "key",
-			string(consumerMessages[i].Key))
+		log.ZDebug(ctx, "message parse finish", "message", msgFromMQ, "key", consumerMessages[i].Key)
 		ctxMessages = append(ctxMessages, ctxMsg)
 	}
 	return ctxMessages
@@ -383,7 +372,9 @@ 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())
-		_, _, _ = och.msgTransferDatabase.MsgToPushMQ(v.ctx, key, conversationID, v.message)
+		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())
+		}
 	}
 }
 
@@ -401,35 +392,10 @@ func withAggregationCtx(ctx context.Context, values []*ContextMsg) context.Conte
 	return mcontext.SetOperationID(ctx, allMessageOperationID)
 }
 
-func (och *OnlineHistoryRedisConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error { return nil }
-func (och *OnlineHistoryRedisConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error {
+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)
+	}
 	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,36 +17,24 @@ 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 {
-	historyConsumerGroup *kafka.MConsumerGroup
-	msgTransferDatabase  controller.MsgTransferDatabase
+	msgTransferDatabase controller.MsgTransferDatabase
 }
 
-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
+func NewOnlineHistoryMongoConsumerHandler(database controller.MsgTransferDatabase) *OnlineHistoryMongoConsumerHandler {
+	return &OnlineHistoryMongoConsumerHandler{
+		msgTransferDatabase: database,
 	}
-
-	mc := &OnlineHistoryMongoConsumerHandler{
-		historyConsumerGroup: historyConsumerGroup,
-		msgTransferDatabase:  database,
-	}
-	return mc, nil
 }
 
-func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(ctx context.Context, cMsg *sarama.ConsumerMessage, key string, session sarama.ConsumerGroupSession) {
-	msg := cMsg.Value
+func (mc *OnlineHistoryMongoConsumerHandler) HandleChatWs2Mongo(ctx context.Context, key string, msg []byte) {
 	msgFromMQ := pbmsg.MsgDataToMongoByMQ{}
 	err := proto.Unmarshal(msg, &msgFromMQ)
 	if err != nil {
@@ -54,21 +42,13 @@ func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(ctx context.Cont
 		return
 	}
 	if len(msgFromMQ.MsgData) == 0 {
-		log.ZError(ctx, "msgFromMQ.MsgData is empty", nil, "cMsg", cMsg)
+		log.ZError(ctx, "msgFromMQ.MsgData is empty", nil, "key", key, "msg", msg)
 		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()

internal/push/callback.go

@@ -17,6 +17,7 @@ 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,11 +3,9 @@ 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"
@@ -18,34 +16,16 @@ import (
 )
 
 type OfflinePushConsumerHandler struct {
-	OfflinePushConsumerGroup *kafka.MConsumerGroup
-	offlinePusher            offlinepush.OfflinePusher
+	offlinePusher offlinepush.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
+func NewOfflinePushConsumerHandler(offlinePusher offlinepush.OfflinePusher) *OfflinePushConsumerHandler {
+	return &OfflinePushConsumerHandler{
+		offlinePusher: offlinePusher,
 	}
-	return &offlinePushConsumerHandler, nil
 }
 
-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) {
+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"
-	"errors"
+	"fmt"
 	"sync"
 
 	"github.com/openimsdk/protocol/msggateway"
@@ -11,6 +11,7 @@ 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"
 
@@ -30,37 +31,36 @@ 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.SvcDiscoveryRegistry, config *Config) OnlinePusher {
-
-	if config.runTimeEnv == conf.KUBERNETES {
-		return NewDefaultAllNode(disCov, config)
+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
 	}
 	switch config.Discovery.Enable {
 	case conf.ETCD:
-		return NewDefaultAllNode(disCov, config)
+		return NewDefaultAllNode(disCov, config), nil
 	default:
-		log.ZError(context.Background(), "NewOnlinePusher is error", errs.Wrap(errors.New("unsupported discovery type")), "type", config.Discovery.Enable)
-		return nil
+		return nil, errs.New(fmt.Sprintf("unsupported discovery type %s", config.Discovery.Enable))
 	}
 }
 
 type DefaultAllNode struct {
-	disCov discovery.SvcDiscoveryRegistry
+	disCov discovery.Conn
 	config *Config
 }
 
-func NewDefaultAllNode(disCov discovery.SvcDiscoveryRegistry, config *Config) *DefaultAllNode {
+func NewDefaultAllNode(disCov discovery.Conn, config *Config) *DefaultAllNode {
 	return &DefaultAllNode{disCov: disCov, config: config}
 }
 

internal/push/push.go

@@ -2,38 +2,43 @@ 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.SvcDiscoveryRegistry
+	disCov        discovery.Conn
 	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      string
-
-	runTimeEnv string
+	FcmConfigPath      config.Path
 }
 
 func (p pushServer) DelUserPushToken(ctx context.Context,
@@ -44,40 +49,90 @@ func (p pushServer) DelUserPushToken(ctx context.Context,
 	return &pbpush.DelUserPushTokenResp{}, nil
 }
 
-func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
-	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
+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)
 	if err != nil {
 		return err
 	}
-	cacheModel := redis.NewThirdCache(rdb)
-	offlinePusher, err := offlinepush.NewOfflinePusher(&config.RpcConfig, cacheModel, config.FcmConfigPath)
+	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)
 	if err != nil {
 		return err
 	}
 
-	database := controller.NewPushDatabase(cacheModel, &config.KafkaConfig)
-
-	consumer, err := NewConsumerHandler(ctx, config, database, offlinePusher, rdb, client)
+	pushHandler, err := NewConsumerHandler(ctx, config, database, offlinePusher, rdb, client)
 	if err != nil {
 		return err
 	}
 
-	offlinePushConsumer, err := NewOfflinePushConsumerHandler(config, offlinePusher)
-	if err != nil {
-		return err
-	}
+	offlineHandler := NewOfflinePushConsumerHandler(offlinePusher)
 
 	pbpush.RegisterPushMsgServiceServer(server, &pushServer{
 		database:      database,
 		disCov:        client,
 		offlinePusher: offlinePusher,
-		pushCh:        consumer,
-		offlinePushCh: offlinePushConsumer,
 	})
 
-	go consumer.pushConsumerGroup.RegisterHandleAndConsumer(ctx, consumer)
+	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 offlinePushConsumer.OfflinePushConsumerGroup.RegisterHandleAndConsumer(ctx, offlinePushConsumer)
+	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
+			}
+		}
+	}()
 
 	return nil
 }

internal/push/push_handler.go

@@ -3,21 +3,16 @@ 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"
@@ -34,11 +29,11 @@ import (
 )
 
 type ConsumerHandler struct {
-	pushConsumerGroup      *kafka.MConsumerGroup
+	//pushConsumerGroup      mq.Consumer
 	offlinePusher          offlinepush.OfflinePusher
 	onlinePusher           OnlinePusher
 	pushDatabase           controller.PushDatabase
-	onlineCache            *rpccache.OnlineCache
+	onlineCache            rpccache.OnlineCache
 	groupLocalCache        *rpccache.GroupLocalCache
 	conversationLocalCache *rpccache.ConversationLocalCache
 	webhookClient          *webhook.Client
@@ -49,15 +44,7 @@ type ConsumerHandler struct {
 	conversationClient     *rpcli.ConversationClient
 }
 
-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
-	}
+func NewConsumerHandler(ctx context.Context, config *Config, database controller.PushDatabase, offlinePusher offlinepush.OfflinePusher, rdb redis.UniversalClient, client discovery.Conn) (*ConsumerHandler, error) {
 	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
 	if err != nil {
 		return nil, err
@@ -74,13 +61,18 @@ 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 = NewOnlinePusher(client, config)
+	consumerHandler.onlinePusher = onlinePusher
 	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)
@@ -93,7 +85,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))
@@ -127,25 +119,8 @@ func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 	}
 }
 
-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
+func (c *ConsumerHandler) WaitCache() {
+	c.onlineCache.WaitCache()
 }
 
 // Push2User Suitable for two types of conversations, one is SingleChatType and the other is NotificationChatType.

internal/rpc/conversation/conversation.go

@@ -19,24 +19,23 @@ import (
 	"sort"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
+	"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/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"
@@ -66,12 +65,13 @@ type Config struct {
 	Discovery          config.Discovery
 }
 
-func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
-	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
+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)
 	if err != nil {
 		return err
 	}
-	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
+	rdb, err := dbb.Redis(ctx)
 	if err != nil {
 		return err
 	}
@@ -96,7 +96,7 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	pbconversation.RegisterConversationServer(server, &conversationServer{
 		conversationNotificationSender: NewConversationNotificationSender(&config.NotificationConfig, msgClient),
 		conversationDatabase: controller.NewConversationDatabase(conversationDB,
-			redis.NewConversationRedis(rdb, &config.LocalCacheConfig, redis.GetRocksCacheOptions(), conversationDB), mgocli.GetTx()),
+			redis.NewConversationRedis(rdb, &config.LocalCacheConfig, conversationDB), mgocli.GetTx()),
 		userClient:  rpcli.NewUserClient(userConn),
 		groupClient: rpcli.NewGroupClient(groupConn),
 		msgClient:   msgClient,
@@ -105,6 +105,9 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 }
 
 func (c *conversationServer) GetConversation(ctx context.Context, req *pbconversation.GetConversationReq) (*pbconversation.GetConversationResp, error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
 	conversations, err := c.conversationDatabase.FindConversations(ctx, req.OwnerUserID, []string{req.ConversationID})
 	if err != nil {
 		return nil, err
@@ -118,7 +121,9 @@ func (c *conversationServer) GetConversation(ctx context.Context, req *pbconvers
 }
 
 func (c *conversationServer) GetSortedConversationList(ctx context.Context, req *pbconversation.GetSortedConversationListReq) (resp *pbconversation.GetSortedConversationListResp, err error) {
-	log.ZDebug(ctx, "GetSortedConversationList", "seqs", req, "userID", req.UserID)
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	var conversationIDs []string
 	if len(req.ConversationIDs) == 0 {
 		conversationIDs, err = c.conversationDatabase.GetConversationIDs(ctx, req.UserID)
@@ -191,6 +196,9 @@ func (c *conversationServer) GetSortedConversationList(ctx context.Context, req
 }
 
 func (c *conversationServer) GetAllConversations(ctx context.Context, req *pbconversation.GetAllConversationsReq) (*pbconversation.GetAllConversationsResp, error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
 	conversations, err := c.conversationDatabase.GetUserAllConversation(ctx, req.OwnerUserID)
 	if err != nil {
 		return nil, err
@@ -201,6 +209,9 @@ func (c *conversationServer) GetAllConversations(ctx context.Context, req *pbcon
 }
 
 func (c *conversationServer) GetConversations(ctx context.Context, req *pbconversation.GetConversationsReq) (*pbconversation.GetConversationsResp, error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
 	conversations, err := c.getConversations(ctx, req.OwnerUserID, req.ConversationIDs)
 	if err != nil {
 		return nil, err
@@ -221,6 +232,9 @@ func (c *conversationServer) getConversations(ctx context.Context, ownerUserID s
 }
 
 func (c *conversationServer) SetConversation(ctx context.Context, req *pbconversation.SetConversationReq) (*pbconversation.SetConversationResp, error) {
+	if err := authverify.CheckAccess(ctx, req.GetConversation().GetUserID()); err != nil {
+		return nil, err
+	}
 	var conversation dbModel.Conversation
 	if err := datautil.CopyStructFields(&conversation, req.Conversation); err != nil {
 		return nil, err
@@ -235,8 +249,10 @@ func (c *conversationServer) SetConversation(ctx context.Context, req *pbconvers
 }
 
 func (c *conversationServer) SetConversations(ctx context.Context, req *pbconversation.SetConversationsReq) (*pbconversation.SetConversationsResp, error) {
-	if req.Conversation == nil {
-		return nil, errs.ErrArgs.WrapMsg("conversation must not be nil")
+	for _, userID := range req.UserIDs {
+		if err := authverify.CheckAccess(ctx, userID); err != nil {
+			return nil, err
+		}
 	}
 	if req.Conversation.ConversationType == constant.WriteGroupChatType {
 		groupInfo, err := c.groupClient.GetGroupInfo(ctx, req.Conversation.GroupID)
@@ -397,15 +413,25 @@ func (c *conversationServer) SetConversations(ctx context.Context, req *pbconver
 	return &pbconversation.SetConversationsResp{}, nil
 }
 
-// Get user IDs with "Do Not Disturb" enabled in super large groups.
-func (c *conversationServer) GetRecvMsgNotNotifyUserIDs(ctx context.Context, req *pbconversation.GetRecvMsgNotNotifyUserIDsReq) (*pbconversation.GetRecvMsgNotNotifyUserIDsResp, error) {
-	return nil, errs.New("deprecated")
+func (c *conversationServer) UpdateConversationsByUser(ctx context.Context, req *pbconversation.UpdateConversationsByUserReq) (*pbconversation.UpdateConversationsByUserResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	m := make(map[string]any)
+	if req.Ex != nil {
+		m["ex"] = req.Ex.Value
+	}
+	if len(m) > 0 {
+		if err := c.conversationDatabase.UpdateUserConversations(ctx, req.UserID, m); err != nil {
+			return nil, err
+		}
+	}
+	return &pbconversation.UpdateConversationsByUserResp{}, nil
 }
 
 // create conversation without notification for msg redis transfer.
-func (c *conversationServer) CreateSingleChatConversations(ctx context.Context,
-	req *pbconversation.CreateSingleChatConversationsReq,
-) (*pbconversation.CreateSingleChatConversationsResp, error) {
+func (c *conversationServer) CreateSingleChatConversations(ctx context.Context, req *pbconversation.CreateSingleChatConversationsReq) (*pbconversation.CreateSingleChatConversationsResp, error) {
+	var conversation dbModel.Conversation
 	switch req.ConversationType {
 	case constant.SingleChatType:
 		var conversation dbModel.Conversation
@@ -481,6 +507,9 @@ func (c *conversationServer) SetConversationMinSeq(ctx context.Context, req *pbc
 }
 
 func (c *conversationServer) GetConversationIDs(ctx context.Context, req *pbconversation.GetConversationIDsReq) (*pbconversation.GetConversationIDsResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	conversationIDs, err := c.conversationDatabase.GetConversationIDs(ctx, req.UserID)
 	if err != nil {
 		return nil, err
@@ -489,6 +518,9 @@ func (c *conversationServer) GetConversationIDs(ctx context.Context, req *pbconv
 }
 
 func (c *conversationServer) GetUserConversationIDsHash(ctx context.Context, req *pbconversation.GetUserConversationIDsHashReq) (*pbconversation.GetUserConversationIDsHashResp, error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
 	hash, err := c.conversationDatabase.GetUserConversationIDsHash(ctx, req.OwnerUserID)
 	if err != nil {
 		return nil, err
@@ -496,10 +528,7 @@ func (c *conversationServer) GetUserConversationIDsHash(ctx context.Context, req
 	return &pbconversation.GetUserConversationIDsHashResp{Hash: hash}, nil
 }
 
-func (c *conversationServer) GetConversationsByConversationID(
-	ctx context.Context,
-	req *pbconversation.GetConversationsByConversationIDReq,
-) (*pbconversation.GetConversationsByConversationIDResp, error) {
+func (c *conversationServer) GetConversationsByConversationID(ctx context.Context, req *pbconversation.GetConversationsByConversationIDReq) (*pbconversation.GetConversationsByConversationIDResp, error) {
 	conversations, err := c.conversationDatabase.GetConversationsByConversationID(ctx, req.ConversationIDs)
 	if err != nil {
 		return nil, err
@@ -553,10 +582,7 @@ func (c *conversationServer) conversationSort(conversations map[int64]string, re
 	resp.ConversationElems = append(resp.ConversationElems, cons...)
 }
 
-func (c *conversationServer) getConversationInfo(
-	ctx context.Context,
-	chatLogs map[string]*sdkws.MsgData,
-	userID string) (map[string]*pbconversation.ConversationElem, error) {
+func (c *conversationServer) getConversationInfo(ctx context.Context, chatLogs map[string]*sdkws.MsgData, userID string) (map[string]*pbconversation.ConversationElem, error) {
 	var (
 		sendIDs         []string
 		groupIDs        []string
@@ -642,6 +668,11 @@ func (c *conversationServer) GetConversationNotReceiveMessageUserIDs(ctx context
 }
 
 func (c *conversationServer) UpdateConversation(ctx context.Context, req *pbconversation.UpdateConversationReq) (*pbconversation.UpdateConversationResp, error) {
+	for _, userID := range req.UserIDs {
+		if err := authverify.CheckAccess(ctx, userID); err != nil {
+			return nil, err
+		}
+	}
 	m := make(map[string]any)
 	if req.RecvMsgOpt != nil {
 		m["recv_msg_opt"] = req.RecvMsgOpt.Value
@@ -688,6 +719,9 @@ func (c *conversationServer) UpdateConversation(ctx context.Context, req *pbconv
 }
 
 func (c *conversationServer) GetOwnerConversation(ctx context.Context, req *pbconversation.GetOwnerConversationReq) (*pbconversation.GetOwnerConversationResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	total, conversations, err := c.conversationDatabase.GetOwnerConversation(ctx, req.UserID, req.Pagination)
 	if err != nil {
 		return nil, err
@@ -749,6 +783,9 @@ func (c *conversationServer) GetConversationsNeedClearMsg(ctx context.Context, _
 }
 
 func (c *conversationServer) GetNotNotifyConversationIDs(ctx context.Context, req *pbconversation.GetNotNotifyConversationIDsReq) (*pbconversation.GetNotNotifyConversationIDsResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	conversationIDs, err := c.conversationDatabase.GetNotNotifyConversationIDs(ctx, req.UserID)
 	if err != nil {
 		return nil, err
@@ -757,6 +794,9 @@ func (c *conversationServer) GetNotNotifyConversationIDs(ctx context.Context, re
 }
 
 func (c *conversationServer) GetPinnedConversationIDs(ctx context.Context, req *pbconversation.GetPinnedConversationIDsReq) (*pbconversation.GetPinnedConversationIDsResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	conversationIDs, err := c.conversationDatabase.GetPinnedConversationIDs(ctx, req.UserID)
 	if err != nil {
 		return nil, err

internal/rpc/conversation/notification.go

@@ -16,21 +16,22 @@ 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 {
-	*rpcclient.NotificationSender
+	*notification.NotificationSender
 }
 
 func NewConversationNotificationSender(conf *config.Notification, msgClient *rpcli.MsgClient) *ConversationNotificationSender {
-	return &ConversationNotificationSender{rpcclient.NewNotificationSender(conf, rpcclient.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+	return &ConversationNotificationSender{notification.NewNotificationSender(conf, notification.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
 		return msgClient.SendMsg(ctx, req)
 	}))}
 }

internal/rpc/conversation/sync.go

@@ -35,6 +35,9 @@ func (c *conversationServer) GetFullOwnerConversationIDs(ctx context.Context, re
 }
 
 func (c *conversationServer) GetIncrementalConversation(ctx context.Context, req *conversation.GetIncrementalConversationReq) (*conversation.GetIncrementalConversationResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	opt := incrversion.Option[*conversation.Conversation, conversation.GetIncrementalConversationResp]{
 		Ctx:             ctx,
 		VersionKey:      req.UserID,

internal/rpc/group/cache.go

@@ -17,6 +17,7 @@ package group
 import (
 	"context"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	pbgroup "github.com/openimsdk/protocol/group"
 )
@@ -32,8 +33,11 @@ func (s *groupServer) GetGroupInfoCache(ctx context.Context, req *pbgroup.GetGro
 	}, nil
 }
 
-func (s *groupServer) GetGroupMemberCache(ctx context.Context, req *pbgroup.GetGroupMemberCacheReq) (*pbgroup.GetGroupMemberCacheResp, error) {
-	members, err := s.db.TakeGroupMember(ctx, req.GroupID, req.GroupMemberID)
+func (g *groupServer) GetGroupMemberCache(ctx context.Context, req *pbgroup.GetGroupMemberCacheReq) (*pbgroup.GetGroupMemberCacheResp, error) {
+	if err := authverify.CheckAccess(ctx, req.GroupMemberID); err != nil {
+		return nil, err
+	}
+	members, err := g.db.TakeGroupMember(ctx, req.GroupID, req.GroupMemberID)
 	if err != nil {
 		return nil, err
 	}

internal/rpc/group/db_map.go

@@ -16,6 +16,7 @@ package group
 
 import (
 	"context"
+	"strings"
 	"time"
 
 	pbgroup "github.com/openimsdk/protocol/group"
@@ -55,41 +56,52 @@ func UpdateGroupInfoMap(ctx context.Context, group *sdkws.GroupInfoForSet) map[s
 	return m
 }
 
-func UpdateGroupInfoExMap(ctx context.Context, group *pbgroup.SetGroupInfoExReq) (map[string]any, error) {
-	m := make(map[string]any)
+func UpdateGroupInfoExMap(ctx context.Context, group *pbgroup.SetGroupInfoExReq) (m map[string]any, normalFlag, groupNameFlag, notificationFlag bool, err error) {
+	m = make(map[string]any)
 
 	if group.GroupName != nil {
-		if group.GroupName.Value != "" {
+		if strings.TrimSpace(group.GroupName.Value) != "" {
 			m["group_name"] = group.GroupName.Value
+			groupNameFlag = true
 		} else {
-			return nil, errs.ErrArgs.WrapMsg("group name is empty")
+			return nil, normalFlag, notificationFlag, groupNameFlag, 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_update_time"] = time.Now()
 		m["notification_user_id"] = mcontext.GetOpUserID(ctx)
+		m["notification_update_time"] = time.Now()
 	}
 	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, nil
+	return m, normalFlag, groupNameFlag, notificationFlag, nil
 }
 
 func UpdateGroupStatusMap(status int) map[string]any {

internal/rpc/group/group.go

@@ -43,8 +43,6 @@ 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"
@@ -52,7 +50,6 @@ 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,12 +74,13 @@ type Config struct {
 	Discovery          config.Discovery
 }
 
-func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
-	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
+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)
 	if err != nil {
 		return err
 	}
-	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
+	rdb, err := dbb.Redis(ctx)
 	if err != nil {
 		return err
 	}
@@ -98,11 +96,6 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	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
@@ -289,13 +282,14 @@ func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 			break
 		}
 	}
-	g.notification.GroupCreatedNotification(ctx, tips)
+	g.notification.GroupCreatedNotification(ctx, tips, req.SendMessage)
 
 	if req.GroupInfo.Notification != "" {
+		notificationFlag := true
 		g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{
 			Group:  tips.Group,
 			OpUser: tips.OpUser,
-		})
+		}, &notificationFlag)
 	}
 
 	reqCallBackAfter := &pbgroup.CreateGroupReq{
@@ -479,6 +473,19 @@ func (g *groupServer) GetGroupAllMember(ctx context.Context, req *pbgroup.GetGro
 	if err != nil {
 		return nil, err
 	}
+	if !authverify.IsAdmin(ctx) {
+		var inGroup bool
+		opUserID := mcontext.GetOpUserID(ctx)
+		for _, member := range members {
+			if member.UserID == opUserID {
+				inGroup = true
+				break
+			}
+		}
+		if !inGroup {
+			return nil, errs.ErrNoPermission.WrapMsg("opuser not in group")
+		}
+	}
 	if err := g.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
@@ -489,11 +496,24 @@ func (g *groupServer) GetGroupAllMember(ctx context.Context, req *pbgroup.GetGro
 	return &resp, nil
 }
 
+func (g *groupServer) checkAdminOrInGroup(ctx context.Context, groupID string) error {
+	if authverify.IsAdmin(ctx) {
+		return nil
+	}
+	opUserID := mcontext.GetOpUserID(ctx)
+	members, err := g.db.FindGroupMembers(ctx, groupID, []string{opUserID})
+	if err != nil {
+		return err
+	}
+	if len(members) == 0 {
+		return errs.ErrNoPermission.WrapMsg("op user not in group")
+	}
+	return nil
+}
+
 func (g *groupServer) GetGroupMemberList(ctx context.Context, req *pbgroup.GetGroupMemberListReq) (*pbgroup.GetGroupMemberListResp, error) {
-	if opUserID := mcontext.GetOpUserID(ctx); !datautil.Contain(opUserID, g.config.Share.IMAdminUserID...) {
-		if _, err := g.db.TakeGroupMember(ctx, req.GroupID, opUserID); err != nil {
-			return nil, err
-		}
+	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+		return nil, err
 	}
 	var (
 		total   int64
@@ -618,7 +638,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)
+	g.notification.MemberKickedNotification(ctx, tips, req.SendMessage)
 	if err := g.deleteMemberAndSetConversationSeq(ctx, req.GroupID, req.KickedUserIDs); err != nil {
 		return nil, err
 	}
@@ -634,6 +654,9 @@ func (g *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbgroup.GetG
 	if req.GroupID == "" {
 		return nil, errs.ErrArgs.WrapMsg("groupID empty")
 	}
+	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+		return nil, err
+	}
 	members, err := g.getGroupMembersInfo(ctx, req.GroupID, req.UserIDs)
 	if err != nil {
 		return nil, err
@@ -661,6 +684,9 @@ func (g *groupServer) getGroupMembersInfo(ctx context.Context, groupID string, u
 
 // GetGroupApplicationList handles functions that get a list of group requests.
 func (g *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.GetGroupApplicationListReq) (*pbgroup.GetGroupApplicationListResp, error) {
+	if err := authverify.CheckAccess(ctx, req.FromUserID); err != nil {
+		return nil, err
+	}
 	groupIDs, err := g.db.FindUserManagedGroupID(ctx, req.FromUserID)
 	if err != nil {
 		return nil, err
@@ -827,8 +853,14 @@ func (g *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 		if member == nil {
 			log.ZDebug(ctx, "GroupApplicationResponse", "member is nil")
 		} else {
-			if err = g.notification.GroupApplicationAgreeMemberEnterNotification(ctx, req.GroupID, groupRequest.InviterUserID, req.FromUserID); err != nil {
-				return nil, err
+			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
+				}
 			}
 		}
 	case constant.GroupResponseRefuse:
@@ -1030,7 +1062,8 @@ func (g *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
 				log.ZWarn(ctx, "SetConversations", err, "UserIDs", resp.UserIDs, "conversation", conversation)
 			}
 		}()
-		g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser})
+		notficationFlag := true
+		g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notficationFlag)
 	}
 	if req.GroupInfoForSet.GroupName != "" {
 		num--
@@ -1091,7 +1124,7 @@ func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupI
 		return nil, err
 	}
 
-	updatedData, err := UpdateGroupInfoExMap(ctx, req)
+	updatedData, normalFlag, groupNameFlag, notificationFlag, err := UpdateGroupInfoExMap(ctx, req)
 	if len(updatedData) == 0 {
 		return &pbgroup.SetGroupInfoExResp{}, nil
 	}
@@ -1119,41 +1152,38 @@ func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupI
 		tips.OpUser = g.groupMemberDB2PB(opMember, 0)
 	}
 
-	num := len(updatedData)
-
-	if req.Notification != nil {
-		num -= 3
-
+	if notificationFlag {
 		if req.Notification.Value != "" {
-			func() {
-				conversation := &pbconv.ConversationReq{
-					ConversationID:   msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, req.GroupID),
-					ConversationType: constant.ReadGroupChatType,
-					GroupID:          req.GroupID,
-				}
+			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
-				}
+			resp, err := g.GetGroupMemberUserIDs(ctx, &pbgroup.GetGroupMemberUserIDsReq{GroupID: req.GroupID})
+			if err != nil {
+				log.ZWarn(ctx, "GetGroupMemberIDs is failed.", err)
+				return nil, err
+			}
 
-				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})
+			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)
 		}
 	}
 
-	if req.GroupName != nil {
-		num--
+	if groupNameFlag {
 		g.notification.GroupInfoSetNameNotification(ctx, &sdkws.GroupInfoSetNameTips{Group: tips.Group, OpUser: tips.OpUser})
 	}
 
-	if num > 0 {
+	// if updatedData > 0, send the normal notification
+	if normalFlag {
 		g.notification.GroupInfoSetNotification(ctx, tips)
 	}
 
@@ -1374,7 +1404,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)
+		g.notification.GroupDismissedNotification(ctx, tips, req.SendMessage)
 	}
 	membersID, err := g.db.FindGroupMemberUserID(ctx, group.GroupID)
 	if err != nil {
@@ -1651,6 +1681,11 @@ func (g *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbgroup.Get
 	if datautil.Duplicate(req.GroupIDs) {
 		return nil, errs.ErrArgs.WrapMsg("groupIDs duplicate")
 	}
+	for _, groupID := range req.GroupIDs {
+		if err := g.checkAdminOrInGroup(ctx, groupID); err != nil {
+			return nil, err
+		}
+	}
 	groups, err := g.db.FindGroup(ctx, req.GroupIDs)
 	if err != nil {
 		return nil, err
@@ -1698,6 +1733,9 @@ func (g *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbgroup.Ge
 	if err != nil {
 		return nil, err
 	}
+	if err := authverify.CheckAccessIn(ctx, userIDs...); err != nil {
+		return nil, err
+	}
 	return &pbgroup.GetGroupMemberUserIDsResp{
 		UserIDs: userIDs,
 	}, nil

internal/rpc/group/notification.go

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

internal/rpc/group/statistics.go

@@ -18,6 +18,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/tools/errs"
 )
@@ -26,7 +27,10 @@ func (s *groupServer) GroupCreateCount(ctx context.Context, req *group.GroupCrea
 	if req.Start > req.End {
 		return nil, errs.ErrArgs.WrapMsg("start > end: %d > %d", req.Start, req.End)
 	}
-	total, err := s.db.CountTotal(ctx, nil)
+	if err := authverify.CheckAdmin(ctx); err != nil {
+		return nil, err
+	}
+	total, err := g.db.CountTotal(ctx, nil)
 	if err != nil {
 		return nil, err
 	}

internal/rpc/group/sync.go

@@ -11,9 +11,6 @@ import (
 	"github.com/openimsdk/protocol/constant"
 	pbgroup "github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/protocol/sdkws"
-	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/mcontext"
-	"github.com/openimsdk/tools/utils/datautil"
 )
 
 const versionSyncLimit = 500
@@ -23,10 +20,8 @@ func (g *groupServer) GetFullGroupMemberUserIDs(ctx context.Context, req *pbgrou
 	if err != nil {
 		return nil, err
 	}
-	if opUserID := mcontext.GetOpUserID(ctx); !datautil.Contain(opUserID, g.config.Share.IMAdminUserID...) {
-		if !datautil.Contain(opUserID, userIDs...) {
-			return nil, errs.ErrNoPermission.WrapMsg("user not in group")
-		}
+	if err := authverify.CheckAccessIn(ctx, userIDs...); err != nil {
+		return nil, err
 	}
 	vl, err := g.db.FindMaxGroupMemberVersionCache(ctx, req.GroupID)
 	if err != nil {
@@ -52,7 +47,7 @@ func (g *groupServer) GetFullJoinGroupIDs(ctx context.Context, req *pbgroup.GetF
 	if err != nil {
 		return nil, err
 	}
-	groupIDs, err := s.db.FindJoinGroupID(ctx, req.UserID)
+	groupIDs, err := g.db.FindJoinGroupID(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -68,17 +63,17 @@ func (g *groupServer) GetFullJoinGroupIDs(ctx context.Context, req *pbgroup.GetF
 	}, nil
 }
 
-func (s *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgroup.GetIncrementalGroupMemberReq) (*pbgroup.GetIncrementalGroupMemberResp, error) {
-	group, err := s.db.TakeGroup(ctx, req.GroupID)
+func (g *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgroup.GetIncrementalGroupMemberReq) (*pbgroup.GetIncrementalGroupMemberResp, error) {
+	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+		return nil, err
+	}
+	group, err := g.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
 	if group.Status == constant.GroupStatusDismissed {
 		return nil, servererrs.ErrDismissedAlready.Wrap()
 	}
-	if _, err := g.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx)); err != nil {
-		return nil, err
-	}
 	var (
 		hasGroupUpdate bool
 		sortVersion    uint64
@@ -89,7 +84,7 @@ func (s *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 := s.db.FindMemberIncrVersion(ctx, groupID, version, limit)
+			vl, err := g.db.FindMemberIncrVersion(ctx, groupID, version, limit)
 			if err != nil {
 				return nil, err
 			}
@@ -112,9 +107,9 @@ func (s *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgrou
 			}
 			return vl, nil
 		},
-		CacheMaxVersion: s.db.FindMaxGroupMemberVersionCache,
+		CacheMaxVersion: g.db.FindMaxGroupMemberVersionCache,
 		Find: func(ctx context.Context, ids []string) ([]*sdkws.GroupMemberFullInfo, error) {
-			return s.getGroupMembersInfo(ctx, req.GroupID, ids)
+			return g.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 +128,15 @@ func (s *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgrou
 		return nil, err
 	}
 	if resp.Full || hasGroupUpdate {
-		count, err := s.db.FindGroupMemberNum(ctx, group.GroupID)
+		count, err := g.db.FindGroupMemberNum(ctx, group.GroupID)
 		if err != nil {
 			return nil, err
 		}
-		owner, err := s.db.TakeGroupOwner(ctx, group.GroupID)
+		owner, err := g.db.TakeGroupOwner(ctx, group.GroupID)
 		if err != nil {
 			return nil, err
 		}
-		resp.Group = s.groupDB2PB(group, owner.UserID, count)
+		resp.Group = g.groupDB2PB(group, owner.UserID, count)
 	}
 	return resp, nil
 }
@@ -155,9 +150,9 @@ func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.
 		VersionKey:      req.UserID,
 		VersionID:       req.VersionID,
 		VersionNumber:   req.Version,
-		Version:         s.db.FindJoinIncrVersion,
-		CacheMaxVersion: s.db.FindMaxJoinGroupVersionCache,
-		Find:            s.getGroupsInfo,
+		Version:         g.db.FindJoinIncrVersion,
+		CacheMaxVersion: g.db.FindMaxJoinGroupVersionCache,
+		Find:            g.getGroupsInfo,
 		Resp: func(version *model.VersionLog, delIDs []string, insertList, updateList []*sdkws.GroupInfo, full bool) *pbgroup.GetIncrementalJoinGroupResp {
 			return &pbgroup.GetIncrementalJoinGroupResp{
 				VersionID: version.ID.Hex(),
@@ -171,3 +166,23 @@ 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/as_read.go

@@ -18,6 +18,7 @@ import (
 	"context"
 	"errors"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	cbapi "github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/msg"
@@ -29,6 +30,9 @@ import (
 )
 
 func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *msg.GetConversationsHasReadAndMaxSeqReq) (*msg.GetConversationsHasReadAndMaxSeqResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	var conversationIDs []string
 	if len(req.ConversationIDs) == 0 {
 		var err error
@@ -82,6 +86,9 @@ func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *m
 }
 
 func (m *msgServer) SetConversationHasReadSeq(ctx context.Context, req *msg.SetConversationHasReadSeqReq) (*msg.SetConversationHasReadSeqResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	maxSeq, err := m.MsgDatabase.GetMaxSeq(ctx, req.ConversationID)
 	if err != nil {
 		return nil, err
@@ -97,8 +104,8 @@ func (m *msgServer) SetConversationHasReadSeq(ctx context.Context, req *msg.SetC
 }
 
 func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadReq) (*msg.MarkMsgsAsReadResp, error) {
-	if len(req.Seqs) < 1 {
-		return nil, errs.ErrArgs.WrapMsg("seqs must not be empty")
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
 	}
 	maxSeq, err := m.MsgDatabase.GetMaxSeq(ctx, req.ConversationID)
 	if err != nil {
@@ -139,6 +146,9 @@ func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadR
 }
 
 func (m *msgServer) MarkConversationAsRead(ctx context.Context, req *msg.MarkConversationAsReadReq) (*msg.MarkConversationAsReadResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	conversation, err := m.ConversationLocalCache.GetConversation(ctx, req.UserID, req.ConversationID)
 	if err != nil {
 		return nil, err
@@ -216,5 +226,4 @@ func (m *msgServer) sendMarkAsReadNotification(ctx context.Context, conversation
 		HasReadSeq:       hasReadSeq,
 	}
 	m.notificationSender.NotificationWithSessionType(ctx, sendID, recvID, constant.HasReadReceipt, sessionType, tips)
-
 }

internal/rpc/msg/delete.go

@@ -94,6 +94,9 @@ func (m *msgServer) DeleteMsgs(ctx context.Context, req *msg.DeleteMsgsReq) (*ms
 }
 
 func (m *msgServer) DeleteMsgPhysicalBySeq(ctx context.Context, req *msg.DeleteMsgPhysicalBySeqReq) (*msg.DeleteMsgPhysicalBySeqResp, error) {
+	if err := authverify.CheckAdmin(ctx); err != nil {
+		return nil, err
+	}
 	err := m.MsgDatabase.DeleteMsgsPhysicalBySeqs(ctx, req.ConversationID, req.Seqs)
 	if err != nil {
 		return nil, err

internal/rpc/msg/notification.go

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

internal/rpc/msg/send.go

@@ -17,6 +17,9 @@ package msg
 import (
 	"context"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
 	"github.com/openimsdk/open-im-server/v3/pkg/util/conversationutil"
@@ -36,6 +39,9 @@ func (m *msgServer) SendMsg(ctx context.Context, req *pbmsg.SendMsgReq) (*pbmsg.
 	if req.MsgData == nil {
 		return nil, errs.ErrArgs.WrapMsg("msgData is nil")
 	}
+	if err := authverify.CheckAccess(ctx, req.MsgData.SendID); err != nil {
+		return nil, err
+	}
 	before := new(*sdkws.MsgData)
 	resp, err := m.sendMsg(ctx, req, before)
 	if err != nil {
@@ -171,13 +177,7 @@ func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *pbmsg.SendMsgReq
 	isSend := true
 	isNotification := msgprocessor.IsNotificationByMsg(req.MsgData)
 	if !isNotification {
-		isSend, err = m.modifyMessageByUserMessageReceiveOpt(
-			ctx,
-			req.MsgData.RecvID,
-			conversationutil.GenConversationIDForSingle(req.MsgData.SendID, req.MsgData.RecvID),
-			constant.SingleChatType,
-			req,
-		)
+		isSend, err = m.modifyMessageByUserMessageReceiveOpt(authverify.WithTempAdmin(ctx), req.MsgData.RecvID, conversationutil.GenConversationIDForSingle(req.MsgData.SendID, req.MsgData.RecvID), constant.SingleChatType, req)
 		if err != nil {
 			return nil, err
 		}

internal/rpc/msg/seq.go

@@ -17,9 +17,10 @@ package msg
 import (
 	"context"
 	"errors"
+	"sort"
+
 	pbmsg "github.com/openimsdk/protocol/msg"
 	"github.com/redis/go-redis/v9"
-	"sort"
 )
 
 func (m *msgServer) GetConversationMaxSeq(ctx context.Context, req *pbmsg.GetConversationMaxSeqReq) (*pbmsg.GetConversationMaxSeqResp, error) {

internal/rpc/msg/server.go

@@ -17,22 +17,23 @@ 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"
 )
@@ -57,14 +58,14 @@ type Config struct {
 // MsgServer encapsulates dependencies required for message handling.
 type msgServer struct {
 	msg.UnimplementedMsgServer
-	RegisterCenter         discovery.SvcDiscoveryRegistry   // Service discovery registry for service registration.
+	RegisterCenter         discovery.Conn                   // 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     *rpcclient.NotificationSender    // RPC client for sending notifications.
+	notificationSender     *notification.NotificationSender // RPC client for sending notifications.
 	msgNotificationSender  *MsgNotificationSender           // RPC client for sending msg notifications.
 	config                 *Config                          // Global configuration settings.
 	webhookClient          *webhook.Client
@@ -76,12 +77,18 @@ func (m *msgServer) addInterceptorHandler(interceptorFunc ...MessageInterceptorF
 
 }
 
-func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
-	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
+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)
 	if err != nil {
 		return err
 	}
-	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
+	dbb := dbbuild.NewBuilder(&config.MongodbConfig, &config.RedisConfig)
+	mgocli, err := dbb.Mongo(ctx)
+	if err != nil {
+		return err
+	}
+	rdb, err := dbb.Redis(ctx)
 	if err != nil {
 		return err
 	}
@@ -89,7 +96,16 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	if err != nil {
 		return err
 	}
-	msgModel := redis.NewMsgCache(rdb, msgDocModel)
+	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)
+	}
 	seqConversation, err := mgo.NewSeqConversationMongo(mgocli.GetDB())
 	if err != nil {
 		return err
@@ -100,10 +116,6 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 		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
@@ -121,6 +133,7 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 		return err
 	}
 	conversationClient := rpcli.NewConversationClient(conversationConn)
+	msgDatabase := controller.NewCommonMsgDatabase(msgDocModel, msgModel, seqUserCache, seqConversationCache, redisProducer)
 	s := &msgServer{
 		MsgDatabase:            msgDatabase,
 		RegisterCenter:         client,
@@ -133,8 +146,8 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 		conversationClient:     conversationClient,
 	}
 
-	s.notificationSender = rpcclient.NewNotificationSender(&config.NotificationConfig, rpcclient.WithLocalSendMsg(s.SendMsg))
-	s.msgNotificationSender = NewMsgNotificationSender(config, rpcclient.WithLocalSendMsg(s.SendMsg))
+	s.notificationSender = notification.NewNotificationSender(&config.NotificationConfig, notification.WithLocalSendMsg(s.SendMsg))
+	s.msgNotificationSender = NewMsgNotificationSender(config, notification.WithLocalSendMsg(s.SendMsg))
 
 	msg.RegisterMsgServer(server, s)
 

internal/rpc/msg/statistics.go

@@ -16,15 +16,20 @@ package msg
 
 import (
 	"context"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
+
 	"github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/utils/datautil"
 )
 
 func (m *msgServer) GetActiveUser(ctx context.Context, req *msg.GetActiveUserReq) (*msg.GetActiveUserResp, error) {
+	if err := authverify.CheckAdmin(ctx); err != nil {
+		return nil, err
+	}
 	msgCount, userCount, users, dateCount, err := m.MsgDatabase.RangeUserSendCount(ctx, time.UnixMilli(req.Start), time.UnixMilli(req.End), req.Group, req.Ase, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
@@ -60,6 +65,9 @@ func (m *msgServer) GetActiveUser(ctx context.Context, req *msg.GetActiveUserReq
 }
 
 func (m *msgServer) GetActiveGroup(ctx context.Context, req *msg.GetActiveGroupReq) (*msg.GetActiveGroupResp, error) {
+	if err := authverify.CheckAdmin(ctx); err != nil {
+		return nil, err
+	}
 	msgCount, groupCount, groups, dateCount, err := m.MsgDatabase.RangeGroupSendCount(ctx, time.UnixMilli(req.Start), time.UnixMilli(req.End), req.Ase, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err

internal/rpc/msg/sync_msg.go

@@ -29,6 +29,9 @@ import (
 )
 
 func (m *msgServer) PullMessageBySeqs(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	resp := &sdkws.PullMessageBySeqsResp{}
 	resp.Msgs = make(map[string]*sdkws.PullMsgs)
 	resp.NotificationMsgs = make(map[string]*sdkws.PullMsgs)

internal/rpc/relation/black.go

@@ -47,6 +47,9 @@ func (s *friendServer) GetPaginationBlacks(ctx context.Context, req *relation.Ge
 }
 
 func (s *friendServer) IsBlack(ctx context.Context, req *relation.IsBlackReq) (*relation.IsBlackResp, error) {
+	if err := authverify.CheckAccessIn(ctx, req.UserID1, req.UserID2); err != nil {
+		return nil, err
+	}
 	in1, in2, err := s.blackDatabase.CheckIn(ctx, req.UserID1, req.UserID2)
 	if err != nil {
 		return nil, err

internal/rpc/relation/friend.go

@@ -17,26 +17,24 @@ 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"
@@ -48,7 +46,7 @@ type friendServer struct {
 	db                 controller.FriendDatabase
 	blackDatabase      controller.BlackDatabase
 	notificationSender *FriendNotificationSender
-	RegisterCenter     discovery.SvcDiscoveryRegistry
+	RegisterCenter     discovery.Conn
 	config             *Config
 	webhookClient      *webhook.Client
 	queue              *memamq.MemoryQueue
@@ -67,12 +65,13 @@ type Config struct {
 	Discovery          config.Discovery
 }
 
-func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
-	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
+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)
 	if err != nil {
 		return err
 	}
-	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
+	rdb, err := dbb.Redis(ctx)
 	if err != nil {
 		return err
 	}
@@ -115,12 +114,12 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 		db: controller.NewFriendDatabase(
 			friendMongoDB,
 			friendRequestMongoDB,
-			redis.NewFriendCacheRedis(rdb, &config.LocalCacheConfig, friendMongoDB, redis.GetRocksCacheOptions()),
+			redis.NewFriendCacheRedis(rdb, &config.LocalCacheConfig, friendMongoDB),
 			mgocli.GetTx(),
 		),
 		blackDatabase: controller.NewBlackDatabase(
 			blackMongoDB,
-			redis.NewBlackCacheRedis(rdb, &config.LocalCacheConfig, blackMongoDB, redis.GetRocksCacheOptions()),
+			redis.NewBlackCacheRedis(rdb, &config.LocalCacheConfig, blackMongoDB),
 		),
 		notificationSender: notificationSender,
 		RegisterCenter:     client,
@@ -281,6 +280,9 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *relation.SetFri
 }
 
 func (s *friendServer) GetFriendInfo(ctx context.Context, req *relation.GetFriendInfoReq) (*relation.GetFriendInfoResp, error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
 	friends, err := s.db.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
 	if err != nil {
 		return nil, err
@@ -289,6 +291,9 @@ func (s *friendServer) GetFriendInfo(ctx context.Context, req *relation.GetFrien
 }
 
 func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *relation.GetDesignatedFriendsReq) (resp *relation.GetDesignatedFriendsResp, err error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
 	resp = &relation.GetDesignatedFriendsResp{}
 	if datautil.Duplicate(req.FriendUserIDs) {
 		return nil, errs.ErrArgs.WrapMsg("friend userID repeated")
@@ -314,9 +319,10 @@ func (s *friendServer) getFriend(ctx context.Context, ownerUserID string, friend
 }
 
 // Get the list of friend requests sent out proactively.
-func (s *friendServer) GetDesignatedFriendsApply(ctx context.Context,
-	req *relation.GetDesignatedFriendsApplyReq,
-) (resp *relation.GetDesignatedFriendsApplyResp, err error) {
+func (s *friendServer) GetDesignatedFriendsApply(ctx context.Context, req *relation.GetDesignatedFriendsApplyReq) (resp *relation.GetDesignatedFriendsApplyResp, err error) {
+	if err := authverify.CheckAccessIn(ctx, req.FromUserID, req.ToUserID); err != nil {
+		return nil, err
+	}
 	friendRequests, err := s.db.FindBothFriendRequests(ctx, req.FromUserID, req.ToUserID)
 	if err != nil {
 		return nil, err
@@ -375,6 +381,9 @@ func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *r
 
 // ok.
 func (s *friendServer) IsFriend(ctx context.Context, req *relation.IsFriendReq) (resp *relation.IsFriendResp, err error) {
+	if err := authverify.CheckAccessIn(ctx, req.UserID1, req.UserID2); err != nil {
+		return nil, err
+	}
 	resp = &relation.IsFriendResp{}
 	resp.InUser1Friends, resp.InUser2Friends, err = s.db.CheckIn(ctx, req.UserID1, req.UserID2)
 	if err != nil {
@@ -427,6 +436,9 @@ func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *relatio
 		return nil, errs.ErrArgs.WrapMsg("userIDList repeated")
 	}
 
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
 	userMap, err := s.userClient.GetUsersInfoMap(ctx, req.UserIDList)
 	if err != nil {
 		return nil, err
@@ -495,10 +507,7 @@ func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *relatio
 	return resp, nil
 }
 
-func (s *friendServer) UpdateFriends(
-	ctx context.Context,
-	req *relation.UpdateFriendsReq,
-) (*relation.UpdateFriendsResp, error) {
+func (s *friendServer) UpdateFriends(ctx context.Context, req *relation.UpdateFriendsReq) (*relation.UpdateFriendsResp, error) {
 	if len(req.FriendUserIDs) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("friendIDList is empty")
 	}
@@ -506,6 +515,10 @@ func (s *friendServer) UpdateFriends(
 		return nil, errs.ErrArgs.WrapMsg("friendIDList repeated")
 	}
 
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+
 	_, err := s.db.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
 	if err != nil {
 		return nil, err

internal/rpc/relation/notification.go

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

internal/rpc/third/log.go

@@ -25,6 +25,7 @@ import (
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/third"
 	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/mcontext"
 	"github.com/openimsdk/tools/utils/datautil"
 )
 
@@ -45,7 +46,7 @@ func genLogID() string {
 
 func (t *thirdServer) UploadLogs(ctx context.Context, req *third.UploadLogsReq) (*third.UploadLogsResp, error) {
 	var dbLogs []*relationtb.Log
-	userID := ctx.Value(constant.OpUserID).(string)
+	userID := mcontext.GetOpUserID(ctx)
 	platform := constant.PlatformID2Name[int(req.Platform)]
 	for _, fileURL := range req.FileURLs {
 		log := relationtb.Log{

internal/rpc/third/third.go

@@ -17,9 +17,15 @@ package third
 import (
 	"context"
 	"fmt"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
+	"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"
+
 	"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/database/mgo"
@@ -29,8 +35,6 @@ 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"
@@ -60,15 +64,17 @@ type Config struct {
 	Discovery          config.Discovery
 }
 
-func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
-	mgocli, err := mongoutil.NewMongoDB(ctx, config.MongodbConfig.Build())
+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)
 	if err != nil {
 		return err
 	}
-	rdb, err := redisutil.NewRedisClient(ctx, config.RedisConfig.Build())
+	rdb, err := dbb.Redis(ctx)
 	if err != nil {
 		return err
 	}
+
 	logdb, err := mgo.NewLogMongo(mgocli.GetDB())
 	if err != nil {
 		return err
@@ -77,15 +83,31 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	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
-	enable := config.RpcConfig.Object.Enable
-	var (
-		o s3.Interface
-	)
-	switch enable {
+	var o s3.Interface
+	switch enable := config.RpcConfig.Object.Enable; enable {
 	case "minio":
-		o, err = minio.NewMinio(ctx, redis.NewMinioCache(rdb), *config.MinioConfig.Build())
+		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())
 	case "cos":
 		o, err = cos.NewCos(*config.RpcConfig.Object.Cos.Build())
 	case "oss":
@@ -94,6 +116,8 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 		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)
 	}
@@ -106,7 +130,7 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	}
 	localcache.InitLocalCache(&config.LocalCacheConfig)
 	third.RegisterThirdServer(server, &thirdServer{
-		thirdDatabase: controller.NewThirdDatabase(redis.NewThirdCache(rdb), logdb),
+		thirdDatabase: controller.NewThirdDatabase(thirdCache, logdb),
 		s3dataBase:    controller.NewS3Database(rdb, o, s3db),
 		defaultExpire: time.Hour * 24 * 7,
 		config:        config,
@@ -125,6 +149,9 @@ func (t *thirdServer) FcmUpdateToken(ctx context.Context, req *third.FcmUpdateTo
 }
 
 func (t *thirdServer) SetAppBadge(ctx context.Context, req *third.SetAppBadgeReq) (resp *third.SetAppBadgeResp, err error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
 	err = t.thirdDatabase.SetAppBadge(ctx, req.UserID, int(req.AppUnreadCount))
 	if err != nil {
 		return nil, err

internal/rpc/user/notification.go

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

internal/tools/cron/cron_task.go

@@ -1,47 +1,37 @@
-package tools
+package cron
 
 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 CronTaskConfig struct {
+type Config struct {
 	CronTask  config.CronTask
 	Share     config.Share
 	Discovery config.Discovery
-
-	runTimeEnv string
 }
 
-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)
+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)
 	if conf.CronTask.RetainChatRecords < 1 {
-		return errs.New("msg destruct time must be greater than 1").Wrap()
+		log.ZInfo(ctx, "disable cron")
+		<-ctx.Done()
+		return nil
 	}
-	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)
@@ -88,13 +78,15 @@ func Start(ctx context.Context, conf *CronTaskConfig) error {
 	}
 	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             *CronTaskConfig
+	config             *Config
 	cron               *cron.Cron
 	msgClient          msg.MsgClient
 	conversationClient pbconversation.ConversationClient

internal/tools/cron/cron_test.go

@@ -0,0 +1,64 @@
+package cron
+
+import (
+	"context"
+	"testing"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
+	kdisc "github.com/openimsdk/open-im-server/v3/pkg/common/discovery"
+	pbconversation "github.com/openimsdk/protocol/conversation"
+	"github.com/openimsdk/protocol/msg"
+	"github.com/openimsdk/protocol/third"
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/mw"
+	"github.com/robfig/cron/v3"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+func TestName(t *testing.T) {
+	conf := &config.Discovery{
+		Enable: config.ETCD,
+		Etcd: config.Etcd{
+			RootDirectory: "openim",
+			Address:       []string{"localhost:12379"},
+		},
+	}
+	client, err := kdisc.NewDiscoveryRegister(conf, nil)
+	if err != nil {
+		panic(err)
+	}
+	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()))
+	ctx := mcontext.SetOpUserID(context.Background(), "imAdmin")
+	msgConn, err := client.GetConn(ctx, "msg-rpc-service")
+	if err != nil {
+		panic(err)
+	}
+	thirdConn, err := client.GetConn(ctx, "third-rpc-service")
+	if err != nil {
+		panic(err)
+	}
+
+	conversationConn, err := client.GetConn(ctx, "conversation-rpc-service")
+	if err != nil {
+		panic(err)
+	}
+
+	srv := &cronServer{
+		ctx: ctx,
+		config: &CronTaskConfig{
+			CronTask: config.CronTask{
+				RetainChatRecords: 1,
+				FileExpireTime:    1,
+				DeleteObjectType:  []string{"msg-picture", "msg-file", "msg-voice", "msg-video", "msg-video-snapshot", "sdklog", ""},
+			},
+		},
+		cron:               cron.New(),
+		msgClient:          msg.NewMsgClient(msgConn),
+		conversationClient: pbconversation.NewConversationClient(conversationConn),
+		thirdClient:        third.NewThirdClient(thirdConn),
+	}
+	srv.deleteMsg()
+	//srv.clearS3()
+	//srv.clearUserMsg()
+}

internal/tools/cron/msg.go

@@ -1,12 +1,13 @@
-package tools
+package cron
 
 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/cron/s3.go

@@ -1,12 +1,13 @@
-package tools
+package cron
 
 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/cron/user_msg.go

@@ -1,12 +1,13 @@
-package tools
+package cron
 
 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,14 +4,23 @@
 package main
 
 import (
-	"github.com/openimsdk/gomake/mageutil"
+	"flag"
 	"os"
+
+	"github.com/openimsdk/gomake/mageutil"
 )
 
 var Default = Build
 
 func Build() {
-	mageutil.Build()
+	flag.Parse()
+
+	bin := flag.Args()
+	if len(bin) != 0 {
+		bin = bin[1:]
+	}
+
+	mageutil.Build(bin)
 }
 
 func Start() {

pkg/authverify/token.go

@@ -51,29 +51,70 @@ func CheckSystemAccount(ctx context.Context, level int32) bool {
 }
 
 const (
-	CtxIsAdminKey = "CtxIsAdminKey"
+	CtxAdminUserIDsKey = "CtxAdminUserIDsKey"
 )
 
 func WithIMAdminUserIDs(ctx context.Context, imAdminUserID []string) context.Context {
-	return context.WithValue(ctx, CtxIsAdminKey, imAdminUserID)
+	return context.WithValue(ctx, CtxAdminUserIDsKey, imAdminUserID)
 }
 
 func GetIMAdminUserIDs(ctx context.Context) []string {
-	imAdminUserID, _ := ctx.Value(CtxIsAdminKey).([]string)
+	imAdminUserID, _ := ctx.Value(CtxAdminUserIDsKey).([]string)
 	return imAdminUserID
 }
 
 func IsAdmin(ctx context.Context) bool {
-	return datautil.Contain(mcontext.GetOpUserID(ctx), GetIMAdminUserIDs(ctx)...)
+	return IsTempAdmin(ctx) || IsSystemAdmin(ctx)
 }
 
 func CheckAccess(ctx context.Context, ownerUserID string) error {
-	opUserID := mcontext.GetOpUserID(ctx)
-	if opUserID == ownerUserID {
+	if mcontext.GetOpUserID(ctx) == ownerUserID {
 		return nil
 	}
-	if datautil.Contain(mcontext.GetOpUserID(ctx), GetIMAdminUserIDs(ctx)...) {
+	if IsAdmin(ctx) {
 		return nil
 	}
 	return servererrs.ErrNoPermission.WrapMsg("ownerUserID", ownerUserID)
 }
+
+func CheckAccessIn(ctx context.Context, ownerUserIDs ...string) error {
+	opUserID := mcontext.GetOpUserID(ctx)
+	for _, userID := range ownerUserIDs {
+		if opUserID == userID {
+			return nil
+		}
+	}
+	if IsAdmin(ctx) {
+		return nil
+	}
+	return servererrs.ErrNoPermission.WrapMsg("opUser in ownerUserIDs")
+}
+
+var tempAdminValue = []string{"1"}
+
+const ctxTempAdminKey = "ctxImTempAdminKey"
+
+func WithTempAdmin(ctx context.Context) context.Context {
+	keys, _ := ctx.Value(constant.RpcCustomHeader).([]string)
+	if datautil.Contain(ctxTempAdminKey, keys...) {
+		return ctx
+	}
+	if len(keys) > 0 {
+		temp := make([]string, 0, len(keys)+1)
+		temp = append(temp, keys...)
+		keys = append(temp, ctxTempAdminKey)
+	} else {
+		keys = []string{ctxTempAdminKey}
+	}
+	ctx = context.WithValue(ctx, constant.RpcCustomHeader, keys)
+	return context.WithValue(ctx, ctxTempAdminKey, tempAdminValue)
+}
+
+func IsTempAdmin(ctx context.Context) bool {
+	values, _ := ctx.Value(ctxTempAdminKey).([]string)
+	return datautil.Equal(tempAdminValue, values)
+}
+
+func IsSystemAdmin(ctx context.Context) bool {
+	return datautil.Contain(mcontext.GetOpUserID(ctx), GetIMAdminUserIDs(ctx)...)
+}

pkg/common/cmd/api.go

@@ -19,6 +19,7 @@ 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"
@@ -32,7 +33,7 @@ type ApiCmd struct {
 }
 
 func NewApiCmd() *ApiCmd {
-	apiConfig := api.Config{AllConfig: &config.AllConfig{}}
+	var apiConfig api.Config
 	ret := &ApiCmd{apiConfig: &apiConfig}
 	ret.configMap = map[string]any{
 		config.DiscoveryConfigFilename:          &apiConfig.Discovery,
@@ -61,7 +62,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 = ret.configPath
+		apiConfig.ConfigPath = config.Path(ret.configPath)
 		return ret.runE()
 	}
 	return ret
@@ -72,5 +73,22 @@ func (a *ApiCmd) Exec() error {
 }
 
 func (a *ApiCmd) runE() error {
-	return api.Start(a.ctx, a.Index(), a.apiConfig)
+	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,
+	)
 }

pkg/common/cmd/auth.go

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

pkg/common/cmd/msg_gateway.go

@@ -19,6 +19,7 @@ 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"
@@ -55,5 +56,20 @@ func (m *MsgGatewayCmd) Exec() error {
 }
 
 func (m *MsgGatewayCmd) runE() error {
-	return msggateway.Start(m.ctx, m.Index(), m.msgGatewayConfig)
+	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,
+	)
 }

pkg/common/cmd/msg_transfer.go

@@ -19,6 +19,7 @@ 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"
@@ -56,5 +57,19 @@ func (m *MsgTransferCmd) Exec() error {
 }
 
 func (m *MsgTransferCmd) runE() error {
-	return msgtransfer.Start(m.ctx, m.Index(), m.msgTransferConfig)
+	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,
+	)
 }

pkg/common/cmd/push.go

@@ -38,6 +38,7 @@ 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,
@@ -48,7 +49,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 = ret.ConfigPath()
+		ret.pushConfig.FcmConfigPath = config.Path(ret.ConfigPath())
 		return ret.runE()
 	}
 	return ret

pkg/common/cmd/root.go

@@ -12,7 +12,6 @@ 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"
 )
@@ -86,14 +85,12 @@ func (r *RootCmd) initEtcd() error {
 		return err
 	}
 	disConfig := config.Discovery{}
-	env := runtimeenv.RuntimeEnvironment()
-	err = config.Load(configDirectory, config.DiscoveryConfigFilename, config.EnvPrefixMap[config.DiscoveryConfigFilename],
-		env, &disConfig)
+	err = config.Load(configDirectory, config.DiscoveryConfigFilename, config.EnvPrefixMap[config.DiscoveryConfigFilename], &disConfig)
 	if err != nil {
 		return err
 	}
 	if disConfig.Enable == config.ETCD {
-		discov, _ := kdisc.NewDiscoveryRegister(&disConfig, env, nil)
+		discov, _ := kdisc.NewDiscoveryRegister(&disConfig, nil)
 		r.etcdClient = discov.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
 	}
 	return nil
@@ -125,18 +122,16 @@ 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], runtimeEnv, configStruct)
+		err := config.Load(configDirectory, configFileName, config.EnvPrefixMap[configFileName], configStruct)
 		if err != nil {
 			return err
 		}
 	}
 	// Load common log configuration file
-	return config.Load(configDirectory, config.LogConfigFileName, config.EnvPrefixMap[config.LogConfigFileName], runtimeEnv, &r.log)
+	return config.Load(configDirectory, config.LogConfigFileName, config.EnvPrefixMap[config.LogConfigFileName], &r.log)
 }
 
 func (r *RootCmd) updateConfigFromEtcd(opts *CmdOpts) error {
@@ -208,7 +203,6 @@ 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/constant.go

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

pkg/common/config/global.go

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

pkg/common/config/load_config.go

@@ -7,11 +7,12 @@ 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, runtimeEnv string, config any) error {
-	if runtimeEnv == KUBERNETES {
+func Load(configDirectory string, configFileName string, envPrefix string, config any) error {
+	if runtimeenv.RuntimeEnvironment() == KUBERNETES {
 		mountPath := os.Getenv(MountConfigFilePath)
 		if mountPath == "" {
 			return errs.ErrArgs.WrapMsg(MountConfigFilePath + " env is empty")
@@ -35,7 +36,7 @@ func loadConfig(path string, envPrefix string, config any) error {
 	}
 
 	if err := v.Unmarshal(config, func(config *mapstructure.DecoderConfig) {
-		config.TagName = "mapstructure"
+		config.TagName = StructTagName
 	}); err != nil {
 		return errs.WrapMsg(err, "failed to unmarshal config", "path", path, "envPrefix", envPrefix)
 	}

pkg/common/config/load_config_test.go

@@ -1,27 +1,51 @@
 package config
 
 import (
-	"github.com/stretchr/testify/assert"
+	"os"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestLoadLogConfig(t *testing.T) {
 	var log Log
-	err := LoadConfig("../../../config/log.yml", "IMENV_LOG", &log)
+	os.Setenv("IMENV_LOG_REMAINLOGLEVEL", "5")
+	err := Load("../../../config/", "log.yml", "IMENV_LOG", &log)
 	assert.Nil(t, err)
-	assert.Equal(t, "../../../../logs/", log.StorageLocation)
+	t.Log(log.RemainLogLevel)
+	// assert.Equal(t, "../../../../logs/", log.StorageLocation)
+}
+
+func TestLoadMongoConfig(t *testing.T) {
+	var mongo Mongo
+	// os.Setenv("DEPLOYMENT_TYPE", "kubernetes")
+	os.Setenv("IMENV_MONGODB_PASSWORD", "openIM1231231")
+	// os.Setenv("IMENV_MONGODB_URI", "openIM123")
+	// os.Setenv("IMENV_MONGODB_USERNAME", "openIM123")
+	err := Load("../../../config/", "mongodb.yml", "IMENV_MONGODB", &mongo)
+	// 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)
 }
 
 func TestLoadMinioConfig(t *testing.T) {
 	var storageConfig Minio
-	err := LoadConfig("../../../config/minio.yml", "IMENV_MINIO", &storageConfig)
+	err := Load("../../../config/minio.yml", "IMENV_MINIO", "", &storageConfig)
 	assert.Nil(t, err)
 	assert.Equal(t, "openim", storageConfig.Bucket)
 }
 
 func TestLoadWebhooksConfig(t *testing.T) {
 	var webhooks Webhooks
-	err := LoadConfig("../../../config/webhooks.yml", "IMENV_WEBHOOKS", &webhooks)
+	err := Load("../../../config/webhooks.yml", "IMENV_WEBHOOKS", "", &webhooks)
 	assert.Nil(t, err)
 	assert.Equal(t, 5, webhooks.BeforeAddBlack.Timeout)
 
@@ -29,7 +53,7 @@ func TestLoadWebhooksConfig(t *testing.T) {
 
 func TestLoadOpenIMRpcUserConfig(t *testing.T) {
 	var user User
-	err := LoadConfig("../../../config/openim-rpc-user.yml", "IMENV_OPENIM_RPC_USER", &user)
+	err := Load("../../../config/openim-rpc-user.yml", "IMENV_OPENIM_RPC_USER", "", &user)
 	assert.Nil(t, err)
 	//export IMENV_OPENIM_RPC_USER_RPC_LISTENIP="0.0.0.0"
 	assert.Equal(t, "0.0.0.0", user.RPC.ListenIP)
@@ -39,14 +63,14 @@ func TestLoadOpenIMRpcUserConfig(t *testing.T) {
 
 func TestLoadNotificationConfig(t *testing.T) {
 	var noti Notification
-	err := LoadConfig("../../../config/notification.yml", "IMENV_NOTIFICATION", &noti)
+	err := Load("../../../config/notification.yml", "IMENV_NOTIFICATION", "", &noti)
 	assert.Nil(t, err)
 	assert.Equal(t, "Your friend's profile has been changed", noti.FriendRemarkSet.OfflinePush.Title)
 }
 
 func TestLoadOpenIMThirdConfig(t *testing.T) {
 	var third Third
-	err := LoadConfig("../../../config/openim-rpc-third.yml", "IMENV_OPENIM_RPC_THIRD", &third)
+	err := Load("../../../config/openim-rpc-third.yml", "IMENV_OPENIM_RPC_THIRD", "", &third)
 	assert.Nil(t, err)
 	assert.Equal(t, "enabled", third.Object.Enable)
 	assert.Equal(t, "https://oss-cn-chengdu.aliyuncs.com", third.Object.Oss.Endpoint)
@@ -62,7 +86,7 @@ func TestLoadOpenIMThirdConfig(t *testing.T) {
 
 func TestTransferConfig(t *testing.T) {
 	var tran MsgTransfer
-	err := LoadConfig("../../../config/openim-msgtransfer.yml", "IMENV_OPENIM-MSGTRANSFER", &tran)
+	err := Load("../../../config/openim-msgtransfer.yml", "IMENV_OPENIM-MSGTRANSFER", "", &tran)
 	assert.Nil(t, err)
 	assert.Equal(t, true, tran.Prometheus.Enable)
 	assert.Equal(t, true, tran.Prometheus.AutoSetPorts)

pkg/common/config/parse.go

@@ -18,15 +18,16 @@ 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 (
-	FileName = "config.yaml"
+	DefaultFolderPath = "../config/"
 )
 
 // return absolude path join ../config/, this is k8s container config path.
@@ -56,10 +57,13 @@ func GetProjectRoot() (string, error) {
 	return projectRoot, nil
 }
 
-func GetOptionsByNotification(cfg NotificationConfig) msgprocessor.Options {
+func GetOptionsByNotification(cfg NotificationConfig, sendMessage *bool) msgprocessor.Options {
 	opts := msgprocessor.NewOptions()
 
-	if cfg.UnreadCount {
+	if sendMessage != nil {
+		cfg.IsSendMsg = *sendMessage
+	}
+	if cfg.IsSendMsg {
 		opts = msgprocessor.WithOptions(opts, msgprocessor.WithUnreadCount(true))
 	}
 	if cfg.OfflinePush.Enable {

pkg/common/discovery/discoveryregister.go

@@ -19,6 +19,8 @@ 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"
@@ -28,8 +30,11 @@ import (
 )
 
 // NewDiscoveryRegister creates a new service discovery and registry client based on the provided environment type.
-func NewDiscoveryRegister(discovery *config.Discovery, runtimeEnv string, watchNames []string) (discovery.SvcDiscoveryRegistry, error) {
-	if runtimeEnv == config.KUBERNETES {
+func NewDiscoveryRegister(discovery *config.Discovery, watchNames []string) (discovery.SvcDiscoveryRegistry, error) {
+	if config.Standalone() {
+		return standalone.GetSvcDiscoveryRegistry(), nil
+	}
+	if runtimeenv.RuntimeEnvironment() == config.KUBERNETES {
 		return kubernetes.NewKubernetesConnManager(discovery.Kubernetes.Namespace,
 			grpc.WithDefaultCallOptions(
 				grpc.MaxCallSendMsgSize(1024*1024*20),

pkg/common/prommetrics/api.go

@@ -1,10 +1,11 @@
 package prommetrics
 
 import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"net"
 	"strconv"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
 var (
@@ -24,6 +25,10 @@ var (
 	)
 )
 
+func RegistryApi() {
+	registry.MustRegister(apiCounter, httpCounter)
+}
+
 func ApiInit(listener net.Listener) error {
 	apiRegistry := prometheus.NewRegistry()
 	cs := append(
@@ -41,9 +46,3 @@ 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

@@ -1,31 +0,0 @@
-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

@@ -1,15 +0,0 @@
-// 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,3 +24,7 @@ var (
 		Help: "The number of user login",
 	})
 )
+
+func RegistryAuth() {
+	registry.MustRegister(UserLoginCounter)
+}

pkg/common/prommetrics/grpc_msg.go

@@ -36,3 +36,12 @@ 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,3 +24,7 @@ var (
 		Help: "The number of online user num",
 	})
 )
+
+func RegistryMsgGateway() {
+	registry.MustRegister(OnlineUserGauge)
+}

pkg/common/prommetrics/grpc_push.go

@@ -28,3 +28,10 @@ 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,3 +8,7 @@ var (
 		Help: "The number of user login",
 	})
 )
+
+func RegistryUser() {
+	registry.MustRegister(UserRegisterCounter)
+}

pkg/common/prommetrics/prommetrics.go

@@ -15,14 +15,42 @@
 package prommetrics
 
 import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/collectors"
+	"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"
 )
 
 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{}),
@@ -36,3 +64,48 @@ 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,6 +14,8 @@
 
 package prommetrics
 
+import "testing"
+
 //func TestNewGrpcPromObj(t *testing.T) {
 //	// Create a custom metric to pass into the NewGrpcPromObj function.
 //	customMetric := prometheus.NewCounter(prometheus.CounterOpts{
@@ -67,3 +69,9 @@ package prommetrics
 //		})
 //	}
 //}
+
+func TestName(t *testing.T) {
+	RegistryApi()
+	RegistryApi()
+
+}

pkg/common/prommetrics/rpc.go

@@ -1,12 +1,13 @@
 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
@@ -22,6 +23,10 @@ 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,9 +15,10 @@
 package prommetrics
 
 import (
+	"net"
+
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
-	"net"
 )
 
 var (
@@ -43,6 +44,16 @@ 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

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

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

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

@@ -1,15 +0,0 @@
-// 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,64 +47,6 @@ 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,
@@ -122,8 +64,8 @@ func Start[T any](ctx context.Context, disc *conf.Discovery, prometheusConfig *c
 
 	options = append(options,
 		grpcsrv.GrpcServerMetadataContext(),
-		grpcsrv.GrpcServerLogger(),
 		grpcsrv.GrpcServerErrorConvert(),
+		grpcsrv.GrpcServerLogger(),
 		grpcsrv.GrpcServerRequestValidate(),
 		grpcsrv.GrpcServerPanicCapture(),
 	)

pkg/common/startrpc/tools.go

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,63 @@
+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,28 +3,65 @@ 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"
 )
 
-func getRocksCacheRedisClient(cli *rockscache.Client) redis.UniversalClient {
-	type Client struct {
-		rdb redis.UniversalClient
-		_   rockscache.Options
-		_   singleflight.Group
-	}
-	return (*Client)(unsafe.Pointer(cli)).rdb
+// 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 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) {
+func newRocksCacheClient(rdb redis.UniversalClient) *rocksCacheClient {
+	if rdb == nil {
+		return &rocksCacheClient{}
+	}
+	rc := &rocksCacheClient{
+		rdb:    rdb,
+		client: rockscache.NewClient(rdb, *GetRocksCacheOptions()),
+	}
+	return rc
+}
+
+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) {
 	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 {
@@ -35,13 +72,13 @@ func batchGetCache2[K comparable, V any](ctx context.Context, rcClient *rockscac
 		keyId[key] = id
 		findKeys = append(findKeys, key)
 	}
-	slotKeys, err := groupKeysBySlot(ctx, getRocksCacheRedisClient(rcClient), findKeys)
+	slotKeys, err := groupKeysBySlot(ctx, rcClient.GetRedis(), findKeys)
 	if err != nil {
 		return nil, err
 	}
 	result := make([]*V, 0, len(findKeys))
 	for _, keys := range slotKeys {
-		indexCache, err := rcClient.FetchBatch2(ctx, keys, expire, func(idx []int) (map[int]string, error) {
+		indexCache, err := rcClient.GetClient().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,23 +1,11 @@
-// 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"
@@ -25,7 +13,6 @@ import (
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/redis/go-redis/v9"
-	"time"
 )
 
 const (
@@ -41,10 +28,10 @@ type BatchDeleterRedis struct {
 }
 
 // NewBatchDeleterRedis creates a new BatchDeleterRedis instance.
-func NewBatchDeleterRedis(redisClient redis.UniversalClient, options *rockscache.Options, redisPubTopics []string) *BatchDeleterRedis {
+func NewBatchDeleterRedis(rcClient *rocksCacheClient, redisPubTopics []string) *BatchDeleterRedis {
 	return &BatchDeleterRedis{
-		redisClient:    redisClient,
-		rocksClient:    rockscache.NewClient(redisClient, *options),
+		redisClient:    rcClient.GetRedis(),
+		rocksClient:    rcClient.GetClient(),
 		redisPubTopics: redisPubTopics,
 	}
 }
@@ -107,21 +94,29 @@ func (c *BatchDeleterRedis) AddKeys(keys ...string) {
 	c.keys = append(c.keys, keys...)
 }
 
-// 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
+type disableBatchDeleter struct{}
 
-	return &opts
+func (x disableBatchDeleter) ChainExecDel(ctx context.Context) error {
+	return nil
 }
 
-func getCache[T any](ctx context.Context, rcClient *rockscache.Client, key string, expire time.Duration, fn func(ctx context.Context) (T, error)) (T, error) {
+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)
+	}
 	var t T
 	var write bool
-	v, err := rcClient.Fetch2(ctx, key, expire, func() (s string, err error) {
+	v, err := rcClient.GetClient().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)
@@ -152,31 +147,3 @@ func getCache[T any](ctx context.Context, rcClient *rockscache.Client, key strin
 
 	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,29 +1,14 @@
-// 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"
-	"github.com/dtm-labs/rockscache"
+	"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/database"
-	"github.com/openimsdk/tools/log"
 	"github.com/redis/go-redis/v9"
-	"time"
 )
 
 const (
@@ -33,18 +18,16 @@ const (
 type BlackCacheRedis struct {
 	cache.BatchDeleter
 	expireTime time.Duration
-	rcClient   *rockscache.Client
+	rcClient   *rocksCacheClient
 	blackDB    database.Black
 }
 
-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())
+func NewBlackCacheRedis(rdb redis.UniversalClient, localCache *config.LocalCache, blackDB database.Black) cache.BlackCache {
+	rc := newRocksCacheClient(rdb)
 	return &BlackCacheRedis{
-		BatchDeleter: batchHandler,
+		BatchDeleter: rc.GetBatchDeleter(localCache.Friend.Topic),
 		expireTime:   blackExpireTime,
-		rcClient:     rockscache.NewClient(rdb, *options),
+		rcClient:     rc,
 		blackDB:      blackDB,
 	}
 }

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

@@ -1,47 +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"
-	"github.com/dtm-labs/rockscache"
+	"math/big"
+	"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/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, 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())
+func NewConversationRedis(rdb redis.UniversalClient, localCache *config.LocalCache, db database.Conversation) cache.ConversationCache {
+	rc := newRocksCacheClient(rdb)
 	return &ConversationRedisCache{
-		BatchDeleter:   batchHandler,
-		rcClient:       rockscache.NewClient(rdb, *opts),
+		BatchDeleter:   rc.GetBatchDeleter(localCache.Conversation.Topic),
+		rcClient:       rc,
 		conversationDB: db,
 		expireTime:     conversationExpireTime,
 	}
@@ -49,7 +32,7 @@ func NewConversationRedis(rdb redis.UniversalClient, localCache *config.LocalCac
 
 type ConversationRedisCache struct {
 	cache.BatchDeleter
-	rcClient       *rockscache.Client
+	rcClient       *rocksCacheClient
 	conversationDB database.Conversation
 	expireTime     time.Duration
 }

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

@@ -1,15 +0,0 @@
-// 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,30 +1,14 @@
-// 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"
 )
@@ -38,21 +22,18 @@ type FriendCacheRedis struct {
 	cache.BatchDeleter
 	friendDB   database.Friend
 	expireTime time.Duration
-	rcClient   *rockscache.Client
+	rcClient   *rocksCacheClient
 	syncCount  int
 }
 
 // NewFriendCacheRedis creates a new instance of FriendCacheRedis.
-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())
+func NewFriendCacheRedis(rdb redis.UniversalClient, localCache *config.LocalCache, friendDB database.Friend) cache.FriendCache {
+	rc := newRocksCacheClient(rdb)
 	return &FriendCacheRedis{
-		BatchDeleter: batchHandler,
+		BatchDeleter: rc.GetBatchDeleter(localCache.Friend.Topic),
 		friendDB:     friendDB,
 		expireTime:   friendExpireTime,
-		rcClient:     rockscache.NewClient(rdb, *options),
+		rcClient:     rc,
 	}
 }
 

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

@@ -1,17 +1,3 @@
-// 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 (
@@ -19,7 +5,6 @@ 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"
@@ -36,34 +21,21 @@ 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       *rockscache.Client
+	rcClient       *rocksCacheClient
 	groupHash      cache.GroupHash
 }
 
-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())
-
+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)
 	return &GroupCacheRedis{
-		BatchDeleter:   batchHandler,
-		rcClient:       rockscache.NewClient(rdb, *opts),
+		BatchDeleter:   rc.GetBatchDeleter(localCache.Group.Topic),
+		rcClient:       rc,
 		expireTime:     groupExpireTime,
 		groupDB:        groupDB,
 		groupMemberDB:  groupMemberDB,

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

@@ -0,0 +1,59 @@
+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,7 +3,8 @@ package redis
 import (
 	"context"
 	"encoding/json"
-	"github.com/dtm-labs/rockscache"
+	"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"
@@ -11,7 +12,6 @@ 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,15 +19,13 @@ const msgCacheTimeout = time.Hour * 24
 
 func NewMsgCache(client redis.UniversalClient, db database.Msg) cache.MsgCache {
 	return &msgCache{
-		rdb:            client,
-		rcClient:       rockscache.NewClient(client, *GetRocksCacheOptions()),
+		rcClient:       newRocksCacheClient(client),
 		msgDocDatabase: db,
 	}
 }
 
 type msgCache struct {
-	rdb            redis.UniversalClient
-	rcClient       *rockscache.Client
+	rcClient       *rocksCacheClient
 	msgDocDatabase database.Msg
 }
 
@@ -36,11 +34,11 @@ func (c *msgCache) getSendMsgKey(id string) string {
 }
 
 func (c *msgCache) SetSendMsgStatus(ctx context.Context, id string, status int32) error {
-	return errs.Wrap(c.rdb.Set(ctx, c.getSendMsgKey(id), status, time.Hour*24).Err())
+	return errs.Wrap(c.rcClient.GetRedis().Set(ctx, c.getSendMsgKey(id), status, time.Hour*24).Err())
 }
 
 func (c *msgCache) GetSendMsgStatus(ctx context.Context, id string) (int32, error) {
-	result, err := c.rdb.Get(ctx, c.getSendMsgKey(id)).Int()
+	result, err := c.rcClient.GetRedis().Get(ctx, c.getSendMsgKey(id)).Int()
 	return int32(result), errs.Wrap(err)
 }
 
@@ -67,12 +65,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, getRocksCacheRedisClient(c.rcClient), keys)
+	slotKeys, err := groupKeysBySlot(ctx, c.rcClient.GetRedis(), keys)
 	if err != nil {
 		return err
 	}
 	for _, keys := range slotKeys {
-		if err := c.rcClient.TagAsDeletedBatch2(ctx, keys); err != nil {
+		if err := c.rcClient.GetClient().TagAsDeletedBatch2(ctx, keys); err != nil {
 			return err
 		}
 	}
@@ -88,7 +86,7 @@ func (c *msgCache) SetMessageBySeqs(ctx context.Context, conversationID string,
 		if err != nil {
 			return err
 		}
-		if err := c.rcClient.RawSet(ctx, cachekey.GetMsgCacheKey(conversationID, msg.Msg.Seq), string(data), msgCacheTimeout); err != nil {
+		if err := c.rcClient.GetClient().RawSet(ctx, cachekey.GetMsgCacheKey(conversationID, msg.Msg.Seq), string(data), msgCacheTimeout); err != nil {
 			return err
 		}
 	}

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

@@ -3,18 +3,24 @@ 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,