refactor: 3.7.0 code conventions. (#2148)

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* feat: add code lint

* feat: add code lint

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Script Refactoring

* feat: code format

* Script Refactoring

* Script Refactoring

* Script Refactoring

* Adjust MinIO configuration settings

* Adjust configuration settings

* Adjust configuration settings

* refactor: config change.

* refactor: webhooks update.

* Adjust configuration settings

* refactor: webhooks update.

* Adjust configuration settings

* Adjust configuration settings

* Adjust configuration settings

* feat: s3 api addr

* refactor: webhooks update.

* Adjust configuration settings

* Adjust configuration settings

* Adjust configuration settings

* Adjust configuration settings

* Adjust configuration settings

* Adjust configuration settings

* Adjust configuration settings

* refactor: webhooks update.

* refactor: kafka update.

* Simplify the Docker Compose configuration, remove unnecessary environment variables, and eliminate the gateway service.

* refactor: kafka update.

* refactor: kafka update.

* Simplify the Docker Compose configuration, remove unnecessary environment variables, and eliminate the gateway service.

* Simplify the Docker Compose configuration, remove unnecessary environment variables, and eliminate the gateway service.

* Windows can compile and run.

* Windows can compile and run.

* refactor: kafka update.

* feat: msg cache split

* refactor: webhooks update

* refactor: webhooks update

* refactor: friends update

* refactor: group update

* refactor: third update

* refactor: api update

* refactor: crontab update

* refactor: msggateway update

* mage

* mage

* refactor: all module update.

* check

* refactor: all module update.

* load config

* load config

* load config

* load config

* refactor: all module update.

* refactor: all module update.

* refactor: all module update.

* refactor: all module update.

* refactor: all module update.

* Optimize Docker configuration and script.

* refactor: all module update.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* refactor: all module update.

* Optimize Docker configuration and script.

* refactor: all module update.

* refactor: all module update.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* update tools

* update tools

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* update protocol

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* refactor: all module update.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* Optimize Docker configuration and script.

* refactor: api remove token auth by redis directly.

* Code Refactoring

* refactor: websocket auth change to call rpc of auth.

* refactor: kick online user and remove token change to call auth rpc.

* refactor: kick online user and remove token change to call auth rpc.

* refactor: remove msggateway redis.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor webhook

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor webhook

* refactor: cmd update.

* refactor: cmd update.

* fix: runtime: goroutine stack exceeds

* refactor: cmd update.

* refactor notification

* refactor notification

* refactor

* refactor: cmd update.

* refactor: cmd update.

* refactor

* refactor

* refactor

* protojson

* protojson

* protojson

* go mod

* wrapperspb

* refactor: cmd update.

* refactor: cmd update.

* refactor: cmd update.

* refactor: context update.

* refactor: websocket update info.

* refactor: websocket update info.

* refactor: websocket update info.

* refactor: websocket update info.

* refactor: api name change.

* refactor: debug info.

* refactor: debug info.

* refactor: debug info.

* fix: update file

* refactor

* refactor

* refactor: debug info.

* refactor: debug info.

* refactor: debug info.

* refactor: debug info.

* refactor: debug info.

* refactor: debug info.

* fix: callback update.

* fix: callback update.

* refactor

* fix: update message.

* fix: msg cache timeout.

* refactor

* refactor

* fix: push update.

* fix: push update.

* fix: push update.

* fix: push update.

* fix: push update.

* fix: push update.

* fix: push update.

* fix: websocket handle error remove when upgrade error.

---------

Co-authored-by: skiffer-git <44203734@qq.com>
Co-authored-by: Xinwei Xiong (cubxxw) <3293172751nss@gmail.com>
Co-authored-by: withchao <993506633@qq.com>

internal/push/callback.go

@@ -16,122 +16,135 @@ package push
 
 import (
 	"context"
+	"encoding/json"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 
-	"github.com/OpenIMSDK/protocol/constant"
-	"github.com/OpenIMSDK/protocol/sdkws"
-	"github.com/OpenIMSDK/tools/mcontext"
-	"github.com/OpenIMSDK/tools/utils"
 	"github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/http"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/utils/datautil"
 )
 
-func callbackOfflinePush(
-	ctx context.Context,
-	config *config.GlobalConfig,
-	userIDs []string,
-	msg *sdkws.MsgData,
-	offlinePushUserIDs *[]string,
-) error {
-	if !config.Callback.CallbackOfflinePush.Enable || msg.ContentType == constant.Typing {
-		return nil
-	}
-	req := &callbackstruct.CallbackBeforePushReq{
-		UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
-			UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
-				CallbackCommand: callbackstruct.CallbackOfflinePushCommand,
-				OperationID:     mcontext.GetOperationID(ctx),
-				PlatformID:      int(msg.SenderPlatformID),
-				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+func (c *ConsumerHandler) webhookBeforeOfflinePush(ctx context.Context, before *config.BeforeConfig, userIDs []string, msg *sdkws.MsgData, offlinePushUserIDs *[]string) error {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		if msg.ContentType == constant.Typing {
+			return nil
+		}
+		req := &callbackstruct.CallbackBeforePushReq{
+			UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
+				UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
+					CallbackCommand: callbackstruct.CallbackBeforeOfflinePushCommand,
+					OperationID:     mcontext.GetOperationID(ctx),
+					PlatformID:      int(msg.SenderPlatformID),
+					Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+				},
+				UserIDList: userIDs,
 			},
-			UserIDList: userIDs,
-		},
-		OfflinePushInfo: msg.OfflinePushInfo,
-		ClientMsgID:     msg.ClientMsgID,
-		SendID:          msg.SendID,
-		GroupID:         msg.GroupID,
-		ContentType:     msg.ContentType,
-		SessionType:     msg.SessionType,
-		AtUserIDs:       msg.AtUserIDList,
-		Content:         GetContent(msg),
-	}
+			OfflinePushInfo: msg.OfflinePushInfo,
+			ClientMsgID:     msg.ClientMsgID,
+			SendID:          msg.SendID,
+			GroupID:         msg.GroupID,
+			ContentType:     msg.ContentType,
+			SessionType:     msg.SessionType,
+			AtUserIDs:       msg.AtUserIDList,
+			Content:         GetContent(msg),
+		}
 
-	resp := &callbackstruct.CallbackBeforePushResp{}
-	if err := http.CallBackPostReturn(ctx, config.Callback.CallbackUrl, req, resp, config.Callback.CallbackOfflinePush); err != nil {
-		return err
-	}
+		resp := &callbackstruct.CallbackBeforePushResp{}
 
-	if len(resp.UserIDs) != 0 {
-		*offlinePushUserIDs = resp.UserIDs
-	}
-	if resp.OfflinePushInfo != nil {
-		msg.OfflinePushInfo = resp.OfflinePushInfo
-	}
-	return nil
+		if err := c.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
+			return err
+		}
+
+		if len(resp.UserIDs) != 0 {
+			*offlinePushUserIDs = resp.UserIDs
+		}
+		if resp.OfflinePushInfo != nil {
+			msg.OfflinePushInfo = resp.OfflinePushInfo
+		}
+		return nil
+	})
 }
 
-func callbackOnlinePush(ctx context.Context, config *config.GlobalConfig, userIDs []string, msg *sdkws.MsgData) error {
-	if !config.Callback.CallbackOnlinePush.Enable || utils.Contain(msg.SendID, userIDs...) || msg.ContentType == constant.Typing {
-		return nil
-	}
-	req := callbackstruct.CallbackBeforePushReq{
-		UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
-			UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
-				CallbackCommand: callbackstruct.CallbackOnlinePushCommand,
-				OperationID:     mcontext.GetOperationID(ctx),
-				PlatformID:      int(msg.SenderPlatformID),
-				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+func (c *ConsumerHandler) webhookBeforeOnlinePush(ctx context.Context, before *config.BeforeConfig, userIDs []string, msg *sdkws.MsgData) error {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		if datautil.Contain(msg.SendID, userIDs...) || msg.ContentType == constant.Typing {
+			return nil
+		}
+		req := callbackstruct.CallbackBeforePushReq{
+			UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
+				UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
+					CallbackCommand: callbackstruct.CallbackBeforeOnlinePushCommand,
+					OperationID:     mcontext.GetOperationID(ctx),
+					PlatformID:      int(msg.SenderPlatformID),
+					Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+				},
+				UserIDList: userIDs,
 			},
-			UserIDList: userIDs,
-		},
-		ClientMsgID: msg.ClientMsgID,
-		SendID:      msg.SendID,
-		GroupID:     msg.GroupID,
-		ContentType: msg.ContentType,
-		SessionType: msg.SessionType,
-		AtUserIDs:   msg.AtUserIDList,
-		Content:     GetContent(msg),
-	}
-	resp := &callbackstruct.CallbackBeforePushResp{}
-	if err := http.CallBackPostReturn(ctx, config.Callback.CallbackUrl, req, resp, config.Callback.CallbackOnlinePush); err != nil {
-		return err
-	}
-	return nil
+			ClientMsgID: msg.ClientMsgID,
+			SendID:      msg.SendID,
+			GroupID:     msg.GroupID,
+			ContentType: msg.ContentType,
+			SessionType: msg.SessionType,
+			AtUserIDs:   msg.AtUserIDList,
+			Content:     GetContent(msg),
+		}
+		resp := &callbackstruct.CallbackBeforePushResp{}
+		if err := c.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
+			return err
+		}
+		return nil
+	})
 }
 
-func callbackBeforeSuperGroupOnlinePush(
+func (c *ConsumerHandler) webhookBeforeGroupOnlinePush(
 	ctx context.Context,
-	config *config.GlobalConfig,
+	before *config.BeforeConfig,
 	groupID string,
 	msg *sdkws.MsgData,
 	pushToUserIDs *[]string,
 ) error {
-	if !config.Callback.CallbackBeforeSuperGroupOnlinePush.Enable || msg.ContentType == constant.Typing {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		if msg.ContentType == constant.Typing {
+			return nil
+		}
+		req := callbackstruct.CallbackBeforeSuperGroupOnlinePushReq{
+			UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
+				CallbackCommand: callbackstruct.CallbackBeforeGroupOnlinePushCommand,
+				OperationID:     mcontext.GetOperationID(ctx),
+				PlatformID:      int(msg.SenderPlatformID),
+				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
+			},
+			ClientMsgID: msg.ClientMsgID,
+			SendID:      msg.SendID,
+			GroupID:     groupID,
+			ContentType: msg.ContentType,
+			SessionType: msg.SessionType,
+			AtUserIDs:   msg.AtUserIDList,
+			Content:     GetContent(msg),
+			Seq:         msg.Seq,
+		}
+		resp := &callbackstruct.CallbackBeforeSuperGroupOnlinePushResp{}
+		if err := c.webhookClient.SyncPost(ctx, req.GetCallbackCommand(), req, resp, before); err != nil {
+			return err
+		}
+		if len(resp.UserIDs) != 0 {
+			*pushToUserIDs = resp.UserIDs
+		}
 		return nil
-	}
-	req := callbackstruct.CallbackBeforeSuperGroupOnlinePushReq{
-		UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
-			CallbackCommand: callbackstruct.CallbackSuperGroupOnlinePushCommand,
-			OperationID:     mcontext.GetOperationID(ctx),
-			PlatformID:      int(msg.SenderPlatformID),
-			Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
-		},
-		ClientMsgID: msg.ClientMsgID,
-		SendID:      msg.SendID,
-		GroupID:     groupID,
-		ContentType: msg.ContentType,
-		SessionType: msg.SessionType,
-		AtUserIDs:   msg.AtUserIDList,
-		Content:     GetContent(msg),
-		Seq:         msg.Seq,
-	}
-	resp := &callbackstruct.CallbackBeforeSuperGroupOnlinePushResp{}
-	if err := http.CallBackPostReturn(ctx, config.Callback.CallbackUrl, req, resp, config.Callback.CallbackBeforeSuperGroupOnlinePush); err != nil {
-		return err
-	}
-
-	if len(resp.UserIDs) != 0 {
-		*pushToUserIDs = resp.UserIDs
-	}
-	return nil
+	})
+}
+
+func GetContent(msg *sdkws.MsgData) string {
+	if msg.ContentType >= constant.NotificationBegin && msg.ContentType <= constant.NotificationEnd {
+		var notification sdkws.NotificationElem
+		if err := json.Unmarshal(msg.Content, &notification); err != nil {
+			return ""
+		}
+		return notification.Detail
+	} else {
+		return string(msg.Content)
+	}
 }

internal/push/consumer_init.go

@@ -1,41 +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 push
-
-import (
-	"context"
-
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-)
-
-type Consumer struct {
-	pushCh ConsumerHandler
-	// successCount is unused
-	// successCount uint64
-}
-
-func NewConsumer(config *config.GlobalConfig, pusher *Pusher) (*Consumer, error) {
-	c, err := NewConsumerHandler(config, pusher)
-	if err != nil {
-		return nil, err
-	}
-	return &Consumer{
-		pushCh: *c,
-	}, nil
-}
-
-func (c *Consumer) Start() {
-	go c.pushCh.pushConsumerGroup.RegisterHandleAndConsumer(context.Background(), &c.pushCh)
-}

internal/push/offlinepush/dummy/push.go

@@ -16,8 +16,7 @@ package dummy
 
 import (
 	"context"
-
-	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush"
+	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/options"
 )
 
 func NewClient() *Dummy {
@@ -27,6 +26,6 @@ func NewClient() *Dummy {
 type Dummy struct {
 }
 
-func (d *Dummy) Push(ctx context.Context, userIDs []string, title, content string, opts *offlinepush.Opts) error {
+func (d *Dummy) Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error {
 	return nil
 }

internal/push/offlinepush/fcm/push.go

@@ -16,14 +16,15 @@ package fcm
 
 import (
 	"context"
+	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/options"
 	"path/filepath"
 
 	firebase "firebase.google.com/go"
 	"firebase.google.com/go/messaging"
-	"github.com/OpenIMSDK/protocol/constant"
-	"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/db/cache"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/errs"
 	"github.com/redis/go-redis/v9"
 	"google.golang.org/api/option"
 )
@@ -34,29 +35,32 @@ var Terminal = []int{constant.IOSPlatformID, constant.AndroidPlatformID, constan
 
 type Fcm struct {
 	fcmMsgCli *messaging.Client
-	cache     cache.MsgModel
+	cache     cache.ThirdCache
 }
 
 // NewClient initializes a new FCM client using the Firebase Admin SDK.
 // It requires the FCM service account credentials file located within the project's configuration directory.
-func NewClient(globalConfig *config.GlobalConfig, cache cache.MsgModel) *Fcm {
-	projectRoot := config.GetProjectRoot()
-	credentialsFilePath := filepath.Join(projectRoot, "config", globalConfig.Push.Fcm.ServiceAccount)
+func NewClient(pushConf *config.Push, cache cache.ThirdCache) (*Fcm, error) {
+	projectRoot, err := config.GetProjectRoot()
+	if err != nil {
+		return nil, err
+	}
+	credentialsFilePath := filepath.Join(projectRoot, "config", pushConf.FCM.ServiceAccount)
 	opt := option.WithCredentialsFile(credentialsFilePath)
 	fcmApp, err := firebase.NewApp(context.Background(), nil, opt)
 	if err != nil {
-		return nil
+		return nil, errs.Wrap(err)
 	}
 	ctx := context.Background()
 	fcmMsgClient, err := fcmApp.Messaging(ctx)
 	if err != nil {
-		return nil
+		return nil, errs.Wrap(err)
 	}
 
-	return &Fcm{fcmMsgCli: fcmMsgClient, cache: cache}
+	return &Fcm{fcmMsgCli: fcmMsgClient, cache: cache}, nil
 }
 
-func (f *Fcm) Push(ctx context.Context, userIDs []string, title, content string, opts *offlinepush.Opts) error {
+func (f *Fcm) Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error {
 	// accounts->registrationToken
 	allTokens := make(map[string][]string, 0)
 	for _, account := range userIDs {

internal/push/offlinepush/getui/body.go

@@ -133,13 +133,13 @@ type Payload struct {
 	IsSignal bool `json:"isSignal"`
 }
 
-func newPushReq(config *config.GlobalConfig, title, content string) PushReq {
+func newPushReq(pushConf *config.Push, title, content string) PushReq {
 	pushReq := PushReq{PushMessage: &PushMessage{Notification: &Notification{
 		Title:       title,
 		Body:        content,
 		ClickType:   "startapp",
-		ChannelID:   config.Push.GeTui.ChannelID,
-		ChannelName: config.Push.GeTui.ChannelName,
+		ChannelID:   pushConf.GeTui.ChannelID,
+		ChannelName: pushConf.GeTui.ChannelName,
 	}}}
 	return pushReq
 }

internal/push/offlinepush/getui/push.go

@@ -18,25 +18,24 @@ import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
-	"errors"
+	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/options"
 	"strconv"
 	"sync"
 	"time"
 
-	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/log"
-	"github.com/OpenIMSDK/tools/mcontext"
-	"github.com/OpenIMSDK/tools/utils/splitter"
-	"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/db/cache"
-	http2 "github.com/openimsdk/open-im-server/v3/pkg/common/http"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/utils/httputil"
+	"github.com/openimsdk/tools/utils/splitter"
 	"github.com/redis/go-redis/v9"
 )
 
 var (
-	ErrTokenExpire = errors.New("token expire")
-	ErrUserIDEmpty = errors.New("userIDs is empty")
+	ErrTokenExpire = errs.New("token expire")
+	ErrUserIDEmpty = errs.New("userIDs is empty")
 )
 
 const (
@@ -45,32 +44,34 @@ const (
 	taskURL      = "/push/list/message"
 	batchPushURL = "/push/list/alias"
 
-	// codes.
+	// Codes.
 	tokenExpireCode = 10001
 	tokenExpireTime = 60 * 60 * 23
 	taskIDTTL       = 1000 * 60 * 60 * 24
 )
 
 type Client struct {
-	cache           cache.MsgModel
+	cache           cache.ThirdCache
 	tokenExpireTime int64
 	taskIDTTL       int64
-	config          *config.GlobalConfig
+	pushConf        *config.Push
+	httpClient      *httputil.HTTPClient
 }
 
-func NewClient(config *config.GlobalConfig, cache cache.MsgModel) *Client {
+func NewClient(pushConf *config.Push, cache cache.ThirdCache) *Client {
 	return &Client{cache: cache,
 		tokenExpireTime: tokenExpireTime,
 		taskIDTTL:       taskIDTTL,
-		config:          config,
+		pushConf:        pushConf,
+		httpClient:      httputil.NewHTTPClient(httputil.NewClientConfig()),
 	}
 }
 
-func (g *Client) Push(ctx context.Context, userIDs []string, title, content string, opts *offlinepush.Opts) error {
+func (g *Client) Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error {
 	token, err := g.cache.GetGetuiToken(ctx)
 	if err != nil {
 		if errs.Unwrap(err) == redis.Nil {
-			log.ZInfo(ctx, "getui token not exist in redis")
+			log.ZDebug(ctx, "getui token not exist in redis")
 			token, err = g.getTokenAndSave2Redis(ctx)
 			if err != nil {
 				return err
@@ -79,7 +80,7 @@ func (g *Client) Push(ctx context.Context, userIDs []string, title, content stri
 			return err
 		}
 	}
-	pushReq := newPushReq(g.config, title, content)
+	pushReq := newPushReq(g.pushConf, title, content)
 	pushReq.setPushChannel(title, content)
 	if len(userIDs) > 1 {
 		maxNum := 999
@@ -114,13 +115,13 @@ func (g *Client) Push(ctx context.Context, userIDs []string, title, content stri
 func (g *Client) Auth(ctx context.Context, timeStamp int64) (token string, expireTime int64, err error) {
 	h := sha256.New()
 	h.Write(
-		[]byte(g.config.Push.GeTui.AppKey + strconv.Itoa(int(timeStamp)) + g.config.Push.GeTui.MasterSecret),
+		[]byte(g.pushConf.GeTui.AppKey + strconv.Itoa(int(timeStamp)) + g.pushConf.GeTui.MasterSecret),
 	)
 	sign := hex.EncodeToString(h.Sum(nil))
 	reqAuth := AuthReq{
 		Sign:      sign,
 		Timestamp: strconv.Itoa(int(timeStamp)),
-		AppKey:    g.config.Push.GeTui.AppKey,
+		AppKey:    g.pushConf.GeTui.AppKey,
 	}
 	respAuth := AuthResp{}
 	err = g.request(ctx, authURL, reqAuth, "", &respAuth)
@@ -163,7 +164,7 @@ func (g *Client) request(ctx context.Context, url string, input any, token strin
 	header := map[string]string{"token": token}
 	resp := &Resp{}
 	resp.Data = output
-	return g.postReturn(ctx, g.config.Push.GeTui.PushUrl+url, header, input, resp, 3)
+	return g.postReturn(ctx, g.pushConf.GeTui.PushUrl+url, header, input, resp, 3)
 }
 
 func (g *Client) postReturn(
@@ -174,7 +175,7 @@ func (g *Client) postReturn(
 	output RespI,
 	timeout int,
 ) error {
-	err := http2.PostReturn(ctx, url, header, input, output, timeout)
+	err := g.httpClient.PostReturn(ctx, url, header, input, output, timeout)
 	if err != nil {
 		return err
 	}

internal/push/offlinepush/jpush/body/audience.go

@@ -32,8 +32,8 @@ func (a *Audience) set(key string, v []string) {
 		a.audience = make(map[string][]string)
 		a.Object = a.audience
 	}
-	//v, ok = this.audience[key]
-	//if ok {
+	// v, ok = this.audience[key]
+	// if ok {
 	//	return
 	//}
 	a.audience[key] = v

internal/push/offlinepush/jpush/body/notification.go

@@ -56,8 +56,8 @@ func (n *Notification) SetExtras(extras Extras) {
 	n.Android.Extras = extras
 }
 
-func (n *Notification) SetAndroidIntent(config *config.GlobalConfig) {
-	n.Android.Intent.URL = config.Push.Jpns.PushIntent
+func (n *Notification) SetAndroidIntent(pushConf *config.Push) {
+	n.Android.Intent.URL = pushConf.JPNS.PushIntent
 }
 
 func (n *Notification) IOSEnableMutableContent() {

internal/push/offlinepush/jpush/body/platform.go

@@ -15,9 +15,9 @@
 package body
 
 import (
-	"errors"
+	"github.com/openimsdk/tools/errs"
 
-	"github.com/OpenIMSDK/protocol/constant"
+	"github.com/openimsdk/protocol/constant"
 )
 
 const (
@@ -39,7 +39,7 @@ func (p *Platform) Set(os string) error {
 	} else {
 		switch p.Os.(type) {
 		case string:
-			return errors.New("platform is all")
+			return errs.New("platform is all")
 		default:
 		}
 	}
@@ -61,7 +61,7 @@ func (p *Platform) Set(os string) error {
 		p.osArry = append(p.osArry, os)
 		p.Os = p.osArry
 	default:
-		return errors.New("unknow platform")
+		return errs.New("unknow platform")
 	}
 
 	return nil
@@ -74,7 +74,7 @@ func (p *Platform) SetPlatform(platform string) error {
 	case constant.IOSPlatformStr:
 		return p.SetIOS()
 	default:
-		return errors.New("platform err")
+		return errs.New("platform err")
 	}
 }
 

internal/push/offlinepush/jpush/push.go

@@ -18,19 +18,22 @@ import (
 	"context"
 	"encoding/base64"
 	"fmt"
+	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/options"
 
-	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush"
 	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/jpush/body"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	http2 "github.com/openimsdk/open-im-server/v3/pkg/common/http"
+	"github.com/openimsdk/tools/utils/httputil"
 )
 
 type JPush struct {
-	config *config.GlobalConfig
+	pushConf   *config.Push
+	httpClient *httputil.HTTPClient
 }
 
-func NewClient(config *config.GlobalConfig) *JPush {
-	return &JPush{config: config}
+func NewClient(pushConf *config.Push) *JPush {
+	return &JPush{pushConf: pushConf,
+		httpClient: httputil.NewHTTPClient(httputil.NewClientConfig()),
+	}
 }
 
 func (j *JPush) Auth(apiKey, secretKey string, timeStamp int64) (token string, err error) {
@@ -48,7 +51,7 @@ func (j *JPush) getAuthorization(appKey string, masterSecret string) string {
 	return Authorization
 }
 
-func (j *JPush) Push(ctx context.Context, userIDs []string, title, content string, opts *offlinepush.Opts) error {
+func (j *JPush) Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error {
 	var pf body.Platform
 	pf.SetAll()
 	var au body.Audience
@@ -61,12 +64,12 @@ func (j *JPush) Push(ctx context.Context, userIDs []string, title, content strin
 	no.IOSEnableMutableContent()
 	no.SetExtras(extras)
 	no.SetAlert(title)
-	no.SetAndroidIntent(j.config)
+	no.SetAndroidIntent(j.pushConf)
 
 	var msg body.Message
 	msg.SetMsgContent(content)
 	var opt body.Options
-	opt.SetApnsProduction(j.config.IOSPush.Production)
+	opt.SetApnsProduction(j.pushConf.IOSPush.Production)
 	var pushObj body.PushObj
 	pushObj.SetPlatform(&pf)
 	pushObj.SetAudience(&au)
@@ -78,11 +81,11 @@ func (j *JPush) Push(ctx context.Context, userIDs []string, title, content strin
 }
 
 func (j *JPush) request(ctx context.Context, po body.PushObj, resp any, timeout int) error {
-	return http2.PostReturn(
+	return j.httpClient.PostReturn(
 		ctx,
-		j.config.Push.Jpns.PushUrl,
+		j.pushConf.JPNS.PushURL,
 		map[string]string{
-			"Authorization": j.getAuthorization(j.config.Push.Jpns.AppKey, j.config.Push.Jpns.MasterSecret),
+			"Authorization": j.getAuthorization(j.pushConf.JPNS.AppKey, j.pushConf.JPNS.MasterSecret),
 		},
 		po,
 		resp,

internal/push/offlinepush/offlinepush_interface.go

@@ -1,37 +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 offlinepush
-
-import (
-	"context"
-)
-
-// OfflinePusher Offline Pusher.
-type OfflinePusher interface {
-	Push(ctx context.Context, userIDs []string, title, content string, opts *Opts) error
-}
-
-// Opts opts.
-type Opts struct {
-	Signal        *Signal
-	IOSPushSound  string
-	IOSBadgeCount bool
-	Ex            string
-}
-
-// Signal message id.
-type Signal struct {
-	ClientMsgID string
-}

internal/push/offlinepush/offlinepusher.go

@@ -0,0 +1,52 @@
+// 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 offlinepush
+
+import (
+	"context"
+	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/dummy"
+	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/fcm"
+	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/getui"
+	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/jpush"
+	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/options"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
+)
+
+const (
+	geTUI    = "getui"
+	firebase = "fcm"
+	jPush    = "jpush"
+)
+
+// OfflinePusher Offline Pusher.
+type OfflinePusher interface {
+	Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error
+}
+
+func NewOfflinePusher(pushConf *config.Push, cache cache.ThirdCache) (OfflinePusher, error) {
+	var offlinePusher OfflinePusher
+	switch pushConf.Enable {
+	case geTUI:
+		offlinePusher = getui.NewClient(pushConf, cache)
+	case firebase:
+		return fcm.NewClient(pushConf, cache)
+	case jPush:
+		offlinePusher = jpush.NewClient(pushConf)
+	default:
+		offlinePusher = dummy.NewClient()
+	}
+	return offlinePusher, nil
+}

internal/push/offlinepush/options/options.go

@@ -0,0 +1,14 @@
+package options
+
+// Opts opts.
+type Opts struct {
+	Signal        *Signal
+	IOSPushSound  string
+	IOSBadgeCount bool
+	Ex            string
+}
+
+// Signal message id.
+type Signal struct {
+	ClientMsgID string
+}

internal/push/onlinepusher.go

@@ -0,0 +1,204 @@
+package push
+
+import (
+	"context"
+	"github.com/openimsdk/protocol/msggateway"
+	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/discovery"
+	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/utils/datautil"
+	"golang.org/x/sync/errgroup"
+	"google.golang.org/grpc"
+	"sync"
+)
+
+const (
+	KUBERNETES = "k8s"
+	ZOOKEEPER  = "zookeeper"
+)
+
+type OnlinePusher interface {
+	GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
+		pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error)
+	GetOnlinePushFailedUserIDs(ctx context.Context, msg *sdkws.MsgData, wsResults []*msggateway.SingleMsgToUserResults,
+		pushToUserIDs *[]string) []string
+}
+
+type emptyOnlinePUsher struct{}
+
+func newEmptyOnlinePUsher() *emptyOnlinePUsher {
+	return &emptyOnlinePUsher{}
+}
+
+func (emptyOnlinePUsher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
+	pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
+	log.ZWarn(ctx, "emptyOnlinePUsher GetConnsAndOnlinePush", nil)
+	return nil, nil
+}
+func (u emptyOnlinePUsher) GetOnlinePushFailedUserIDs(ctx context.Context, msg *sdkws.MsgData,
+	wsResults []*msggateway.SingleMsgToUserResults, pushToUserIDs *[]string) []string {
+	log.ZWarn(ctx, "emptyOnlinePUsher GetOnlinePushFailedUserIDs", nil)
+	return nil
+}
+
+func NewOnlinePusher(disCov discovery.SvcDiscoveryRegistry, config *Config) OnlinePusher {
+	switch config.Share.Env {
+	case KUBERNETES:
+		return NewK8sStaticConsistentHash(disCov, config)
+	case ZOOKEEPER:
+		return NewDefaultAllNode(disCov, config)
+	default:
+		return newEmptyOnlinePUsher()
+	}
+}
+
+type DefaultAllNode struct {
+	disCov discovery.SvcDiscoveryRegistry
+	config *Config
+}
+
+func NewDefaultAllNode(disCov discovery.SvcDiscoveryRegistry, config *Config) *DefaultAllNode {
+	return &DefaultAllNode{disCov: disCov, config: config}
+}
+
+func (d *DefaultAllNode) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
+	pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
+	conns, err := d.disCov.GetConns(ctx, d.config.Share.RpcRegisterName.MessageGateway)
+	log.ZDebug(ctx, "get gateway conn", "conn length", len(conns))
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		mu         sync.Mutex
+		wg         = errgroup.Group{}
+		input      = &msggateway.OnlineBatchPushOneMsgReq{MsgData: msg, PushToUserIDs: pushToUserIDs}
+		maxWorkers = d.config.RpcConfig.MaxConcurrentWorkers
+	)
+
+	if maxWorkers < 3 {
+		maxWorkers = 3
+	}
+
+	wg.SetLimit(maxWorkers)
+
+	// Online push message
+	for _, conn := range conns {
+		conn := conn // loop var safe
+		wg.Go(func() error {
+			msgClient := msggateway.NewMsgGatewayClient(conn)
+			reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(ctx, input)
+			if err != nil {
+				return nil
+			}
+
+			log.ZDebug(ctx, "push result", "reply", reply)
+			if reply != nil && reply.SinglePushResult != nil {
+				mu.Lock()
+				wsResults = append(wsResults, reply.SinglePushResult...)
+				mu.Unlock()
+			}
+
+			return nil
+		})
+	}
+
+	_ = wg.Wait()
+
+	// always return nil
+	return wsResults, nil
+}
+
+func (d *DefaultAllNode) GetOnlinePushFailedUserIDs(_ context.Context, msg *sdkws.MsgData,
+	wsResults []*msggateway.SingleMsgToUserResults, pushToUserIDs *[]string) []string {
+
+	onlineSuccessUserIDs := []string{msg.SendID}
+	for _, v := range wsResults {
+		//message sender do not need offline push
+		if msg.SendID == v.UserID {
+			continue
+		}
+		// mobile online push success
+		if v.OnlinePush {
+			onlineSuccessUserIDs = append(onlineSuccessUserIDs, v.UserID)
+		}
+
+	}
+
+	return datautil.SliceSub(*pushToUserIDs, onlineSuccessUserIDs)
+}
+
+type K8sStaticConsistentHash struct {
+	disCov discovery.SvcDiscoveryRegistry
+	config *Config
+}
+
+func NewK8sStaticConsistentHash(disCov discovery.SvcDiscoveryRegistry, config *Config) *K8sStaticConsistentHash {
+	return &K8sStaticConsistentHash{disCov: disCov, config: config}
+}
+
+func (k *K8sStaticConsistentHash) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
+	pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
+
+	var usersHost = make(map[string][]string)
+	for _, v := range pushToUserIDs {
+		tHost, err := k.disCov.GetUserIdHashGatewayHost(ctx, v)
+		if err != nil {
+			log.ZError(ctx, "get msg gateway hash error", err)
+			return nil, err
+		}
+		tUsers, tbl := usersHost[tHost]
+		if tbl {
+			tUsers = append(tUsers, v)
+			usersHost[tHost] = tUsers
+		} else {
+			usersHost[tHost] = []string{v}
+		}
+	}
+	log.ZDebug(ctx, "genUsers send hosts struct:", "usersHost", usersHost)
+	var usersConns = make(map[*grpc.ClientConn][]string)
+	for host, userIds := range usersHost {
+		tconn, _ := k.disCov.GetConn(ctx, host)
+		usersConns[tconn] = userIds
+	}
+	var (
+		mu         sync.Mutex
+		wg         = errgroup.Group{}
+		maxWorkers = k.config.RpcConfig.MaxConcurrentWorkers
+	)
+	if maxWorkers < 3 {
+		maxWorkers = 3
+	}
+	wg.SetLimit(maxWorkers)
+	for conn, userIds := range usersConns {
+		tcon := conn
+		tuserIds := userIds
+		wg.Go(func() error {
+			input := &msggateway.OnlineBatchPushOneMsgReq{MsgData: msg, PushToUserIDs: tuserIds}
+			msgClient := msggateway.NewMsgGatewayClient(tcon)
+			reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(ctx, input)
+			if err != nil {
+				return nil
+			}
+			log.ZDebug(ctx, "push result", "reply", reply)
+			if reply != nil && reply.SinglePushResult != nil {
+				mu.Lock()
+				wsResults = append(wsResults, reply.SinglePushResult...)
+				mu.Unlock()
+			}
+			return nil
+		})
+	}
+	_ = wg.Wait()
+	return wsResults, nil
+}
+func (k *K8sStaticConsistentHash) GetOnlinePushFailedUserIDs(_ context.Context, _ *sdkws.MsgData,
+	wsResults []*msggateway.SingleMsgToUserResults, _ *[]string) []string {
+	var needOfflinePushUserIDs []string
+	for _, v := range wsResults {
+		if !v.OnlinePush {
+			needOfflinePushUserIDs = append(needOfflinePushUserIDs, v.UserID)
+		}
+	}
+	return needOfflinePushUserIDs
+}

internal/push/push.go

@@ -0,0 +1,71 @@
+package push
+
+import (
+	"context"
+	"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/db/cache"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/db/controller"
+	pbpush "github.com/openimsdk/protocol/push"
+	"github.com/openimsdk/tools/db/redisutil"
+	"github.com/openimsdk/tools/discovery"
+	"google.golang.org/grpc"
+)
+
+type pushServer struct {
+	database      controller.PushDatabase
+	disCov        discovery.SvcDiscoveryRegistry
+	offlinePusher offlinepush.OfflinePusher
+	pushCh        *ConsumerHandler
+}
+
+type Config struct {
+	RpcConfig          config.Push
+	RedisConfig        config.Redis
+	MongodbConfig      config.Mongo
+	KafkaConfig        config.Kafka
+	ZookeeperConfig    config.ZooKeeper
+	NotificationConfig config.Notification
+	Share              config.Share
+	WebhooksConfig     config.Webhooks
+	LocalCacheConfig   config.LocalCache
+}
+
+func (p pushServer) PushMsg(ctx context.Context, req *pbpush.PushMsgReq) (*pbpush.PushMsgResp, error) {
+	//todo reserved Interface
+	return nil, nil
+}
+
+func (p pushServer) DelUserPushToken(ctx context.Context,
+	req *pbpush.DelUserPushTokenReq) (resp *pbpush.DelUserPushTokenResp, err error) {
+	if err = p.database.DelFcmToken(ctx, req.UserID, int(req.PlatformID)); err != nil {
+		return nil, err
+	}
+	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())
+	if err != nil {
+		return err
+	}
+	cacheModel := cache.NewThirdCache(rdb)
+	offlinePusher, err := offlinepush.NewOfflinePusher(&config.RpcConfig, cacheModel)
+	if err != nil {
+		return err
+	}
+	database := controller.NewPushDatabase(cacheModel)
+
+	consumer, err := NewConsumerHandler(config, offlinePusher, rdb, client)
+	if err != nil {
+		return err
+	}
+	pbpush.RegisterPushMsgServiceServer(server, &pushServer{
+		database:      database,
+		disCov:        client,
+		offlinePusher: offlinePusher,
+		pushCh:        consumer,
+	})
+	go consumer.pushConsumerGroup.RegisterHandleAndConsumer(ctx, consumer)
+	return nil
+}

internal/push/push_handler.go

@@ -16,49 +16,64 @@ package push
 
 import (
 	"context"
+	"encoding/json"
+	"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/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/rpcclient"
+	"github.com/openimsdk/open-im-server/v3/pkg/util/conversationutil"
+	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/discovery"
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/utils/jsonutil"
+	"github.com/redis/go-redis/v9"
 
 	"github.com/IBM/sarama"
-	"github.com/OpenIMSDK/protocol/constant"
-	pbchat "github.com/OpenIMSDK/protocol/msg"
-	pbpush "github.com/OpenIMSDK/protocol/push"
-	"github.com/OpenIMSDK/tools/log"
-	"github.com/OpenIMSDK/tools/utils"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	kfk "github.com/openimsdk/open-im-server/v3/pkg/common/kafka"
+	"github.com/openimsdk/protocol/constant"
+	pbchat "github.com/openimsdk/protocol/msg"
+	pbpush "github.com/openimsdk/protocol/push"
+	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/mq/kafka"
+	"github.com/openimsdk/tools/utils/datautil"
+	"github.com/openimsdk/tools/utils/timeutil"
 	"google.golang.org/protobuf/proto"
 )
 
 type ConsumerHandler struct {
-	pushConsumerGroup *kfk.MConsumerGroup
-	pusher            *Pusher
+	pushConsumerGroup      *kafka.MConsumerGroup
+	offlinePusher          offlinepush.OfflinePusher
+	onlinePusher           OnlinePusher
+	groupLocalCache        *rpccache.GroupLocalCache
+	conversationLocalCache *rpccache.ConversationLocalCache
+	msgRpcClient           rpcclient.MessageRpcClient
+	conversationRpcClient  rpcclient.ConversationRpcClient
+	groupRpcClient         rpcclient.GroupRpcClient
+	webhookClient          *webhook.Client
+	config                 *Config
 }
 
-func NewConsumerHandler(config *config.GlobalConfig, pusher *Pusher) (*ConsumerHandler, error) {
+func NewConsumerHandler(config *Config, offlinePusher offlinepush.OfflinePusher, rdb redis.UniversalClient,
+	client discovery.SvcDiscoveryRegistry) (*ConsumerHandler, error) {
 	var consumerHandler ConsumerHandler
-	consumerHandler.pusher = pusher
 	var err error
-	var tlsConfig *kfk.TLSConfig
-	if config.Kafka.TLS != nil {
-		tlsConfig = &kfk.TLSConfig{
-			CACrt:              config.Kafka.TLS.CACrt,
-			ClientCrt:          config.Kafka.TLS.ClientCrt,
-			ClientKey:          config.Kafka.TLS.ClientKey,
-			ClientKeyPwd:       config.Kafka.TLS.ClientKeyPwd,
-			InsecureSkipVerify: false,
-		}
-	}
-	consumerHandler.pushConsumerGroup, err = kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{
-		KafkaVersion:   sarama.V2_0_0_0,
-		OffsetsInitial: sarama.OffsetNewest,
-		IsReturnErr:    false,
-		UserName:       config.Kafka.Username,
-		Password:       config.Kafka.Password,
-	}, []string{config.Kafka.MsgToPush.Topic}, config.Kafka.Addr,
-		config.Kafka.ConsumerGroupID.MsgToPush,
-		tlsConfig)
+	consumerHandler.pushConsumerGroup, err = kafka.NewMConsumerGroup(config.KafkaConfig.Build(), config.KafkaConfig.ToPushGroupID,
+		[]string{config.KafkaConfig.ToPushTopic})
 	if err != nil {
 		return nil, err
 	}
+	consumerHandler.offlinePusher = offlinePusher
+	consumerHandler.onlinePusher = NewOnlinePusher(client, config)
+	consumerHandler.groupRpcClient = rpcclient.NewGroupRpcClient(client, config.Share.RpcRegisterName.Group)
+	consumerHandler.groupLocalCache = rpccache.NewGroupLocalCache(consumerHandler.groupRpcClient, &config.LocalCacheConfig, rdb)
+	consumerHandler.msgRpcClient = rpcclient.NewMessageRpcClient(client, config.Share.RpcRegisterName.Msg)
+	consumerHandler.conversationRpcClient = rpcclient.NewConversationRpcClient(client, config.Share.RpcRegisterName.Conversation)
+	consumerHandler.conversationLocalCache = rpccache.NewConversationLocalCache(consumerHandler.conversationRpcClient,
+		&config.LocalCacheConfig, rdb)
+	consumerHandler.webhookClient = webhook.NewWebhookClient(config.WebhooksConfig.URL)
+	consumerHandler.config = config
 	return &consumerHandler, nil
 }
 
@@ -73,38 +88,35 @@ func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 		ConversationID: msgFromMQ.ConversationID,
 	}
 	sec := msgFromMQ.MsgData.SendTime / 1000
-	nowSec := utils.GetCurrentTimestampBySecond()
+	nowSec := timeutil.GetCurrentTimestampBySecond()
 	log.ZDebug(ctx, "push msg", "msg", pbData.String(), "sec", sec, "nowSec", nowSec)
 	if nowSec-sec > 10 {
 		return
 	}
 	var err error
 	switch msgFromMQ.MsgData.SessionType {
-	case constant.SuperGroupChatType:
-		err = c.pusher.Push2SuperGroup(ctx, pbData.MsgData.GroupID, pbData.MsgData)
+	case constant.ReadGroupChatType:
+		err = c.Push2SuperGroup(ctx, pbData.MsgData.GroupID, pbData.MsgData)
 	default:
 		var pushUserIDList []string
-		isSenderSync := utils.GetSwitchFromOptions(pbData.MsgData.Options, constant.IsSenderSync)
+		isSenderSync := datautil.GetSwitchFromOptions(pbData.MsgData.Options, constant.IsSenderSync)
 		if !isSenderSync || pbData.MsgData.SendID == pbData.MsgData.RecvID {
 			pushUserIDList = append(pushUserIDList, pbData.MsgData.RecvID)
 		} else {
 			pushUserIDList = append(pushUserIDList, pbData.MsgData.RecvID, pbData.MsgData.SendID)
 		}
-		err = c.pusher.Push2User(ctx, pushUserIDList, pbData.MsgData)
+		err = c.Push2User(ctx, pushUserIDList, pbData.MsgData)
 	}
 	if err != nil {
-		if err == errNoOfflinePusher {
-			log.ZWarn(ctx, "offline push failed", err, "msg", pbData.String())
-		} else {
-			log.ZError(ctx, "push failed", err, "msg", pbData.String())
-		}
+		log.ZError(ctx, "push failed", err, "msg", pbData.String())
 	}
 }
-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 {
+
+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 {
 	for msg := range claim.Messages() {
 		ctx := c.pushConsumerGroup.GetContextFromMsg(msg)
 		c.handleMs2PsChat(ctx, msg.Value)
@@ -112,3 +124,243 @@ func (c *ConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
 	}
 	return nil
 }
+
+// Push2User Suitable for two types of conversations, one is SingleChatType and the other is NotificationChatType.
+func (c *ConsumerHandler) Push2User(ctx context.Context, userIDs []string, msg *sdkws.MsgData) error {
+	log.ZDebug(ctx, "Get msg from msg_transfer And push msg", "userIDs", userIDs, "msg", msg.String())
+	if err := c.webhookBeforeOnlinePush(ctx, &c.config.WebhooksConfig.BeforeOnlinePush, userIDs, msg); err != nil {
+		return err
+	}
+	wsResults, err := c.onlinePusher.GetConnsAndOnlinePush(ctx, msg, userIDs)
+	if err != nil {
+		return err
+	}
+
+	log.ZDebug(ctx, "single and notification push result", "result", wsResults, "msg", msg, "push_to_userID", userIDs)
+
+	if !c.shouldPushOffline(ctx, msg) {
+		return nil
+	}
+
+	for _, v := range wsResults {
+		//message sender do not need offline push
+		if msg.SendID == v.UserID {
+			continue
+		}
+		//receiver online push success
+		if v.OnlinePush {
+			return nil
+		}
+	}
+	offlinePUshUserID := []string{msg.RecvID}
+
+	//receiver offline push
+	if err = c.webhookBeforeOfflinePush(ctx, &c.config.WebhooksConfig.BeforeOfflinePush,
+		offlinePUshUserID, msg, nil); err != nil {
+		return err
+	}
+
+	err = c.offlinePushMsg(ctx, msg, offlinePUshUserID)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *ConsumerHandler) shouldPushOffline(_ context.Context, msg *sdkws.MsgData) bool {
+	isOfflinePush := datautil.GetSwitchFromOptions(msg.Options, constant.IsOfflinePush)
+	if !isOfflinePush {
+		return false
+	}
+	if msg.ContentType == constant.SignalingNotification {
+		return false
+	}
+	return true
+}
+
+func (c *ConsumerHandler) Push2SuperGroup(ctx context.Context, groupID string, msg *sdkws.MsgData) (err error) {
+	log.ZDebug(ctx, "Get super group msg from msg_transfer and push msg", "msg", msg.String(), "groupID", groupID)
+	var pushToUserIDs []string
+	if err = c.webhookBeforeGroupOnlinePush(ctx, &c.config.WebhooksConfig.BeforeGroupOnlinePush, groupID, msg,
+		&pushToUserIDs); err != nil {
+		return err
+	}
+
+	err = c.groupMessagesHandler(ctx, groupID, &pushToUserIDs, msg)
+	if err != nil {
+		return err
+	}
+
+	wsResults, err := c.onlinePusher.GetConnsAndOnlinePush(ctx, msg, pushToUserIDs)
+	if err != nil {
+		return err
+	}
+
+	log.ZDebug(ctx, "group push result", "result", wsResults, "msg", msg)
+
+	if !c.shouldPushOffline(ctx, msg) {
+		return nil
+	}
+	needOfflinePushUserIDs := c.onlinePusher.GetOnlinePushFailedUserIDs(ctx, msg, wsResults, &pushToUserIDs)
+
+	//filter some user, like don not disturb or don't need offline push etc.
+	needOfflinePushUserIDs, err = c.filterGroupMessageOfflinePush(ctx, groupID, msg, needOfflinePushUserIDs)
+	if err != nil {
+		return err
+	}
+	// Use offline push messaging
+	if len(needOfflinePushUserIDs) > 0 {
+		var offlinePushUserIDs []string
+		err = c.webhookBeforeOfflinePush(ctx, &c.config.WebhooksConfig.BeforeOfflinePush, needOfflinePushUserIDs, msg, &offlinePushUserIDs)
+		if err != nil {
+			return err
+		}
+
+		if len(offlinePushUserIDs) > 0 {
+			needOfflinePushUserIDs = offlinePushUserIDs
+		}
+
+		err = c.offlinePushMsg(ctx, msg, needOfflinePushUserIDs)
+		if err != nil {
+			log.ZError(ctx, "offlinePushMsg failed", err, "groupID", groupID, "msg", msg)
+			return err
+		}
+
+	}
+
+	return nil
+}
+func (c *ConsumerHandler) groupMessagesHandler(ctx context.Context, groupID string, pushToUserIDs *[]string, msg *sdkws.MsgData) (err error) {
+	if len(*pushToUserIDs) == 0 {
+		*pushToUserIDs, err = c.groupLocalCache.GetGroupMemberIDs(ctx, groupID)
+		if err != nil {
+			return err
+		}
+		switch msg.ContentType {
+		case constant.MemberQuitNotification:
+			var tips sdkws.MemberQuitTips
+			if unmarshalNotificationElem(msg.Content, &tips) != nil {
+				return err
+			}
+			if err = c.DeleteMemberAndSetConversationSeq(ctx, groupID, []string{tips.QuitUser.UserID}); err != nil {
+				log.ZError(ctx, "MemberQuitNotification DeleteMemberAndSetConversationSeq", err, "groupID", groupID, "userID", tips.QuitUser.UserID)
+			}
+			*pushToUserIDs = append(*pushToUserIDs, tips.QuitUser.UserID)
+		case constant.MemberKickedNotification:
+			var tips sdkws.MemberKickedTips
+			if unmarshalNotificationElem(msg.Content, &tips) != nil {
+				return err
+			}
+			kickedUsers := datautil.Slice(tips.KickedUserList, func(e *sdkws.GroupMemberFullInfo) string { return e.UserID })
+			if err = c.DeleteMemberAndSetConversationSeq(ctx, groupID, kickedUsers); err != nil {
+				log.ZError(ctx, "MemberKickedNotification DeleteMemberAndSetConversationSeq", err, "groupID", groupID, "userIDs", kickedUsers)
+			}
+
+			*pushToUserIDs = append(*pushToUserIDs, kickedUsers...)
+		case constant.GroupDismissedNotification:
+			if msgprocessor.IsNotification(msgprocessor.GetConversationIDByMsg(msg)) { // 消息先到,通知后到
+				var tips sdkws.GroupDismissedTips
+				if unmarshalNotificationElem(msg.Content, &tips) != nil {
+					return err
+				}
+				log.ZInfo(ctx, "GroupDismissedNotificationInfo****", "groupID", groupID, "num", len(*pushToUserIDs), "list", pushToUserIDs)
+				if len(c.config.Share.IMAdminUserID) > 0 {
+					ctx = mcontext.WithOpUserIDContext(ctx, c.config.Share.IMAdminUserID[0])
+				}
+				defer func(groupID string) {
+					if err = c.groupRpcClient.DismissGroup(ctx, groupID); err != nil {
+						log.ZError(ctx, "DismissGroup Notification clear members", err, "groupID", groupID)
+					}
+				}(groupID)
+			}
+		}
+	}
+	return err
+}
+
+func (c *ConsumerHandler) offlinePushMsg(ctx context.Context, msg *sdkws.MsgData, offlinePushUserIDs []string) error {
+	title, content, opts, err := c.getOfflinePushInfos(msg)
+	if err != nil {
+		return err
+	}
+	err = c.offlinePusher.Push(ctx, offlinePushUserIDs, title, content, opts)
+	if err != nil {
+		prommetrics.MsgOfflinePushFailedCounter.Inc()
+		return err
+	}
+	return nil
+}
+
+func (c *ConsumerHandler) filterGroupMessageOfflinePush(ctx context.Context, groupID string, msg *sdkws.MsgData,
+	offlinePushUserIDs []string) (userIDs []string, err error) {
+
+	//todo local cache Obtain the difference set through local comparison.
+	needOfflinePushUserIDs, err := c.conversationRpcClient.GetConversationOfflinePushUserIDs(
+		ctx, conversationutil.GenGroupConversationID(groupID), offlinePushUserIDs)
+	if err != nil {
+		return nil, err
+	}
+	return needOfflinePushUserIDs, nil
+}
+
+func (c *ConsumerHandler) getOfflinePushInfos(msg *sdkws.MsgData) (title, content string, opts *options.Opts, err error) {
+	type AtTextElem struct {
+		Text       string   `json:"text,omitempty"`
+		AtUserList []string `json:"atUserList,omitempty"`
+		IsAtSelf   bool     `json:"isAtSelf"`
+	}
+
+	opts = &options.Opts{Signal: &options.Signal{}}
+	if msg.OfflinePushInfo != nil {
+		opts.IOSBadgeCount = msg.OfflinePushInfo.IOSBadgeCount
+		opts.IOSPushSound = msg.OfflinePushInfo.IOSPushSound
+		opts.Ex = msg.OfflinePushInfo.Ex
+	}
+
+	if msg.OfflinePushInfo != nil {
+		title = msg.OfflinePushInfo.Title
+		content = msg.OfflinePushInfo.Desc
+	}
+	if title == "" {
+		switch msg.ContentType {
+		case constant.Text:
+			fallthrough
+		case constant.Picture:
+			fallthrough
+		case constant.Voice:
+			fallthrough
+		case constant.Video:
+			fallthrough
+		case constant.File:
+			title = constant.ContentType2PushContent[int64(msg.ContentType)]
+		case constant.AtText:
+			ac := AtTextElem{}
+			_ = jsonutil.JsonStringToStruct(string(msg.Content), &ac)
+		case constant.SignalingNotification:
+			title = constant.ContentType2PushContent[constant.SignalMsg]
+		default:
+			title = constant.ContentType2PushContent[constant.Common]
+		}
+	}
+	if content == "" {
+		content = title
+	}
+	return
+}
+func (c *ConsumerHandler) DeleteMemberAndSetConversationSeq(ctx context.Context, groupID string, userIDs []string) error {
+	conversationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, groupID)
+	maxSeq, err := c.msgRpcClient.GetConversationMaxSeq(ctx, conversationID)
+	if err != nil {
+		return err
+	}
+	return c.conversationRpcClient.SetConversationMaxSeq(ctx, userIDs, conversationID, maxSeq)
+}
+func unmarshalNotificationElem(bytes []byte, t any) error {
+	var notification sdkws.NotificationElem
+	if err := json.Unmarshal(bytes, &notification); err != nil {
+		return err
+	}
+
+	return json.Unmarshal([]byte(notification.Detail), t)
+}

internal/push/push_rpc_server.go

@@ -1,107 +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 push
-
-import (
-	"context"
-
-	"github.com/OpenIMSDK/protocol/constant"
-	pbpush "github.com/OpenIMSDK/protocol/push"
-	"github.com/OpenIMSDK/tools/discoveryregistry"
-	"github.com/OpenIMSDK/tools/log"
-	"github.com/OpenIMSDK/tools/utils"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/db/controller"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpccache"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
-	"google.golang.org/grpc"
-)
-
-type pushServer struct {
-	pusher *Pusher
-	config *config.GlobalConfig
-}
-
-func Start(config *config.GlobalConfig, client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
-	rdb, err := cache.NewRedis(config)
-	if err != nil {
-		return err
-	}
-	cacheModel := cache.NewMsgCacheModel(rdb, config)
-	offlinePusher := NewOfflinePusher(config, cacheModel)
-	database := controller.NewPushDatabase(cacheModel)
-	groupRpcClient := rpcclient.NewGroupRpcClient(client, config)
-	conversationRpcClient := rpcclient.NewConversationRpcClient(client, config)
-	msgRpcClient := rpcclient.NewMessageRpcClient(client, config)
-	pusher := NewPusher(
-		config,
-		client,
-		offlinePusher,
-		database,
-		rpccache.NewGroupLocalCache(groupRpcClient, rdb),
-		rpccache.NewConversationLocalCache(conversationRpcClient, rdb),
-		&conversationRpcClient,
-		&groupRpcClient,
-		&msgRpcClient,
-	)
-
-	pbpush.RegisterPushMsgServiceServer(server, &pushServer{
-		pusher: pusher,
-		config: config,
-	})
-
-	consumer, err := NewConsumer(config, pusher)
-	if err != nil {
-		return err
-	}
-
-	consumer.Start()
-
-	return nil
-}
-
-func (r *pushServer) PushMsg(ctx context.Context, pbData *pbpush.PushMsgReq) (resp *pbpush.PushMsgResp, err error) {
-	switch pbData.MsgData.SessionType {
-	case constant.SuperGroupChatType:
-		err = r.pusher.Push2SuperGroup(ctx, pbData.MsgData.GroupID, pbData.MsgData)
-	default:
-		var pushUserIDList []string
-		isSenderSync := utils.GetSwitchFromOptions(pbData.MsgData.Options, constant.IsSenderSync)
-		if !isSenderSync {
-			pushUserIDList = append(pushUserIDList, pbData.MsgData.RecvID)
-		} else {
-			pushUserIDList = append(pushUserIDList, pbData.MsgData.RecvID, pbData.MsgData.SendID)
-		}
-		err = r.pusher.Push2User(ctx, pushUserIDList, pbData.MsgData)
-	}
-	if err != nil {
-		if err != errNoOfflinePusher {
-			return nil, err
-		}
-		log.ZWarn(ctx, "offline push failed", err, "msg", pbData.String())
-	}
-	return &pbpush.PushMsgResp{}, nil
-}
-
-func (r *pushServer) DelUserPushToken(
-	ctx context.Context,
-	req *pbpush.DelUserPushTokenReq,
-) (resp *pbpush.DelUserPushTokenResp, err error) {
-	if err = r.pusher.database.DelFcmToken(ctx, req.UserID, int(req.PlatformID)); err != nil {
-		return nil, err
-	}
-	return &pbpush.DelUserPushTokenResp{}, nil
-}

internal/push/push_to_client.go

@@ -1,522 +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 push
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"sync"
-
-	"github.com/OpenIMSDK/protocol/constant"
-	"github.com/OpenIMSDK/protocol/conversation"
-	"github.com/OpenIMSDK/protocol/msggateway"
-	"github.com/OpenIMSDK/protocol/sdkws"
-	"github.com/OpenIMSDK/tools/discoveryregistry"
-	"github.com/OpenIMSDK/tools/log"
-	"github.com/OpenIMSDK/tools/mcontext"
-	"github.com/OpenIMSDK/tools/utils"
-	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush"
-	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/dummy"
-	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/fcm"
-	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/getui"
-	"github.com/openimsdk/open-im-server/v3/internal/push/offlinepush/jpush"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/db/controller"
-	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
-	"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/rpcclient"
-	"golang.org/x/sync/errgroup"
-	"google.golang.org/grpc"
-)
-
-type Pusher struct {
-	config                 *config.GlobalConfig
-	database               controller.PushDatabase
-	discov                 discoveryregistry.SvcDiscoveryRegistry
-	offlinePusher          offlinepush.OfflinePusher
-	groupLocalCache        *rpccache.GroupLocalCache
-	conversationLocalCache *rpccache.ConversationLocalCache
-	msgRpcClient           *rpcclient.MessageRpcClient
-	conversationRpcClient  *rpcclient.ConversationRpcClient
-	groupRpcClient         *rpcclient.GroupRpcClient
-}
-
-var errNoOfflinePusher = errors.New("no offlinePusher is configured")
-
-func NewPusher(config *config.GlobalConfig, discov discoveryregistry.SvcDiscoveryRegistry, offlinePusher offlinepush.OfflinePusher, database controller.PushDatabase,
-	groupLocalCache *rpccache.GroupLocalCache, conversationLocalCache *rpccache.ConversationLocalCache,
-	conversationRpcClient *rpcclient.ConversationRpcClient, groupRpcClient *rpcclient.GroupRpcClient, msgRpcClient *rpcclient.MessageRpcClient,
-) *Pusher {
-	return &Pusher{
-		config:                 config,
-		discov:                 discov,
-		database:               database,
-		offlinePusher:          offlinePusher,
-		groupLocalCache:        groupLocalCache,
-		conversationLocalCache: conversationLocalCache,
-		msgRpcClient:           msgRpcClient,
-		conversationRpcClient:  conversationRpcClient,
-		groupRpcClient:         groupRpcClient,
-	}
-}
-
-func NewOfflinePusher(config *config.GlobalConfig, cache cache.MsgModel) offlinepush.OfflinePusher {
-	var offlinePusher offlinepush.OfflinePusher
-	switch config.Push.Enable {
-	case "getui":
-		offlinePusher = getui.NewClient(config, cache)
-	case "fcm":
-		offlinePusher = fcm.NewClient(config, cache)
-	case "jpush":
-		offlinePusher = jpush.NewClient(config)
-	default:
-		offlinePusher = dummy.NewClient()
-	}
-	return offlinePusher
-}
-
-func (p *Pusher) DeleteMemberAndSetConversationSeq(ctx context.Context, groupID string, userIDs []string) error {
-	conevrsationID := msgprocessor.GetConversationIDBySessionType(constant.SuperGroupChatType, groupID)
-	maxSeq, err := p.msgRpcClient.GetConversationMaxSeq(ctx, conevrsationID)
-	if err != nil {
-		return err
-	}
-	return p.conversationRpcClient.SetConversationMaxSeq(ctx, userIDs, conevrsationID, maxSeq)
-}
-
-func (p *Pusher) Push2User(ctx context.Context, userIDs []string, msg *sdkws.MsgData) error {
-	log.ZDebug(ctx, "Get msg from msg_transfer And push msg", "userIDs", userIDs, "msg", msg.String())
-	if err := callbackOnlinePush(ctx, p.config, userIDs, msg); err != nil {
-		return err
-	}
-	// push
-	wsResults, err := p.GetConnsAndOnlinePush(ctx, msg, userIDs)
-	if err != nil {
-		return err
-	}
-
-	isOfflinePush := utils.GetSwitchFromOptions(msg.Options, constant.IsOfflinePush)
-	log.ZDebug(ctx, "push_result", "ws push result", wsResults, "sendData", msg, "isOfflinePush", isOfflinePush, "push_to_userID", userIDs)
-
-	if !isOfflinePush {
-		return nil
-	}
-
-	if len(wsResults) == 0 {
-		return nil
-	}
-	onlinePushSuccUserIDSet := utils.SliceSet(utils.Filter(wsResults, func(e *msggateway.SingleMsgToUserResults) (string, bool) {
-		return e.UserID, e.OnlinePush && e.UserID != ""
-	}))
-	offlinePushUserIDList := utils.Filter(wsResults, func(e *msggateway.SingleMsgToUserResults) (string, bool) {
-		_, exist := onlinePushSuccUserIDSet[e.UserID]
-		return e.UserID, !exist && e.UserID != "" && e.UserID != msg.SendID
-	})
-
-	if len(offlinePushUserIDList) > 0 {
-		if err = callbackOfflinePush(ctx, p.config, offlinePushUserIDList, msg, &[]string{}); err != nil {
-			return err
-		}
-		err = p.offlinePushMsg(ctx, msg.SendID, msg, offlinePushUserIDList)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (p *Pusher) UnmarshalNotificationElem(bytes []byte, t any) error {
-	var notification sdkws.NotificationElem
-	if err := json.Unmarshal(bytes, &notification); err != nil {
-		return err
-	}
-
-	return json.Unmarshal([]byte(notification.Detail), t)
-}
-
-/*
-k8s deployment,offline push group messages function.
-*/
-func (p *Pusher) k8sOfflinePush2SuperGroup(ctx context.Context, groupID string, msg *sdkws.MsgData, wsResults []*msggateway.SingleMsgToUserResults) error {
-
-	var needOfflinePushUserIDs []string
-	for _, v := range wsResults {
-		if !v.OnlinePush {
-			needOfflinePushUserIDs = append(needOfflinePushUserIDs, v.UserID)
-		}
-	}
-	if len(needOfflinePushUserIDs) > 0 {
-		var offlinePushUserIDs []string
-		err := callbackOfflinePush(ctx, p.config, needOfflinePushUserIDs, msg, &offlinePushUserIDs)
-		if err != nil {
-			return err
-		}
-
-		if len(offlinePushUserIDs) > 0 {
-			needOfflinePushUserIDs = offlinePushUserIDs
-		}
-		if msg.ContentType != constant.SignalingNotification {
-			resp, err := p.conversationRpcClient.Client.GetConversationOfflinePushUserIDs(
-				ctx,
-				&conversation.GetConversationOfflinePushUserIDsReq{ConversationID: utils.GenGroupConversationID(groupID), UserIDs: needOfflinePushUserIDs},
-			)
-			if err != nil {
-				return err
-			}
-			if len(resp.UserIDs) > 0 {
-				err = p.offlinePushMsg(ctx, groupID, msg, resp.UserIDs)
-				if err != nil {
-					log.ZError(ctx, "offlinePushMsg failed", err, "groupID", groupID, "msg", msg)
-					return err
-				}
-			}
-		}
-
-	}
-	return nil
-}
-func (p *Pusher) Push2SuperGroup(ctx context.Context, groupID string, msg *sdkws.MsgData) (err error) {
-	log.ZDebug(ctx, "Get super group msg from msg_transfer and push msg", "msg", msg.String(), "groupID", groupID)
-	var pushToUserIDs []string
-	if err = callbackBeforeSuperGroupOnlinePush(ctx, p.config, groupID, msg, &pushToUserIDs); err != nil {
-		return err
-	}
-
-	if len(pushToUserIDs) == 0 {
-		pushToUserIDs, err = p.groupLocalCache.GetGroupMemberIDs(ctx, groupID)
-		if err != nil {
-			return err
-		}
-
-		switch msg.ContentType {
-		case constant.MemberQuitNotification:
-			var tips sdkws.MemberQuitTips
-			if p.UnmarshalNotificationElem(msg.Content, &tips) != nil {
-				return err
-			}
-			defer func(groupID string, userIDs []string) {
-				if err = p.DeleteMemberAndSetConversationSeq(ctx, groupID, userIDs); err != nil {
-					log.ZError(ctx, "MemberQuitNotification DeleteMemberAndSetConversationSeq", err, "groupID", groupID, "userIDs", userIDs)
-				}
-			}(groupID, []string{tips.QuitUser.UserID})
-			pushToUserIDs = append(pushToUserIDs, tips.QuitUser.UserID)
-		case constant.MemberKickedNotification:
-			var tips sdkws.MemberKickedTips
-			if p.UnmarshalNotificationElem(msg.Content, &tips) != nil {
-				return err
-			}
-			kickedUsers := utils.Slice(tips.KickedUserList, func(e *sdkws.GroupMemberFullInfo) string { return e.UserID })
-			defer func(groupID string, userIDs []string) {
-				if err = p.DeleteMemberAndSetConversationSeq(ctx, groupID, userIDs); err != nil {
-					log.ZError(ctx, "MemberKickedNotification DeleteMemberAndSetConversationSeq", err, "groupID", groupID, "userIDs", userIDs)
-				}
-			}(groupID, kickedUsers)
-			pushToUserIDs = append(pushToUserIDs, kickedUsers...)
-		case constant.GroupDismissedNotification:
-			// Messages arrive first, notifications arrive later
-			if msgprocessor.IsNotification(msgprocessor.GetConversationIDByMsg(msg)) {
-				var tips sdkws.GroupDismissedTips
-				if p.UnmarshalNotificationElem(msg.Content, &tips) != nil {
-					return err
-				}
-				log.ZInfo(ctx, "GroupDismissedNotificationInfo****", "groupID", groupID, "num", len(pushToUserIDs), "list", pushToUserIDs)
-				if len(p.config.Manager.UserID) > 0 {
-					ctx = mcontext.WithOpUserIDContext(ctx, p.config.Manager.UserID[0])
-				}
-				if len(p.config.Manager.UserID) == 0 && len(p.config.IMAdmin.UserID) > 0 {
-					ctx = mcontext.WithOpUserIDContext(ctx, p.config.IMAdmin.UserID[0])
-				}
-				defer func(groupID string) {
-					if err = p.groupRpcClient.DismissGroup(ctx, groupID); err != nil {
-						log.ZError(ctx, "DismissGroup Notification clear members", err, "groupID", groupID)
-					}
-				}(groupID)
-			}
-		}
-	}
-
-	wsResults, err := p.GetConnsAndOnlinePush(ctx, msg, pushToUserIDs)
-	if err != nil {
-		return err
-	}
-
-	log.ZDebug(ctx, "get conn and online push success", "result", wsResults, "msg", msg)
-	isOfflinePush := utils.GetSwitchFromOptions(msg.Options, constant.IsOfflinePush)
-	if isOfflinePush && p.config.Envs.Discovery == "k8s" {
-		return p.k8sOfflinePush2SuperGroup(ctx, groupID, msg, wsResults)
-	}
-	if isOfflinePush && p.config.Envs.Discovery == "zookeeper" {
-		var (
-			onlineSuccessUserIDs      = []string{msg.SendID}
-			webAndPcBackgroundUserIDs []string
-		)
-
-		for _, v := range wsResults {
-			if v.OnlinePush && v.UserID != msg.SendID {
-				onlineSuccessUserIDs = append(onlineSuccessUserIDs, v.UserID)
-			}
-
-			if v.OnlinePush {
-				continue
-			}
-
-			if len(v.Resp) == 0 {
-				continue
-			}
-
-			for _, singleResult := range v.Resp {
-				if singleResult.ResultCode != -2 {
-					continue
-				}
-
-				isPC := constant.PlatformIDToName(int(singleResult.RecvPlatFormID)) == constant.TerminalPC
-				isWebID := singleResult.RecvPlatFormID == constant.WebPlatformID
-
-				if isPC || isWebID {
-					webAndPcBackgroundUserIDs = append(webAndPcBackgroundUserIDs, v.UserID)
-				}
-			}
-		}
-
-		needOfflinePushUserIDs := utils.DifferenceString(onlineSuccessUserIDs, pushToUserIDs)
-
-		// Use offline push messaging
-		if len(needOfflinePushUserIDs) > 0 {
-			var offlinePushUserIDs []string
-			err = callbackOfflinePush(ctx, p.config, needOfflinePushUserIDs, msg, &offlinePushUserIDs)
-			if err != nil {
-				return err
-			}
-
-			if len(offlinePushUserIDs) > 0 {
-				needOfflinePushUserIDs = offlinePushUserIDs
-			}
-			if msg.ContentType != constant.SignalingNotification {
-				resp, err := p.conversationRpcClient.Client.GetConversationOfflinePushUserIDs(
-					ctx,
-					&conversation.GetConversationOfflinePushUserIDsReq{ConversationID: utils.GenGroupConversationID(groupID), UserIDs: needOfflinePushUserIDs},
-				)
-				if err != nil {
-					return err
-				}
-				if len(resp.UserIDs) > 0 {
-					err = p.offlinePushMsg(ctx, groupID, msg, resp.UserIDs)
-					if err != nil {
-						log.ZError(ctx, "offlinePushMsg failed", err, "groupID", groupID, "msg", msg)
-						return err
-					}
-					if _, err := p.GetConnsAndOnlinePush(ctx, msg, utils.IntersectString(resp.UserIDs, webAndPcBackgroundUserIDs)); err != nil {
-						log.ZError(ctx, "offlinePushMsg failed", err, "groupID", groupID, "msg", msg, "userIDs", utils.IntersectString(needOfflinePushUserIDs, webAndPcBackgroundUserIDs))
-						return err
-					}
-				}
-			}
-
-		}
-	}
-	return nil
-}
-
-func (p *Pusher) k8sOnlinePush(ctx context.Context, msg *sdkws.MsgData, pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
-	var usersHost = make(map[string][]string)
-	for _, v := range pushToUserIDs {
-		tHost, err := p.discov.GetUserIdHashGatewayHost(ctx, v)
-		if err != nil {
-			log.ZError(ctx, "get msggateway hash error", err)
-			return nil, err
-		}
-		tUsers, tbl := usersHost[tHost]
-		if tbl {
-			tUsers = append(tUsers, v)
-			usersHost[tHost] = tUsers
-		} else {
-			usersHost[tHost] = []string{v}
-		}
-	}
-	log.ZDebug(ctx, "genUsers send hosts struct:", "usersHost", usersHost)
-	var usersConns = make(map[*grpc.ClientConn][]string)
-	for host, userIds := range usersHost {
-		tconn, _ := p.discov.GetConn(ctx, host)
-		usersConns[tconn] = userIds
-	}
-	var (
-		mu         sync.Mutex
-		wg         = errgroup.Group{}
-		maxWorkers = p.config.Push.MaxConcurrentWorkers
-	)
-	if maxWorkers < 3 {
-		maxWorkers = 3
-	}
-	wg.SetLimit(maxWorkers)
-	for conn, userIds := range usersConns {
-		tcon := conn
-		tuserIds := userIds
-		wg.Go(func() error {
-			input := &msggateway.OnlineBatchPushOneMsgReq{MsgData: msg, PushToUserIDs: tuserIds}
-			msgClient := msggateway.NewMsgGatewayClient(tcon)
-			reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(ctx, input)
-			if err != nil {
-				return nil
-			}
-			log.ZDebug(ctx, "push result", "reply", reply)
-			if reply != nil && reply.SinglePushResult != nil {
-				mu.Lock()
-				wsResults = append(wsResults, reply.SinglePushResult...)
-				mu.Unlock()
-			}
-			return nil
-		})
-	}
-	_ = wg.Wait()
-	return wsResults, nil
-}
-func (p *Pusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData, pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
-	if p.config.Envs.Discovery == "k8s" {
-		return p.k8sOnlinePush(ctx, msg, pushToUserIDs)
-	}
-	conns, err := p.discov.GetConns(ctx, p.config.RpcRegisterName.OpenImMessageGatewayName)
-	log.ZDebug(ctx, "get gateway conn", "conn length", len(conns))
-	if err != nil {
-		return nil, err
-	}
-
-	var (
-		mu         sync.Mutex
-		wg         = errgroup.Group{}
-		input      = &msggateway.OnlineBatchPushOneMsgReq{MsgData: msg, PushToUserIDs: pushToUserIDs}
-		maxWorkers = p.config.Push.MaxConcurrentWorkers
-	)
-
-	if maxWorkers < 3 {
-		maxWorkers = 3
-	}
-
-	wg.SetLimit(maxWorkers)
-
-	// Online push message
-	for _, conn := range conns {
-		conn := conn // loop var safe
-		wg.Go(func() error {
-			msgClient := msggateway.NewMsgGatewayClient(conn)
-			reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(ctx, input)
-			if err != nil {
-				return nil
-			}
-
-			log.ZDebug(ctx, "push result", "reply", reply)
-			if reply != nil && reply.SinglePushResult != nil {
-				mu.Lock()
-				wsResults = append(wsResults, reply.SinglePushResult...)
-				mu.Unlock()
-			}
-
-			return nil
-		})
-	}
-
-	_ = wg.Wait()
-
-	// always return nil
-	return wsResults, nil
-}
-
-func (p *Pusher) offlinePushMsg(ctx context.Context, conversationID string, msg *sdkws.MsgData, offlinePushUserIDs []string) error {
-	title, content, opts, err := p.getOfflinePushInfos(conversationID, msg)
-	if err != nil {
-		return err
-	}
-	err = p.offlinePusher.Push(ctx, offlinePushUserIDs, title, content, opts)
-	if err != nil {
-		prommetrics.MsgOfflinePushFailedCounter.Inc()
-		return err
-	}
-	return nil
-}
-
-func (p *Pusher) GetOfflinePushOpts(msg *sdkws.MsgData) (opts *offlinepush.Opts, err error) {
-	opts = &offlinepush.Opts{Signal: &offlinepush.Signal{}}
-	// if msg.ContentType > constant.SignalingNotificationBegin && msg.ContentType < constant.SignalingNotificationEnd {
-	// 	req := &sdkws.SignalReq{}
-	// 	if err := proto.Unmarshal(msg.Content, req); err != nil {
-	// 		return nil, utils.Wrap(err, "")
-	// 	}
-	// 	switch req.Payload.(type) {
-	// 	case *sdkws.SignalReq_Invite, *sdkws.SignalReq_InviteInGroup:
-	// 		opts.Signal = &offlinepush.Signal{ClientMsgID: msg.ClientMsgID}
-	// 	}
-	// }
-	if msg.OfflinePushInfo != nil {
-		opts.IOSBadgeCount = msg.OfflinePushInfo.IOSBadgeCount
-		opts.IOSPushSound = msg.OfflinePushInfo.IOSPushSound
-		opts.Ex = msg.OfflinePushInfo.Ex
-	}
-	return opts, nil
-}
-
-func (p *Pusher) getOfflinePushInfos(conversationID string, msg *sdkws.MsgData) (title, content string, opts *offlinepush.Opts, err error) {
-	if p.offlinePusher == nil {
-		err = errNoOfflinePusher
-		return
-	}
-
-	type atContent struct {
-		Text       string   `json:"text"`
-		AtUserList []string `json:"atUserList"`
-		IsAtSelf   bool     `json:"isAtSelf"`
-	}
-
-	opts, err = p.GetOfflinePushOpts(msg)
-	if err != nil {
-		return
-	}
-
-	if msg.OfflinePushInfo != nil {
-		title = msg.OfflinePushInfo.Title
-		content = msg.OfflinePushInfo.Desc
-	}
-	if title == "" {
-		switch msg.ContentType {
-		case constant.Text:
-			fallthrough
-		case constant.Picture:
-			fallthrough
-		case constant.Voice:
-			fallthrough
-		case constant.Video:
-			fallthrough
-		case constant.File:
-			title = constant.ContentType2PushContent[int64(msg.ContentType)]
-		case constant.AtText:
-			ac := atContent{}
-			_ = utils.JsonStringToStruct(string(msg.Content), &ac)
-			if utils.IsContain(conversationID, ac.AtUserList) {
-				title = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
-			} else {
-				title = constant.ContentType2PushContent[constant.GroupMsg]
-			}
-		case constant.SignalingNotification:
-			title = constant.ContentType2PushContent[constant.SignalMsg]
-		default:
-			title = constant.ContentType2PushContent[constant.Common]
-		}
-	}
-	if content == "" {
-		content = title
-	}
-	return
-}

internal/push/tools.go

@@ -1,31 +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 push
-
-import (
-	"github.com/OpenIMSDK/protocol/constant"
-	"github.com/OpenIMSDK/protocol/sdkws"
-	"google.golang.org/protobuf/proto"
-)
-
-func GetContent(msg *sdkws.MsgData) string {
-	if msg.ContentType >= constant.NotificationBegin && msg.ContentType <= constant.NotificationEnd {
-		var tips sdkws.TipsComm
-		_ = proto.Unmarshal(msg.Content, &tips)
-		content := tips.JsonDetail
-		return content
-	}
-	return string(msg.Content)
-}