blackteay/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2025-04-06 04:15:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

rename

Browse Source
This commit is contained in:
skiffer-git 2022-07-20 20:59:52 +08:00
parent 5936492f76
commit 7c15a53a62
16 changed files with 528 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/open_im_api/main.go
View File

@ -143,12 +143,8 @@ func main() {
chatGroup.POST("/clear_msg", apiChat.ClearMsg)
chatGroup.POST("/manage_send_msg", manage.ManagementSendMsg)
chatGroup.POST("/batch_send_msg", manage.ManagementBatchSendMsg)
chatGroup.POST("/set_msg_min_seq", apiChat.SetMsgMinSeq)
}
//Manager
//managementGroup := r.Group("/manager")
//{
// managementGroup.POST("/delete_user", manage.DeleteUser) //1
//}
//Conversation
conversationGroup := r.Group("/conversation")
{ //1

4
cmd/rpc/open_im_msg/main.go
View File

@ -1,7 +1,7 @@
package main
import (
rpcChat "Open_IM/internal/rpc/msg"
"Open_IM/internal/rpc/msg"
"Open_IM/pkg/common/config"
"flag"
"fmt"
@ -12,6 +12,6 @@ func main() {
rpcPort := flag.Int("port", defaultPorts[0], "rpc listening port")
flag.Parse()
fmt.Println("start msg rpc server, port: ", *rpcPort)
rpcServer := rpcChat.NewRpcChatServer(*rpcPort)
rpcServer := msg.NewRpcChatServer(*rpcPort)
rpcServer.Run()
}

56
internal/api/chat/del_msg.go
View File

@ -7,7 +7,7 @@ import (
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
rpc "Open_IM/pkg/proto/chat"
rpc "Open_IM/pkg/proto/msg"
pbCommon "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"context"
@ -54,7 +54,7 @@ func DelMsg(c *gin.Context) {
return
}
grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, req.OperationID)
grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
if grpcConn == nil {
errMsg := req.OperationID + " getcdv3.GetConn == nil"
log.NewError(req.OperationID, errMsg)
@ -127,7 +127,7 @@ func DelSuperGroupMsg(c *gin.Context) {
c.JSON(http.StatusOK, resp)
}
log.Info(req.OperationID, "", "api DelSuperGroupMsg call start..., [data: %s]", pbData.String())
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, req.OperationID)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetConn == nil"
log.NewError(req.OperationID, errMsg)
@ -186,7 +186,7 @@ func ClearMsg(c *gin.Context) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, req.OperationID)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + " getcdv3.GetConn == nil"
log.NewError(req.OperationID, errMsg)
@ -206,3 +206,51 @@ func ClearMsg(c *gin.Context) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
c.JSON(http.StatusOK, resp)
}
// @Summary 设置用户最小seq
// @Description 设置用户最小seq，以及用户相关读扩散群组最小seq
// @Tags 消息相关
// @ID SetMsgMinSeq
// @Accept json
// @Param token header string true "im token"
func SetMsgMinSeq(c *gin.Context) {
params := api.SetMsgMinSeqReq{}
if err := c.BindJSON(&params); err != nil {
log.NewError("0", "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
//
req := &rpc.SetMsgMinSeqReq{}
utils.CopyStructFields(req, &params)
var ok bool
var errInfo string
ok, req.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + " getcdv3.GetConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewChatClient(etcdConn)
RpcResp, err := client.SetMsgMinSeq(context.Background(), req)
if err != nil {
log.NewError(req.OperationID, " SetMsgMinSeq failed ", err.Error(), req.String(), RpcResp.ErrMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": RpcResp.ErrMsg})
return
}
resp := api.CleanUpMsgResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
c.JSON(http.StatusOK, resp)
}

5
internal/api/user/user.go
View File

@ -324,8 +324,9 @@ func SetGlobalRecvMessageOpt(c *gin.Context) {
func GetSelfUserInfo(c *gin.Context) {
params := api.GetSelfUserInfoReq{}
if err := c.BindJSON(&params); err != nil {
log.NewError("0", "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
errMsg := "BindJSON failed " + err.Error()
log.NewError("0", "BindJSON failed ", errMsg)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
req := &rpc.GetUserInfoReq{}

6
internal/msg_gateway/gate/batch_push.go
View File

@ -5,7 +5,7 @@ import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbChat "Open_IM/pkg/proto/chat"
pbChat "Open_IM/pkg/proto/msg"
sdk_ws "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"context"
@ -89,14 +89,14 @@ func (r *RPCServer) GetSingleUserMsg(operationID string, currentMsgSeq uint32, u
rpcReq.SeqList = seqList
rpcReq.UserID = userID
rpcReq.OperationID = operationID
grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, rpcReq.OperationID)
grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, rpcReq.OperationID)
if grpcConn == nil {
errMsg := "getcdv3.GetConn == nil"
log.NewError(rpcReq.OperationID, errMsg)
return nil
}
msgClient := pbChat.NewChatClient(grpcConn)
msgClient := pbChat.NewMsgClient(grpcConn)
reply, err := msgClient.PullMessageBySeqList(context.Background(), &rpcReq)
if err != nil {
log.Error(operationID, "PullMessageBySeqList failed ", err.Error(), rpcReq.String())

18
internal/msg_gateway/gate/logic.go
View File

@ -6,7 +6,7 @@ import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbChat "Open_IM/pkg/proto/chat"
pbChat "Open_IM/pkg/proto/msg"
pbRtc "Open_IM/pkg/proto/rtc"
sdk_ws "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
@ -69,7 +69,7 @@ func (ws *WServer) getSeqReq(conn *UserConn, m *Req) {
rpcReq.UserID = m.SendID
rpcReq.OperationID = m.OperationID
log.Debug(m.OperationID, "Ws call success to getMaxAndMinSeq", m.SendID, m.ReqIdentifier, m.MsgIncr, data.(sdk_ws.GetMaxAndMinSeqReq).GroupIDList)
grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, rpcReq.OperationID)
grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, rpcReq.OperationID)
if grpcConn == nil {
errMsg := rpcReq.OperationID + "getcdv3.GetConn == nil"
nReply.ErrCode = 500
@ -78,7 +78,7 @@ func (ws *WServer) getSeqReq(conn *UserConn, m *Req) {
ws.getSeqResp(conn, m, nReply)
return
}
msgClient := pbChat.NewChatClient(grpcConn)
msgClient := pbChat.NewMsgClient(grpcConn)
rpcReply, err := msgClient.GetMaxAndMinSeq(context.Background(), &rpcReq)
if err != nil {
nReply.ErrCode = 500
@ -124,7 +124,7 @@ func (ws *WServer) pullMsgBySeqListReq(conn *UserConn, m *Req) {
rpcReq.OperationID = m.OperationID
rpcReq.GroupSeqList = data.(sdk_ws.PullMessageBySeqListReq).GroupSeqList
log.NewInfo(m.OperationID, "Ws call success to pullMsgBySeqListReq middle", m.SendID, m.ReqIdentifier, m.MsgIncr, data.(sdk_ws.PullMessageBySeqListReq).SeqList)
grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, m.OperationID)
grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, m.OperationID)
if grpcConn == nil {
errMsg := rpcReq.OperationID + "getcdv3.GetConn == nil"
nReply.ErrCode = 500
@ -133,7 +133,7 @@ func (ws *WServer) pullMsgBySeqListReq(conn *UserConn, m *Req) {
ws.pullMsgBySeqListResp(conn, m, nReply)
return
}
msgClient := pbChat.NewChatClient(grpcConn)
msgClient := pbChat.NewMsgClient(grpcConn)
reply, err := msgClient.PullMessageBySeqList(context.Background(), &rpcReq)
if err != nil {
log.NewError(rpcReq.OperationID, "pullMsgBySeqListReq err", err.Error())
@ -183,7 +183,7 @@ func (ws *WServer) sendMsgReq(conn *UserConn, m *Req) {
MsgData: &data,
}
log.NewInfo(m.OperationID, "Ws call success to sendMsgReq middle", m.ReqIdentifier, m.SendID, m.MsgIncr, data.String())
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, m.OperationID)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, m.OperationID)
if etcdConn == nil {
errMsg := m.OperationID + "getcdv3.GetConn == nil"
nReply.ErrCode = 500
@ -192,7 +192,7 @@ func (ws *WServer) sendMsgReq(conn *UserConn, m *Req) {
ws.sendMsgResp(conn, m, nReply)
return
}
client := pbChat.NewChatClient(etcdConn)
client := pbChat.NewMsgClient(etcdConn)
reply, err := client.SendMsg(context.Background(), &pbData)
if err != nil {
log.NewError(pbData.OperationID, "UserSendMsg err", err.Error())
@ -264,14 +264,14 @@ func (ws *WServer) sendSignalMsgReq(conn *UserConn, m *Req) {
}
log.NewInfo(m.OperationID, utils.GetSelfFuncName(), "pbData: ", pbData)
log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq middle", m.ReqIdentifier, m.SendID, m.MsgIncr, msgData)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, m.OperationID)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, m.OperationID)
if etcdConn == nil {
errMsg := m.OperationID + "getcdv3.GetConn == nil"
log.NewError(m.OperationID, errMsg)
ws.sendSignalMsgResp(conn, 200, errMsg, m, &signalResp)
return
}
client := pbChat.NewChatClient(etcdConn)
client := pbChat.NewMsgClient(etcdConn)
reply, err := client.SendMsg(context.Background(), &pbData)
if err != nil {
log.NewError(pbData.OperationID, utils.GetSelfFuncName(), "rpc sendMsg err", err.Error())

4
internal/msg_gateway/gate/rpc_server.go → internal/msg_gateway/gate/relay_rpc_server.go
View File

@ -32,7 +32,7 @@ type RPCServer struct {
func (r *RPCServer) onInit(rpcPort int) {
r.rpcPort = rpcPort
r.rpcRegisterName = config.Config.RpcRegisterName.OpenImOnlineMessageRelayName
r.rpcRegisterName = config.Config.RpcRegisterName.OpenImRelayName
r.etcdSchema = config.Config.Etcd.EtcdSchema
r.etcdAddr = config.Config.Etcd.EtcdAddr
r.platformList = genPlatformArray()
@ -53,7 +53,7 @@ func (r *RPCServer) run() {
defer listener.Close()
srv := grpc.NewServer()
defer srv.GracefulStop()
pbRelay.RegisterOnlineMessageRelayServiceServer(srv, r)
pbRelay.RegisterRelayServer(srv, r)
rpcRegisterIP := config.Config.RpcRegisterIP
if config.Config.RpcRegisterIP == "" {

29
internal/rpc/msg/chat.go
View File

@ -5,7 +5,7 @@ import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/proto/chat"
pbChat "Open_IM/pkg/proto/msg"
"Open_IM/pkg/utils"
"context"
)
@ -15,7 +15,7 @@ func (rpc *rpcChat) ClearMsg(_ context.Context, req *pbChat.ClearMsgReq) (*pbCha
if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.UserID) {
errMsg := "No permission" + req.OpUserID + req.UserID
log.Error(req.OperationID, errMsg)
return &pbChat.ClearMsgResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
return &pbChat.ClearMsgResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
}
log.Debug(req.OperationID, "CleanUpOneUserAllMsgFromRedis args", req.UserID)
err := db.DB.CleanUpOneUserAllMsgFromRedis(req.UserID, req.OperationID)
@ -36,3 +36,28 @@ func (rpc *rpcChat) ClearMsg(_ context.Context, req *pbChat.ClearMsgReq) (*pbCha
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
return &resp, nil
}
func (rpc *rpcChat) SetMsgMinSeq(_ context.Context, req *pbChat.SetMsgMinSeqReq) (*pbChat.SetMsgMinSeqResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc req: ", req.String())
if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.UserID) {
errMsg := "No permission" + req.OpUserID + req.UserID
log.Error(req.OperationID, errMsg)
return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
}
if req.GroupID == "" {
err := db.DB.SetUserMinSeq(req.UserID, req.MinSeq)
if err != nil {
errMsg := "SetUserMinSeq failed " + err.Error() + req.OperationID + req.UserID + utils.Uint32ToString(req.MinSeq)
log.Error(req.OperationID, errMsg)
return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
}
return &pbChat.SetMsgMinSeqResp{}, nil
}
err := db.DB.SetGroupUserMinSeq(req.GroupID, req.UserID, req.MinSeq)
if err != nil {
errMsg := "SetGroupUserMinSeq failed " + err.Error() + req.OperationID + req.GroupID + req.UserID + utils.Uint32ToString(req.MinSeq)
log.Error(req.OperationID, errMsg)
return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
}
return &pbChat.SetMsgMinSeqResp{}, nil
}

6
internal/rpc/msg/rpcChat.go
View File

@ -7,7 +7,7 @@ import (
"Open_IM/pkg/common/kafka"
"Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbChat "Open_IM/pkg/proto/chat"
"Open_IM/pkg/proto/msg"
"Open_IM/pkg/utils"
"google.golang.org/grpc"
"net"
@ -36,7 +36,7 @@ func NewRpcChatServer(port int) *rpcChat {
log.NewPrivateLog(constant.LogFileName)
rc := rpcChat{
rpcPort: port,
rpcRegisterName: config.Config.RpcRegisterName.OpenImOfflineMessageName,
rpcRegisterName: config.Config.RpcRegisterName.OpenImMsgName,
etcdSchema: config.Config.Etcd.EtcdSchema,
etcdAddr: config.Config.Etcd.EtcdAddr,
}
@ -65,7 +65,7 @@ func (rpc *rpcChat) Run() {
defer srv.GracefulStop()
rpcRegisterIP := config.Config.RpcRegisterIP
pbChat.RegisterChatServer(srv, rpc)
msg.RegisterMsgServer(srv, rpc)
if config.Config.RpcRegisterIP == "" {
rpcRegisterIP, err = utils.GetLocalIP()
if err != nil {

15
pkg/base_info/msg.go
View File

@ -34,3 +34,18 @@ type MsgDeleteNotificationElem struct {
IsAllDelete bool `json:"isAllDelete"`
SeqList []uint32 `json:"seqList"`
}
//UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
// GroupID string `protobuf:"bytes,2,opt,name=groupID" json:"groupID,omitempty"`
// MinSeq uint32 `protobuf:"varint,3,opt,name=minSeq" json:"minSeq,omitempty"`
// OperationID string `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"`
// OpUserID string `protobuf:"bytes,5,opt,name=opUserID" json:"opUserID,omitempty"`
type SetMsgMinSeqReq struct {
UserID string `json:"userID" binding:"required"`
GroupID string `json:"groupID"`
MinSeq uint32 `json:"minSeq" binding:"required"`
OperationID string `json:"operationID" binding:"required"`
}
type SetMsgMinSeqResp struct {
CommResp
}

31
pkg/common/config/config.go
View File

@ -123,21 +123,22 @@ type config struct {
OpenImCachePort []int `yaml:"openImCachePort"`
}
RpcRegisterName struct {
OpenImStatisticsName string `yaml:"openImStatisticsName"`
OpenImUserName string `yaml:"openImUserName"`
OpenImFriendName string `yaml:"openImFriendName"`
OpenImOfflineMessageName string `yaml:"openImOfflineMessageName"`
OpenImPushName string `yaml:"openImPushName"`
OpenImOnlineMessageRelayName string `yaml:"openImOnlineMessageRelayName"`
OpenImGroupName string `yaml:"openImGroupName"`
OpenImAuthName string `yaml:"openImAuthName"`
OpenImMessageCMSName string `yaml:"openImMessageCMSName"`
OpenImAdminCMSName string `yaml:"openImAdminCMSName"`
OpenImOfficeName string `yaml:"openImOfficeName"`
OpenImOrganizationName string `yaml:"openImOrganizationName"`
OpenImConversationName string `yaml:"openImConversationName"`
OpenImCacheName string `yaml:"openImCacheName"`
OpenImRealTimeCommName string `yaml:"openImRealTimeCommName"`
OpenImStatisticsName string `yaml:"openImStatisticsName"`
OpenImUserName string `yaml:"openImUserName"`
OpenImFriendName string `yaml:"openImFriendName"`
// OpenImOfflineMessageName string `yaml:"openImOfflineMessageName"`
OpenImMsgName string `yaml:"openImMsgName"`
OpenImPushName string `yaml:"openImPushName"`
OpenImRelayName string `yaml:"openImRelayName"`
OpenImGroupName string `yaml:"openImGroupName"`
OpenImAuthName string `yaml:"openImAuthName"`
OpenImMessageCMSName string `yaml:"openImMessageCMSName"`
OpenImAdminCMSName string `yaml:"openImAdminCMSName"`
OpenImOfficeName string `yaml:"openImOfficeName"`
OpenImOrganizationName string `yaml:"openImOrganizationName"`
OpenImConversationName string `yaml:"openImConversationName"`
OpenImCacheName string `yaml:"openImCacheName"`
OpenImRealTimeCommName string `yaml:"openImRealTimeCommName"`
}
Etcd struct {
EtcdSchema string `yaml:"etcdSchema"`

381
pkg/proto/chat/chat.pb.go → pkg/proto/msg/msg.pb.go
View File

@ -1,7 +1,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: chat/chat.proto
// source: msg/msg.proto
package pbChat // import "./chat"
package msg // import "./msg"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
@ -37,7 +37,7 @@ func (m *MsgDataToMQ) Reset() { *m = MsgDataToMQ{} }
func (m *MsgDataToMQ) String() string { return proto.CompactTextString(m) }
func (*MsgDataToMQ) ProtoMessage() {}
func (*MsgDataToMQ) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{0}
return fileDescriptor_msg_f78465087fd6709c, []int{0}
}
func (m *MsgDataToMQ) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MsgDataToMQ.Unmarshal(m, b)
@ -90,7 +90,7 @@ func (m *MsgDataToDB) Reset() { *m = MsgDataToDB{} }
func (m *MsgDataToDB) String() string { return proto.CompactTextString(m) }
func (*MsgDataToDB) ProtoMessage() {}
func (*MsgDataToDB) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{1}
return fileDescriptor_msg_f78465087fd6709c, []int{1}
}
func (m *MsgDataToDB) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MsgDataToDB.Unmarshal(m, b)
@ -137,7 +137,7 @@ func (m *PushMsgDataToMQ) Reset() { *m = PushMsgDataToMQ{} }
func (m *PushMsgDataToMQ) String() string { return proto.CompactTextString(m) }
func (*PushMsgDataToMQ) ProtoMessage() {}
func (*PushMsgDataToMQ) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{2}
return fileDescriptor_msg_f78465087fd6709c, []int{2}
}
func (m *PushMsgDataToMQ) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PushMsgDataToMQ.Unmarshal(m, b)
@ -192,7 +192,7 @@ func (m *MsgDataToMongoByMQ) Reset() { *m = MsgDataToMongoByMQ{} }
func (m *MsgDataToMongoByMQ) String() string { return proto.CompactTextString(m) }
func (*MsgDataToMongoByMQ) ProtoMessage() {}
func (*MsgDataToMongoByMQ) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{3}
return fileDescriptor_msg_f78465087fd6709c, []int{3}
}
func (m *MsgDataToMongoByMQ) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MsgDataToMongoByMQ.Unmarshal(m, b)
@ -272,7 +272,7 @@ func (m *GetMaxAndMinSeqReq) Reset() { *m = GetMaxAndMinSeqReq{} }
func (m *GetMaxAndMinSeqReq) String() string { return proto.CompactTextString(m) }
func (*GetMaxAndMinSeqReq) ProtoMessage() {}
func (*GetMaxAndMinSeqReq) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{4}
return fileDescriptor_msg_f78465087fd6709c, []int{4}
}
func (m *GetMaxAndMinSeqReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetMaxAndMinSeqReq.Unmarshal(m, b)
@ -320,7 +320,7 @@ func (m *GetMaxAndMinSeqResp) Reset() { *m = GetMaxAndMinSeqResp{} }
func (m *GetMaxAndMinSeqResp) String() string { return proto.CompactTextString(m) }
func (*GetMaxAndMinSeqResp) ProtoMessage() {}
func (*GetMaxAndMinSeqResp) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{5}
return fileDescriptor_msg_f78465087fd6709c, []int{5}
}
func (m *GetMaxAndMinSeqResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetMaxAndMinSeqResp.Unmarshal(m, b)
@ -381,7 +381,7 @@ func (m *SendMsgReq) Reset() { *m = SendMsgReq{} }
func (m *SendMsgReq) String() string { return proto.CompactTextString(m) }
func (*SendMsgReq) ProtoMessage() {}
func (*SendMsgReq) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{6}
return fileDescriptor_msg_f78465087fd6709c, []int{6}
}
func (m *SendMsgReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SendMsgReq.Unmarshal(m, b)
@ -437,7 +437,7 @@ func (m *SendMsgResp) Reset() { *m = SendMsgResp{} }
func (m *SendMsgResp) String() string { return proto.CompactTextString(m) }
func (*SendMsgResp) ProtoMessage() {}
func (*SendMsgResp) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{7}
return fileDescriptor_msg_f78465087fd6709c, []int{7}
}
func (m *SendMsgResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SendMsgResp.Unmarshal(m, b)
@ -505,7 +505,7 @@ func (m *ClearMsgReq) Reset() { *m = ClearMsgReq{} }
func (m *ClearMsgReq) String() string { return proto.CompactTextString(m) }
func (*ClearMsgReq) ProtoMessage() {}
func (*ClearMsgReq) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{8}
return fileDescriptor_msg_f78465087fd6709c, []int{8}
}
func (m *ClearMsgReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ClearMsgReq.Unmarshal(m, b)
@ -558,7 +558,7 @@ func (m *ClearMsgResp) Reset() { *m = ClearMsgResp{} }
func (m *ClearMsgResp) String() string { return proto.CompactTextString(m) }
func (*ClearMsgResp) ProtoMessage() {}
func (*ClearMsgResp) Descriptor() ([]byte, []int) {
return fileDescriptor_chat_64077d68a66b2cfd, []int{9}
return fileDescriptor_msg_f78465087fd6709c, []int{9}
}
func (m *ClearMsgResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ClearMsgResp.Unmarshal(m, b)
@ -592,17 +592,135 @@ func (m *ClearMsgResp) GetErrMsg() string {
return ""
}
type SetMsgMinSeqReq struct {
UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
GroupID string `protobuf:"bytes,2,opt,name=groupID" json:"groupID,omitempty"`
MinSeq uint32 `protobuf:"varint,3,opt,name=minSeq" json:"minSeq,omitempty"`
OperationID string `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"`
OpUserID string `protobuf:"bytes,5,opt,name=opUserID" json:"opUserID,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetMsgMinSeqReq) Reset() { *m = SetMsgMinSeqReq{} }
func (m *SetMsgMinSeqReq) String() string { return proto.CompactTextString(m) }
func (*SetMsgMinSeqReq) ProtoMessage() {}
func (*SetMsgMinSeqReq) Descriptor() ([]byte, []int) {
return fileDescriptor_msg_f78465087fd6709c, []int{10}
}
func (m *SetMsgMinSeqReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetMsgMinSeqReq.Unmarshal(m, b)
}
func (m *SetMsgMinSeqReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetMsgMinSeqReq.Marshal(b, m, deterministic)
}
func (dst *SetMsgMinSeqReq) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetMsgMinSeqReq.Merge(dst, src)
}
func (m *SetMsgMinSeqReq) XXX_Size() int {
return xxx_messageInfo_SetMsgMinSeqReq.Size(m)
}
func (m *SetMsgMinSeqReq) XXX_DiscardUnknown() {
xxx_messageInfo_SetMsgMinSeqReq.DiscardUnknown(m)
}
var xxx_messageInfo_SetMsgMinSeqReq proto.InternalMessageInfo
func (m *SetMsgMinSeqReq) GetUserID() string {
if m != nil {
return m.UserID
}
return ""
}
func (m *SetMsgMinSeqReq) GetGroupID() string {
if m != nil {
return m.GroupID
}
return ""
}
func (m *SetMsgMinSeqReq) GetMinSeq() uint32 {
if m != nil {
return m.MinSeq
}
return 0
}
func (m *SetMsgMinSeqReq) GetOperationID() string {
if m != nil {
return m.OperationID
}
return ""
}
func (m *SetMsgMinSeqReq) GetOpUserID() string {
if m != nil {
return m.OpUserID
}
return ""
}
type SetMsgMinSeqResp struct {
ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"`
ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetMsgMinSeqResp) Reset() { *m = SetMsgMinSeqResp{} }
func (m *SetMsgMinSeqResp) String() string { return proto.CompactTextString(m) }
func (*SetMsgMinSeqResp) ProtoMessage() {}
func (*SetMsgMinSeqResp) Descriptor() ([]byte, []int) {
return fileDescriptor_msg_f78465087fd6709c, []int{11}
}
func (m *SetMsgMinSeqResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetMsgMinSeqResp.Unmarshal(m, b)
}
func (m *SetMsgMinSeqResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetMsgMinSeqResp.Marshal(b, m, deterministic)
}
func (dst *SetMsgMinSeqResp) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetMsgMinSeqResp.Merge(dst, src)
}
func (m *SetMsgMinSeqResp) XXX_Size() int {
return xxx_messageInfo_SetMsgMinSeqResp.Size(m)
}
func (m *SetMsgMinSeqResp) XXX_DiscardUnknown() {
xxx_messageInfo_SetMsgMinSeqResp.DiscardUnknown(m)
}
var xxx_messageInfo_SetMsgMinSeqResp proto.InternalMessageInfo
func (m *SetMsgMinSeqResp) GetErrCode() int32 {
if m != nil {
return m.ErrCode
}
return 0
}
func (m *SetMsgMinSeqResp) GetErrMsg() string {
if m != nil {
return m.ErrMsg
}
return ""
}
func init() {
proto.RegisterType((*MsgDataToMQ)(nil), "pbChat.MsgDataToMQ")
proto.RegisterType((*MsgDataToDB)(nil), "pbChat.MsgDataToDB")
proto.RegisterType((*PushMsgDataToMQ)(nil), "pbChat.PushMsgDataToMQ")
proto.RegisterType((*MsgDataToMongoByMQ)(nil), "pbChat.MsgDataToMongoByMQ")
proto.RegisterType((*GetMaxAndMinSeqReq)(nil), "pbChat.GetMaxAndMinSeqReq")
proto.RegisterType((*GetMaxAndMinSeqResp)(nil), "pbChat.GetMaxAndMinSeqResp")
proto.RegisterType((*SendMsgReq)(nil), "pbChat.SendMsgReq")
proto.RegisterType((*SendMsgResp)(nil), "pbChat.SendMsgResp")
proto.RegisterType((*ClearMsgReq)(nil), "pbChat.ClearMsgReq")
proto.RegisterType((*ClearMsgResp)(nil), "pbChat.ClearMsgResp")
proto.RegisterType((*MsgDataToMQ)(nil), "msg.MsgDataToMQ")
proto.RegisterType((*MsgDataToDB)(nil), "msg.MsgDataToDB")
proto.RegisterType((*PushMsgDataToMQ)(nil), "msg.PushMsgDataToMQ")
proto.RegisterType((*MsgDataToMongoByMQ)(nil), "msg.MsgDataToMongoByMQ")
proto.RegisterType((*GetMaxAndMinSeqReq)(nil), "msg.GetMaxAndMinSeqReq")
proto.RegisterType((*GetMaxAndMinSeqResp)(nil), "msg.GetMaxAndMinSeqResp")
proto.RegisterType((*SendMsgReq)(nil), "msg.SendMsgReq")
proto.RegisterType((*SendMsgResp)(nil), "msg.SendMsgResp")
proto.RegisterType((*ClearMsgReq)(nil), "msg.ClearMsgReq")
proto.RegisterType((*ClearMsgResp)(nil), "msg.ClearMsgResp")
proto.RegisterType((*SetMsgMinSeqReq)(nil), "msg.SetMsgMinSeqReq")
proto.RegisterType((*SetMsgMinSeqResp)(nil), "msg.SetMsgMinSeqResp")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -613,244 +731,281 @@ var _ grpc.ClientConn
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for Chat service
// Client API for Msg service
type ChatClient interface {
type MsgClient interface {
GetMaxAndMinSeq(ctx context.Context, in *sdk_ws.GetMaxAndMinSeqReq, opts ...grpc.CallOption) (*sdk_ws.GetMaxAndMinSeqResp, error)
PullMessageBySeqList(ctx context.Context, in *sdk_ws.PullMessageBySeqListReq, opts ...grpc.CallOption) (*sdk_ws.PullMessageBySeqListResp, error)
SendMsg(ctx context.Context, in *SendMsgReq, opts ...grpc.CallOption) (*SendMsgResp, error)
DelMsgList(ctx context.Context, in *sdk_ws.DelMsgListReq, opts ...grpc.CallOption) (*sdk_ws.DelMsgListResp, error)
ClearMsg(ctx context.Context, in *ClearMsgReq, opts ...grpc.CallOption) (*ClearMsgResp, error)
SetMsgMinSeq(ctx context.Context, in *SetMsgMinSeqReq, opts ...grpc.CallOption) (*SetMsgMinSeqResp, error)
}
type chatClient struct {
type msgClient struct {
cc *grpc.ClientConn
}
func NewChatClient(cc *grpc.ClientConn) ChatClient {
return &chatClient{cc}
func NewMsgClient(cc *grpc.ClientConn) MsgClient {
return &msgClient{cc}
}
func (c *chatClient) GetMaxAndMinSeq(ctx context.Context, in *sdk_ws.GetMaxAndMinSeqReq, opts ...grpc.CallOption) (*sdk_ws.GetMaxAndMinSeqResp, error) {
func (c *msgClient) GetMaxAndMinSeq(ctx context.Context, in *sdk_ws.GetMaxAndMinSeqReq, opts ...grpc.CallOption) (*sdk_ws.GetMaxAndMinSeqResp, error) {
out := new(sdk_ws.GetMaxAndMinSeqResp)
err := grpc.Invoke(ctx, "/pbChat.Chat/GetMaxAndMinSeq", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/msg.msg/GetMaxAndMinSeq", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) PullMessageBySeqList(ctx context.Context, in *sdk_ws.PullMessageBySeqListReq, opts ...grpc.CallOption) (*sdk_ws.PullMessageBySeqListResp, error) {
func (c *msgClient) PullMessageBySeqList(ctx context.Context, in *sdk_ws.PullMessageBySeqListReq, opts ...grpc.CallOption) (*sdk_ws.PullMessageBySeqListResp, error) {
out := new(sdk_ws.PullMessageBySeqListResp)
err := grpc.Invoke(ctx, "/pbChat.Chat/PullMessageBySeqList", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/msg.msg/PullMessageBySeqList", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) SendMsg(ctx context.Context, in *SendMsgReq, opts ...grpc.CallOption) (*SendMsgResp, error) {
func (c *msgClient) SendMsg(ctx context.Context, in *SendMsgReq, opts ...grpc.CallOption) (*SendMsgResp, error) {
out := new(SendMsgResp)
err := grpc.Invoke(ctx, "/pbChat.Chat/SendMsg", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/msg.msg/SendMsg", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) DelMsgList(ctx context.Context, in *sdk_ws.DelMsgListReq, opts ...grpc.CallOption) (*sdk_ws.DelMsgListResp, error) {
func (c *msgClient) DelMsgList(ctx context.Context, in *sdk_ws.DelMsgListReq, opts ...grpc.CallOption) (*sdk_ws.DelMsgListResp, error) {
out := new(sdk_ws.DelMsgListResp)
err := grpc.Invoke(ctx, "/pbChat.Chat/DelMsgList", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/msg.msg/DelMsgList", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *chatClient) ClearMsg(ctx context.Context, in *ClearMsgReq, opts ...grpc.CallOption) (*ClearMsgResp, error) {
func (c *msgClient) ClearMsg(ctx context.Context, in *ClearMsgReq, opts ...grpc.CallOption) (*ClearMsgResp, error) {
out := new(ClearMsgResp)
err := grpc.Invoke(ctx, "/pbChat.Chat/ClearMsg", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/msg.msg/ClearMsg", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Chat service
func (c *msgClient) SetMsgMinSeq(ctx context.Context, in *SetMsgMinSeqReq, opts ...grpc.CallOption) (*SetMsgMinSeqResp, error) {
out := new(SetMsgMinSeqResp)
err := grpc.Invoke(ctx, "/msg.msg/SetMsgMinSeq", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
type ChatServer interface {
// Server API for Msg service
type MsgServer interface {
GetMaxAndMinSeq(context.Context, *sdk_ws.GetMaxAndMinSeqReq) (*sdk_ws.GetMaxAndMinSeqResp, error)
PullMessageBySeqList(context.Context, *sdk_ws.PullMessageBySeqListReq) (*sdk_ws.PullMessageBySeqListResp, error)
SendMsg(context.Context, *SendMsgReq) (*SendMsgResp, error)
DelMsgList(context.Context, *sdk_ws.DelMsgListReq) (*sdk_ws.DelMsgListResp, error)
ClearMsg(context.Context, *ClearMsgReq) (*ClearMsgResp, error)
SetMsgMinSeq(context.Context, *SetMsgMinSeqReq) (*SetMsgMinSeqResp, error)
}
func RegisterChatServer(s *grpc.Server, srv ChatServer) {
s.RegisterService(&_Chat_serviceDesc, srv)
func RegisterMsgServer(s *grpc.Server, srv MsgServer) {
s.RegisterService(&_Msg_serviceDesc, srv)
}
func _Chat_GetMaxAndMinSeq_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Msg_GetMaxAndMinSeq_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(sdk_ws.GetMaxAndMinSeqReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).GetMaxAndMinSeq(ctx, in)
return srv.(MsgServer).GetMaxAndMinSeq(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pbChat.Chat/GetMaxAndMinSeq",
FullMethod: "/msg.msg/GetMaxAndMinSeq",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).GetMaxAndMinSeq(ctx, req.(*sdk_ws.GetMaxAndMinSeqReq))
return srv.(MsgServer).GetMaxAndMinSeq(ctx, req.(*sdk_ws.GetMaxAndMinSeqReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_PullMessageBySeqList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Msg_PullMessageBySeqList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(sdk_ws.PullMessageBySeqListReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).PullMessageBySeqList(ctx, in)
return srv.(MsgServer).PullMessageBySeqList(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pbChat.Chat/PullMessageBySeqList",
FullMethod: "/msg.msg/PullMessageBySeqList",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).PullMessageBySeqList(ctx, req.(*sdk_ws.PullMessageBySeqListReq))
return srv.(MsgServer).PullMessageBySeqList(ctx, req.(*sdk_ws.PullMessageBySeqListReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_SendMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Msg_SendMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SendMsgReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).SendMsg(ctx, in)
return srv.(MsgServer).SendMsg(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pbChat.Chat/SendMsg",
FullMethod: "/msg.msg/SendMsg",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).SendMsg(ctx, req.(*SendMsgReq))
return srv.(MsgServer).SendMsg(ctx, req.(*SendMsgReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_DelMsgList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Msg_DelMsgList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(sdk_ws.DelMsgListReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).DelMsgList(ctx, in)
return srv.(MsgServer).DelMsgList(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pbChat.Chat/DelMsgList",
FullMethod: "/msg.msg/DelMsgList",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).DelMsgList(ctx, req.(*sdk_ws.DelMsgListReq))
return srv.(MsgServer).DelMsgList(ctx, req.(*sdk_ws.DelMsgListReq))
}
return interceptor(ctx, in, info, handler)
}
func _Chat_ClearMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Msg_ClearMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ClearMsgReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ChatServer).ClearMsg(ctx, in)
return srv.(MsgServer).ClearMsg(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pbChat.Chat/ClearMsg",
FullMethod: "/msg.msg/ClearMsg",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ChatServer).ClearMsg(ctx, req.(*ClearMsgReq))
return srv.(MsgServer).ClearMsg(ctx, req.(*ClearMsgReq))
}
return interceptor(ctx, in, info, handler)
}
var _Chat_serviceDesc = grpc.ServiceDesc{
ServiceName: "pbChat.Chat",
HandlerType: (*ChatServer)(nil),
func _Msg_SetMsgMinSeq_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetMsgMinSeqReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(MsgServer).SetMsgMinSeq(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/msg.msg/SetMsgMinSeq",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MsgServer).SetMsgMinSeq(ctx, req.(*SetMsgMinSeqReq))
}
return interceptor(ctx, in, info, handler)
}
var _Msg_serviceDesc = grpc.ServiceDesc{
ServiceName: "msg.msg",
HandlerType: (*MsgServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetMaxAndMinSeq",
Handler: _Chat_GetMaxAndMinSeq_Handler,
Handler: _Msg_GetMaxAndMinSeq_Handler,
},
{
MethodName: "PullMessageBySeqList",
Handler: _Chat_PullMessageBySeqList_Handler,
Handler: _Msg_PullMessageBySeqList_Handler,
},
{
MethodName: "SendMsg",
Handler: _Chat_SendMsg_Handler,
Handler: _Msg_SendMsg_Handler,
},
{
MethodName: "DelMsgList",
Handler: _Chat_DelMsgList_Handler,
Handler: _Msg_DelMsgList_Handler,
},
{
MethodName: "ClearMsg",
Handler: _Chat_ClearMsg_Handler,
Handler: _Msg_ClearMsg_Handler,
},
{
MethodName: "SetMsgMinSeq",
Handler: _Msg_SetMsgMinSeq_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "chat/chat.proto",
Metadata: "msg/msg.proto",
}
func init() { proto.RegisterFile("chat/chat.proto", fileDescriptor_chat_64077d68a66b2cfd) }
func init() { proto.RegisterFile("msg/msg.proto", fileDescriptor_msg_f78465087fd6709c) }
var fileDescriptor_chat_64077d68a66b2cfd = []byte{
// 636 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0x41, 0x6f, 0xda, 0x4c,
0x10, 0x95, 0x43, 0x42, 0x92, 0x71, 0x22, 0xa4, 0x4d, 0x14, 0x21, 0xf4, 0x1d, 0x1c, 0xeb, 0x6b,
0x85, 0x5a, 0x09, 0x24, 0xda, 0x9c, 0x7a, 0x69, 0x09, 0x51, 0x15, 0xa9, 0x6e, 0x12, 0x93, 0x5e,
0x7a, 0xa1, 0x9b, 0x30, 0x5a, 0xac, 0x80, 0xbd, 0xec, 0x98, 0x26, 0x69, 0x7f, 0x43, 0xcf, 0x3d,
0xf6, 0xdc, 0x7f, 0x59, 0xed, 0xae, 0x01, 0x83, 0x91, 0x82, 0x7a, 0xe8, 0x05, 0xe9, 0xbd, 0x7d,
0xbc, 0x99, 0x37, 0x3b, 0x2b, 0x43, 0xe5, 0x76, 0xc0, 0xd3, 0xa6, 0xfe, 0x69, 0x48, 0x95, 0xa4,
0x09, 0x2b, 0xcb, 0x9b, 0xd3, 0x01, 0x4f, 0x6b, 0xc7, 0x17, 0x12, 0xe3, 0xde, 0x79, 0xd0, 0x94,
0x77, 0xa2, 0x69, 0x8e, 0x9a, 0xd4, 0xbf, 0xeb, 0xdd, 0x53, 0xf3, 0x9e, 0xac, 0xd4, 0xff, 0x0e,
0x6e, 0x40, 0xa2, 0xc3, 0x53, 0x7e, 0x9d, 0x04, 0x57, 0xec, 0x10, 0xb6, 0xd2, 0xe4, 0x0e, 0xe3,
0xaa, 0xe3, 0x39, 0xf5, 0xdd, 0xd0, 0x02, 0xe6, 0x81, 0x9b, 0x48, 0x54, 0x3c, 0x8d, 0x92, 0xf8,
0xbc, 0x53, 0xdd, 0x30, 0x67, 0x79, 0x8a, 0xbd, 0x86, 0xed, 0x91, 0xb5, 0xa9, 0x96, 0x3c, 0xa7,
0xee, 0xb6, 0x6a, 0x0d, 0x42, 0xf5, 0x15, 0x55, 0x8f, 0xcb, 0xa8, 0x27, 0xb9, 0xe2, 0x23, 0x6a,
0x64, 0x85, 0xc2, 0xa9, 0xd4, 0xc7, 0x5c, 0xf1, 0x4e, 0x3b, 0x6f, 0xe2, 0xac, 0x6d, 0xf2, 0x74,
0x73, 0xfe, 0x0f, 0x07, 0x2a, 0x97, 0x13, 0x1a, 0xe4, 0x83, 0x7a, 0xe0, 0x5e, 0xe4, 0xfe, 0x65,
0xe3, 0xe6, 0xa9, 0x7c, 0x37, 0x1b, 0xeb, 0x77, 0xe3, 0xc3, 0x9e, 0x9c, 0xd0, 0xe0, 0x3a, 0xf9,
0x44, 0xa8, 0xce, 0x3b, 0x66, 0x1a, 0xbb, 0xe1, 0x02, 0xe7, 0xff, 0x76, 0x80, 0xcd, 0x7b, 0x49,
0x62, 0x91, 0xb4, 0x1f, 0x83, 0x2b, 0x56, 0x85, 0xed, 0x21, 0xa7, 0xb4, 0x8b, 0x63, 0xd3, 0xce,
0x66, 0x38, 0x85, 0xec, 0x7f, 0xd8, 0xe7, 0x42, 0x28, 0x14, 0x8b, 0x21, 0x17, 0x49, 0x76, 0x02,
0xee, 0x08, 0x89, 0xb8, 0xc0, 0x0f, 0x11, 0xa5, 0xd5, 0x92, 0x57, 0xaa, 0xbb, 0xad, 0x83, 0x86,
0xdd, 0x85, 0x46, 0x2e, 0x7c, 0x98, 0xd7, 0xb1, 0xff, 0x60, 0x37, 0x55, 0x91, 0x10, 0xa6, 0xdd,
0x4d, 0x63, 0x3c, 0x27, 0xfc, 0x8f, 0xc0, 0xde, 0x63, 0x1a, 0xf0, 0x87, 0x77, 0x71, 0x3f, 0x88,
0xe2, 0x2e, 0x8e, 0x43, 0x1c, 0xb3, 0x23, 0x28, 0x67, 0xf9, 0xec, 0xe0, 0x32, 0xb4, 0x3c, 0xd5,
0x8d, 0xc2, 0x54, 0xfd, 0x7b, 0x38, 0x28, 0xf8, 0x91, 0xd4, 0xd9, 0xcf, 0x94, 0x3a, 0x4d, 0xfa,
0x68, 0x1c, 0xb7, 0xc2, 0x29, 0xd4, 0xa5, 0xce, 0x94, 0x0a, 0x48, 0x64, 0x6e, 0x19, 0xd2, 0x7c,
0xc0, 0x1f, 0xf4, 0xb0, 0xf4, 0x88, 0xf7, 0xc3, 0x0c, 0x19, 0xde, 0xf8, 0x9a, 0x2c, 0x9a, 0x37,
0xc8, 0xff, 0x06, 0xd0, 0xc5, 0xb8, 0x1f, 0x90, 0xd0, 0x01, 0xfe, 0xed, 0x9e, 0xff, 0x72, 0xc0,
0x9d, 0x15, 0xb7, 0x69, 0x71, 0x31, 0x2d, 0xce, 0xd3, 0xe2, 0x42, 0x5a, 0x8b, 0x74, 0x67, 0xb6,
0x4e, 0x40, 0x62, 0x76, 0x4d, 0x79, 0x4a, 0x2b, 0x6e, 0x87, 0x11, 0xc6, 0xa9, 0x55, 0x6c, 0x59,
0x45, 0x8e, 0x62, 0x35, 0xd8, 0x21, 0x8c, 0xfb, 0xd7, 0xd1, 0x08, 0xab, 0x65, 0xcf, 0xa9, 0x97,
0xc2, 0x19, 0xf6, 0x6f, 0xc1, 0x3d, 0x1d, 0x22, 0x57, 0xd9, 0x78, 0x8e, 0xa0, 0x3c, 0x59, 0xb8,
0x5f, 0x8b, 0xb4, 0x45, 0x22, 0xb3, 0x9b, 0xb7, 0x0d, 0xce, 0xf0, 0xf2, 0xf0, 0x4a, 0xc5, 0x77,
0xf8, 0x16, 0xf6, 0xe6, 0x45, 0xfe, 0x66, 0x0c, 0xad, 0x9f, 0x25, 0xd8, 0xd4, 0xdb, 0xcc, 0xbe,
0x40, 0x65, 0x69, 0x8d, 0xd8, 0xb3, 0x15, 0x37, 0x51, 0x5c, 0xdd, 0xda, 0xf3, 0x75, 0x64, 0x24,
0x59, 0x02, 0x87, 0x97, 0x93, 0xe1, 0x30, 0xb0, 0x2f, 0xa5, 0xfd, 0xd8, 0xc5, 0xb1, 0x79, 0x2e,
0x2f, 0x56, 0xfc, 0x7f, 0x95, 0x50, 0xd7, 0x7a, 0xb9, 0xb6, 0x96, 0x24, 0x6b, 0xc1, 0x76, 0xb6,
0x23, 0x8c, 0x4d, 0x1f, 0xed, 0x7c, 0x63, 0x6b, 0x07, 0x05, 0x8e, 0x24, 0xbb, 0x02, 0xe8, 0xe0,
0x30, 0x20, 0x61, 0x5a, 0xf3, 0x56, 0x94, 0x9b, 0x1f, 0x6b, 0x93, 0xe3, 0x27, 0x14, 0x24, 0xd9,
0x09, 0xec, 0x4c, 0x2f, 0x89, 0xcd, 0x6a, 0xe6, 0x76, 0xa3, 0x76, 0x58, 0x24, 0x49, 0xb6, 0x2b,
0x9f, 0xf7, 0x1b, 0xe6, 0x13, 0xf4, 0xc6, 0x9e, 0xde, 0x94, 0xcd, 0xf7, 0xe5, 0xd5, 0x9f, 0x00,
0x00, 0x00, 0xff, 0xff, 0x88, 0x55, 0xa7, 0xa7, 0x9d, 0x06, 0x00, 0x00,
var fileDescriptor_msg_f78465087fd6709c = []byte{
// 696 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xc1, 0x6e, 0xd3, 0x4c,
0x10, 0x96, 0x9b, 0x26, 0x69, 0xc6, 0xad, 0xd2, 0x7f, 0xff, 0x52, 0x45, 0x16, 0x07, 0xd7, 0x02,
0x14, 0x01, 0x4a, 0xa4, 0xc0, 0xad, 0x17, 0x48, 0x53, 0xa1, 0x4a, 0x98, 0xb6, 0x4e, 0xb9, 0x70,
0x09, 0xa6, 0x59, 0x6d, 0xad, 0xc6, 0xf6, 0x66, 0xc7, 0xa1, 0x2d, 0x3c, 0x03, 0x0f, 0xc0, 0x89,
0x1b, 0xaf, 0xc2, 0x6b, 0xa1, 0xdd, 0x75, 0x92, 0x75, 0x12, 0xa9, 0x51, 0x0f, 0x1c, 0xbf, 0xcf,
0xb3, 0x33, 0xdf, 0x37, 0x3b, 0xb3, 0x86, 0x9d, 0x18, 0x59, 0x3b, 0x46, 0xd6, 0xe2, 0x22, 0xcd,
0x52, 0x52, 0x8a, 0x91, 0x39, 0x07, 0xa7, 0x9c, 0x26, 0x83, 0x13, 0xbf, 0xcd, 0xaf, 0x59, 0x5b,
0xf1, 0x6d, 0x1c, 0x5e, 0x0f, 0x6e, 0xb0, 0x7d, 0x83, 0x3a, 0xce, 0xfb, 0x0e, 0xb6, 0x8f, 0xac,
0x17, 0x66, 0xe1, 0x45, 0xea, 0x9f, 0x93, 0x3d, 0x28, 0x67, 0xe9, 0x35, 0x4d, 0x1a, 0x96, 0x6b,
0x35, 0x6b, 0x81, 0x06, 0xc4, 0x05, 0x3b, 0xe5, 0x54, 0x84, 0x59, 0x94, 0x26, 0x27, 0xbd, 0xc6,
0x86, 0xfa, 0x66, 0x52, 0xe4, 0x35, 0x54, 0x63, 0x9d, 0xa6, 0x51, 0x72, 0xad, 0xa6, 0xdd, 0x71,
0x5a, 0x48, 0xc5, 0x57, 0x2a, 0x06, 0x21, 0x8f, 0x06, 0x3c, 0x14, 0x61, 0x8c, 0xad, 0xbc, 0x50,
0x30, 0x0d, 0xf5, 0xa8, 0x51, 0xbc, 0xd7, 0x35, 0x93, 0x58, 0x6b, 0x27, 0xb9, 0x5f, 0x9c, 0xf7,
0xc3, 0x82, 0xfa, 0xd9, 0x04, 0xaf, 0x4c, 0xa3, 0x2e, 0xd8, 0xa7, 0xc6, 0x29, 0x6d, 0xd7, 0xa4,
0x4c, 0x35, 0x1b, 0xeb, 0xab, 0xf1, 0x60, 0x9b, 0x4f, 0xf0, 0xea, 0x22, 0xfd, 0x88, 0x54, 0x9c,
0xf4, 0x54, 0x37, 0x6a, 0x41, 0x81, 0xf3, 0x7e, 0x5b, 0x40, 0xe6, 0x5a, 0xd2, 0x84, 0xa5, 0xdd,
0x3b, 0xff, 0x9c, 0x34, 0xa0, 0x3a, 0x0a, 0x31, 0xeb, 0xd3, 0xb1, 0x92, 0xb3, 0x19, 0x4c, 0x21,
0x79, 0x02, 0x3b, 0x21, 0x63, 0x82, 0xb2, 0xa2, 0xc9, 0x22, 0x49, 0x3a, 0x60, 0xc7, 0x14, 0x31,
0x64, 0xf4, 0x7d, 0x84, 0x59, 0xa3, 0xe4, 0x96, 0x9a, 0x76, 0x67, 0xb7, 0x25, 0x67, 0xc2, 0x70,
0x1e, 0x98, 0x41, 0xe4, 0x31, 0xd4, 0x32, 0x11, 0x31, 0xa6, 0xb4, 0x6e, 0xaa, 0xac, 0x73, 0xc2,
0xfb, 0x00, 0xe4, 0x1d, 0xcd, 0xfc, 0xf0, 0xf6, 0x6d, 0x32, 0xf4, 0xa3, 0xa4, 0x4f, 0xc7, 0x01,
0x1d, 0x93, 0x7d, 0xa8, 0xe4, 0xe6, 0x74, 0xd7, 0x72, 0xb4, 0xd8, 0xd2, 0x8d, 0xa5, 0x96, 0x7a,
0x37, 0xf0, 0xff, 0x52, 0x3e, 0xe4, 0xd2, 0xf8, 0xb1, 0x10, 0x47, 0xe9, 0x90, 0xaa, 0x8c, 0xe5,
0x60, 0x0a, 0x65, 0xa9, 0x63, 0x21, 0x7c, 0x64, 0x79, 0xb6, 0x1c, 0x49, 0xde, 0x0f, 0x6f, 0x65,
0xa7, 0x64, 0x7f, 0x77, 0x82, 0x1c, 0x29, 0x5e, 0xe5, 0x55, 0x5e, 0x24, 0xaf, 0x90, 0xf7, 0x0d,
0xa0, 0x4f, 0x93, 0xa1, 0x8f, 0x4c, 0x1a, 0xf8, 0xb7, 0x43, 0xfe, 0xcb, 0x02, 0x7b, 0x56, 0x5c,
0xbb, 0xa5, 0x45, 0xb7, 0x74, 0xee, 0x96, 0x16, 0xdc, 0x6a, 0x24, 0x95, 0xe9, 0x3a, 0x3e, 0xb2,
0xd9, 0x35, 0x99, 0x94, 0x8c, 0xb8, 0x1c, 0x45, 0x34, 0xc9, 0x74, 0x44, 0x59, 0x47, 0x18, 0x14,
0x71, 0x60, 0x0b, 0x69, 0x32, 0xbc, 0x88, 0x62, 0xda, 0xa8, 0xb8, 0x56, 0xb3, 0x14, 0xcc, 0xb0,
0x77, 0x09, 0xf6, 0xd1, 0x88, 0x86, 0x22, 0x6f, 0xcf, 0x3e, 0x54, 0x26, 0x85, 0xfb, 0xd5, 0x48,
0xa6, 0x48, 0x79, 0x7e, 0xf3, 0x5a, 0xe0, 0x0c, 0x2f, 0x36, 0xaf, 0xb4, 0xbc, 0x84, 0x6f, 0x60,
0x7b, 0x5e, 0xe4, 0x21, 0x6d, 0xf0, 0x7e, 0x5a, 0x50, 0xef, 0x53, 0xe9, 0xa7, 0x30, 0x8b, 0x2b,
0xb5, 0x36, 0xa0, 0xca, 0x44, 0x3a, 0xe1, 0x33, 0xa9, 0x53, 0x28, 0x4f, 0xc4, 0x7a, 0x44, 0xf2,
0xd1, 0xd1, 0x68, 0xd1, 0xc1, 0xe6, 0xf2, 0xf5, 0x9b, 0xfe, 0xcb, 0x45, 0xff, 0x5e, 0x0f, 0x76,
0x8b, 0xd2, 0x1e, 0xe2, 0xb0, 0xf3, 0xa7, 0x04, 0xf2, 0xdd, 0x26, 0x9f, 0xa1, 0xbe, 0xb0, 0x27,
0xe4, 0xe9, 0x8a, 0x51, 0x5b, 0xde, 0x4d, 0xe7, 0xd9, 0x3a, 0x61, 0xc8, 0x49, 0x0a, 0x7b, 0x67,
0x93, 0xd1, 0xc8, 0xd7, 0x4f, 0x41, 0xf7, 0xae, 0x4f, 0xc7, 0xea, 0x3d, 0x78, 0xbe, 0xe2, 0xfc,
0xaa, 0x40, 0x59, 0xeb, 0xc5, 0xda, 0xb1, 0xc8, 0xc9, 0x4b, 0xa8, 0xe6, 0x4b, 0x40, 0xea, 0xea,
0x49, 0x9a, 0xef, 0xa3, 0xb3, 0x5b, 0x24, 0x90, 0x93, 0x73, 0x80, 0x1e, 0x1d, 0xf9, 0xc8, 0x94,
0x28, 0x77, 0x45, 0xa1, 0xf9, 0x67, 0x99, 0xe1, 0xe0, 0x9e, 0x08, 0xe4, 0xa4, 0x0d, 0x5b, 0xd3,
0xf9, 0x23, 0xba, 0xa0, 0x31, 0xf3, 0xce, 0x7f, 0x0b, 0x0c, 0x72, 0x72, 0x08, 0xdb, 0xe6, 0x95,
0x92, 0xbd, 0x5c, 0x65, 0x61, 0x00, 0x9d, 0x47, 0x2b, 0x58, 0xe4, 0x5d, 0xfb, 0x53, 0xad, 0x25,
0xff, 0xc6, 0x87, 0x31, 0xb2, 0x2f, 0x15, 0xf5, 0xab, 0x7d, 0xf5, 0x37, 0x00, 0x00, 0xff, 0xff,
0x3e, 0x48, 0x33, 0x18, 0xa3, 0x07, 0x00, 0x00,
}

19
pkg/proto/chat/chat.proto → pkg/proto/msg/msg.proto
View File

@ -1,7 +1,7 @@
syntax = "proto3";
import "Open_IM/pkg/proto/sdk_ws/ws.proto";
option go_package = "./chat;pbChat";
package pbChat;
option go_package = "./msg;msg";
package msg;
@ -92,10 +92,23 @@ message ClearMsgResp{
string errMsg = 2;
}
service Chat {
message SetMsgMinSeqReq{
string userID = 1;
string groupID = 2;
uint32 minSeq = 3;
string operationID = 4;
string opUserID = 5;
}
message SetMsgMinSeqResp{
int32 errCode = 1;
string errMsg = 2;
}
service msg {
rpc GetMaxAndMinSeq(server_api_params.GetMaxAndMinSeqReq) returns(server_api_params.GetMaxAndMinSeqResp);
rpc PullMessageBySeqList(server_api_params.PullMessageBySeqListReq) returns(server_api_params.PullMessageBySeqListResp);
rpc SendMsg(SendMsgReq) returns(SendMsgResp);
rpc DelMsgList(server_api_params.DelMsgListReq) returns(server_api_params.DelMsgListResp);
rpc ClearMsg(ClearMsgReq) returns(ClearMsgResp);
rpc SetMsgMinSeq(SetMsgMinSeqReq) returns(SetMsgMinSeqResp);
}

212
pkg/proto/relay/relay.pb.go
View File

@ -37,7 +37,7 @@ func (m *OnlinePushMsgReq) Reset() { *m = OnlinePushMsgReq{} }
func (m *OnlinePushMsgReq) String() string { return proto.CompactTextString(m) }
func (*OnlinePushMsgReq) ProtoMessage() {}
func (*OnlinePushMsgReq) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{0}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{0}
}
func (m *OnlinePushMsgReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OnlinePushMsgReq.Unmarshal(m, b)
@ -89,7 +89,7 @@ func (m *OnlinePushMsgResp) Reset() { *m = OnlinePushMsgResp{} }
func (m *OnlinePushMsgResp) String() string { return proto.CompactTextString(m) }
func (*OnlinePushMsgResp) ProtoMessage() {}
func (*OnlinePushMsgResp) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{1}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{1}
}
func (m *OnlinePushMsgResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OnlinePushMsgResp.Unmarshal(m, b)
@ -129,7 +129,7 @@ func (m *SingelMsgToUserResultList) Reset() { *m = SingelMsgToUserResult
func (m *SingelMsgToUserResultList) String() string { return proto.CompactTextString(m) }
func (*SingelMsgToUserResultList) ProtoMessage() {}
func (*SingelMsgToUserResultList) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{2}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{2}
}
func (m *SingelMsgToUserResultList) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SingelMsgToUserResultList.Unmarshal(m, b)
@ -183,7 +183,7 @@ func (m *OnlineBatchPushOneMsgReq) Reset() { *m = OnlineBatchPushOneMsgR
func (m *OnlineBatchPushOneMsgReq) String() string { return proto.CompactTextString(m) }
func (*OnlineBatchPushOneMsgReq) ProtoMessage() {}
func (*OnlineBatchPushOneMsgReq) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{3}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{3}
}
func (m *OnlineBatchPushOneMsgReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OnlineBatchPushOneMsgReq.Unmarshal(m, b)
@ -235,7 +235,7 @@ func (m *OnlineBatchPushOneMsgResp) Reset() { *m = OnlineBatchPushOneMsg
func (m *OnlineBatchPushOneMsgResp) String() string { return proto.CompactTextString(m) }
func (*OnlineBatchPushOneMsgResp) ProtoMessage() {}
func (*OnlineBatchPushOneMsgResp) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{4}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{4}
}
func (m *OnlineBatchPushOneMsgResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OnlineBatchPushOneMsgResp.Unmarshal(m, b)
@ -275,7 +275,7 @@ func (m *SingleMsgToUserPlatform) Reset() { *m = SingleMsgToUserPlatform
func (m *SingleMsgToUserPlatform) String() string { return proto.CompactTextString(m) }
func (*SingleMsgToUserPlatform) ProtoMessage() {}
func (*SingleMsgToUserPlatform) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{5}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{5}
}
func (m *SingleMsgToUserPlatform) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SingleMsgToUserPlatform.Unmarshal(m, b)
@ -329,7 +329,7 @@ func (m *GetUsersOnlineStatusReq) Reset() { *m = GetUsersOnlineStatusReq
func (m *GetUsersOnlineStatusReq) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusReq) ProtoMessage() {}
func (*GetUsersOnlineStatusReq) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{6}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{6}
}
func (m *GetUsersOnlineStatusReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusReq.Unmarshal(m, b)
@ -384,7 +384,7 @@ func (m *GetUsersOnlineStatusResp) Reset() { *m = GetUsersOnlineStatusRe
func (m *GetUsersOnlineStatusResp) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusResp) ProtoMessage() {}
func (*GetUsersOnlineStatusResp) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{7}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{7}
}
func (m *GetUsersOnlineStatusResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusResp.Unmarshal(m, b)
@ -446,7 +446,7 @@ func (m *GetUsersOnlineStatusResp_SuccessDetail) Reset() {
func (m *GetUsersOnlineStatusResp_SuccessDetail) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusResp_SuccessDetail) ProtoMessage() {}
func (*GetUsersOnlineStatusResp_SuccessDetail) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{7, 0}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{7, 0}
}
func (m *GetUsersOnlineStatusResp_SuccessDetail) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusResp_SuccessDetail.Unmarshal(m, b)
@ -493,7 +493,7 @@ func (m *GetUsersOnlineStatusResp_FailedDetail) Reset() { *m = GetUsersO
func (m *GetUsersOnlineStatusResp_FailedDetail) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusResp_FailedDetail) ProtoMessage() {}
func (*GetUsersOnlineStatusResp_FailedDetail) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{7, 1}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{7, 1}
}
func (m *GetUsersOnlineStatusResp_FailedDetail) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusResp_FailedDetail.Unmarshal(m, b)
@ -549,7 +549,7 @@ func (m *GetUsersOnlineStatusResp_SuccessResult) Reset() {
func (m *GetUsersOnlineStatusResp_SuccessResult) String() string { return proto.CompactTextString(m) }
func (*GetUsersOnlineStatusResp_SuccessResult) ProtoMessage() {}
func (*GetUsersOnlineStatusResp_SuccessResult) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{7, 2}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{7, 2}
}
func (m *GetUsersOnlineStatusResp_SuccessResult) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUsersOnlineStatusResp_SuccessResult.Unmarshal(m, b)
@ -603,7 +603,7 @@ func (m *KickUserOfflineReq) Reset() { *m = KickUserOfflineReq{} }
func (m *KickUserOfflineReq) String() string { return proto.CompactTextString(m) }
func (*KickUserOfflineReq) ProtoMessage() {}
func (*KickUserOfflineReq) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{8}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{8}
}
func (m *KickUserOfflineReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_KickUserOfflineReq.Unmarshal(m, b)
@ -654,7 +654,7 @@ func (m *KickUserOfflineResp) Reset() { *m = KickUserOfflineResp{} }
func (m *KickUserOfflineResp) String() string { return proto.CompactTextString(m) }
func (*KickUserOfflineResp) ProtoMessage() {}
func (*KickUserOfflineResp) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_eb517eee82ca0aca, []int{9}
return fileDescriptor_relay_9ac412c3c8c99f28, []int{9}
}
func (m *KickUserOfflineResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_KickUserOfflineResp.Unmarshal(m, b)
@ -698,9 +698,9 @@ var _ grpc.ClientConn
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for OnlineMessageRelayService service
// Client API for Relay service
type OnlineMessageRelayServiceClient interface {
type RelayClient interface {
OnlinePushMsg(ctx context.Context, in *OnlinePushMsgReq, opts ...grpc.CallOption) (*OnlinePushMsgResp, error)
GetUsersOnlineStatus(ctx context.Context, in *GetUsersOnlineStatusReq, opts ...grpc.CallOption) (*GetUsersOnlineStatusResp, error)
OnlineBatchPushOneMsg(ctx context.Context, in *OnlineBatchPushOneMsgReq, opts ...grpc.CallOption) (*OnlineBatchPushOneMsgResp, error)
@ -708,62 +708,62 @@ type OnlineMessageRelayServiceClient interface {
KickUserOffline(ctx context.Context, in *KickUserOfflineReq, opts ...grpc.CallOption) (*KickUserOfflineResp, error)
}
type onlineMessageRelayServiceClient struct {
type relayClient struct {
cc *grpc.ClientConn
}
func NewOnlineMessageRelayServiceClient(cc *grpc.ClientConn) OnlineMessageRelayServiceClient {
return &onlineMessageRelayServiceClient{cc}
func NewRelayClient(cc *grpc.ClientConn) RelayClient {
return &relayClient{cc}
}
func (c *onlineMessageRelayServiceClient) OnlinePushMsg(ctx context.Context, in *OnlinePushMsgReq, opts ...grpc.CallOption) (*OnlinePushMsgResp, error) {
func (c *relayClient) OnlinePushMsg(ctx context.Context, in *OnlinePushMsgReq, opts ...grpc.CallOption) (*OnlinePushMsgResp, error) {
out := new(OnlinePushMsgResp)
err := grpc.Invoke(ctx, "/relay.OnlineMessageRelayService/OnlinePushMsg", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/relay.relay/OnlinePushMsg", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *onlineMessageRelayServiceClient) GetUsersOnlineStatus(ctx context.Context, in *GetUsersOnlineStatusReq, opts ...grpc.CallOption) (*GetUsersOnlineStatusResp, error) {
func (c *relayClient) GetUsersOnlineStatus(ctx context.Context, in *GetUsersOnlineStatusReq, opts ...grpc.CallOption) (*GetUsersOnlineStatusResp, error) {
out := new(GetUsersOnlineStatusResp)
err := grpc.Invoke(ctx, "/relay.OnlineMessageRelayService/GetUsersOnlineStatus", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/relay.relay/GetUsersOnlineStatus", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *onlineMessageRelayServiceClient) OnlineBatchPushOneMsg(ctx context.Context, in *OnlineBatchPushOneMsgReq, opts ...grpc.CallOption) (*OnlineBatchPushOneMsgResp, error) {
func (c *relayClient) OnlineBatchPushOneMsg(ctx context.Context, in *OnlineBatchPushOneMsgReq, opts ...grpc.CallOption) (*OnlineBatchPushOneMsgResp, error) {
out := new(OnlineBatchPushOneMsgResp)
err := grpc.Invoke(ctx, "/relay.OnlineMessageRelayService/OnlineBatchPushOneMsg", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/relay.relay/OnlineBatchPushOneMsg", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *onlineMessageRelayServiceClient) SuperGroupOnlineBatchPushOneMsg(ctx context.Context, in *OnlineBatchPushOneMsgReq, opts ...grpc.CallOption) (*OnlineBatchPushOneMsgResp, error) {
func (c *relayClient) SuperGroupOnlineBatchPushOneMsg(ctx context.Context, in *OnlineBatchPushOneMsgReq, opts ...grpc.CallOption) (*OnlineBatchPushOneMsgResp, error) {
out := new(OnlineBatchPushOneMsgResp)
err := grpc.Invoke(ctx, "/relay.OnlineMessageRelayService/SuperGroupOnlineBatchPushOneMsg", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/relay.relay/SuperGroupOnlineBatchPushOneMsg", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *onlineMessageRelayServiceClient) KickUserOffline(ctx context.Context, in *KickUserOfflineReq, opts ...grpc.CallOption) (*KickUserOfflineResp, error) {
func (c *relayClient) KickUserOffline(ctx context.Context, in *KickUserOfflineReq, opts ...grpc.CallOption) (*KickUserOfflineResp, error) {
out := new(KickUserOfflineResp)
err := grpc.Invoke(ctx, "/relay.OnlineMessageRelayService/KickUserOffline", in, out, c.cc, opts...)
err := grpc.Invoke(ctx, "/relay.relay/KickUserOffline", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for OnlineMessageRelayService service
// Server API for Relay service
type OnlineMessageRelayServiceServer interface {
type RelayServer interface {
OnlinePushMsg(context.Context, *OnlinePushMsgReq) (*OnlinePushMsgResp, error)
GetUsersOnlineStatus(context.Context, *GetUsersOnlineStatusReq) (*GetUsersOnlineStatusResp, error)
OnlineBatchPushOneMsg(context.Context, *OnlineBatchPushOneMsgReq) (*OnlineBatchPushOneMsgResp, error)
@ -771,178 +771,178 @@ type OnlineMessageRelayServiceServer interface {
KickUserOffline(context.Context, *KickUserOfflineReq) (*KickUserOfflineResp, error)
}
func RegisterOnlineMessageRelayServiceServer(s *grpc.Server, srv OnlineMessageRelayServiceServer) {
s.RegisterService(&_OnlineMessageRelayService_serviceDesc, srv)
func RegisterRelayServer(s *grpc.Server, srv RelayServer) {
s.RegisterService(&_Relay_serviceDesc, srv)
}
func _OnlineMessageRelayService_OnlinePushMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Relay_OnlinePushMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(OnlinePushMsgReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OnlineMessageRelayServiceServer).OnlinePushMsg(ctx, in)
return srv.(RelayServer).OnlinePushMsg(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/relay.OnlineMessageRelayService/OnlinePushMsg",
FullMethod: "/relay.relay/OnlinePushMsg",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OnlineMessageRelayServiceServer).OnlinePushMsg(ctx, req.(*OnlinePushMsgReq))
return srv.(RelayServer).OnlinePushMsg(ctx, req.(*OnlinePushMsgReq))
}
return interceptor(ctx, in, info, handler)
}
func _OnlineMessageRelayService_GetUsersOnlineStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Relay_GetUsersOnlineStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUsersOnlineStatusReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OnlineMessageRelayServiceServer).GetUsersOnlineStatus(ctx, in)
return srv.(RelayServer).GetUsersOnlineStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/relay.OnlineMessageRelayService/GetUsersOnlineStatus",
FullMethod: "/relay.relay/GetUsersOnlineStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OnlineMessageRelayServiceServer).GetUsersOnlineStatus(ctx, req.(*GetUsersOnlineStatusReq))
return srv.(RelayServer).GetUsersOnlineStatus(ctx, req.(*GetUsersOnlineStatusReq))
}
return interceptor(ctx, in, info, handler)
}
func _OnlineMessageRelayService_OnlineBatchPushOneMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Relay_OnlineBatchPushOneMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(OnlineBatchPushOneMsgReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OnlineMessageRelayServiceServer).OnlineBatchPushOneMsg(ctx, in)
return srv.(RelayServer).OnlineBatchPushOneMsg(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/relay.OnlineMessageRelayService/OnlineBatchPushOneMsg",
FullMethod: "/relay.relay/OnlineBatchPushOneMsg",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OnlineMessageRelayServiceServer).OnlineBatchPushOneMsg(ctx, req.(*OnlineBatchPushOneMsgReq))
return srv.(RelayServer).OnlineBatchPushOneMsg(ctx, req.(*OnlineBatchPushOneMsgReq))
}
return interceptor(ctx, in, info, handler)
}
func _OnlineMessageRelayService_SuperGroupOnlineBatchPushOneMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Relay_SuperGroupOnlineBatchPushOneMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(OnlineBatchPushOneMsgReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OnlineMessageRelayServiceServer).SuperGroupOnlineBatchPushOneMsg(ctx, in)
return srv.(RelayServer).SuperGroupOnlineBatchPushOneMsg(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/relay.OnlineMessageRelayService/SuperGroupOnlineBatchPushOneMsg",
FullMethod: "/relay.relay/SuperGroupOnlineBatchPushOneMsg",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OnlineMessageRelayServiceServer).SuperGroupOnlineBatchPushOneMsg(ctx, req.(*OnlineBatchPushOneMsgReq))
return srv.(RelayServer).SuperGroupOnlineBatchPushOneMsg(ctx, req.(*OnlineBatchPushOneMsgReq))
}
return interceptor(ctx, in, info, handler)
}
func _OnlineMessageRelayService_KickUserOffline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Relay_KickUserOffline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(KickUserOfflineReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OnlineMessageRelayServiceServer).KickUserOffline(ctx, in)
return srv.(RelayServer).KickUserOffline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/relay.OnlineMessageRelayService/KickUserOffline",
FullMethod: "/relay.relay/KickUserOffline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OnlineMessageRelayServiceServer).KickUserOffline(ctx, req.(*KickUserOfflineReq))
return srv.(RelayServer).KickUserOffline(ctx, req.(*KickUserOfflineReq))
}
return interceptor(ctx, in, info, handler)
}
var _OnlineMessageRelayService_serviceDesc = grpc.ServiceDesc{
ServiceName: "relay.OnlineMessageRelayService",
HandlerType: (*OnlineMessageRelayServiceServer)(nil),
var _Relay_serviceDesc = grpc.ServiceDesc{
ServiceName: "relay.relay",
HandlerType: (*RelayServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "OnlinePushMsg",
Handler: _OnlineMessageRelayService_OnlinePushMsg_Handler,
Handler: _Relay_OnlinePushMsg_Handler,
},
{
MethodName: "GetUsersOnlineStatus",
Handler: _OnlineMessageRelayService_GetUsersOnlineStatus_Handler,
Handler: _Relay_GetUsersOnlineStatus_Handler,
},
{
MethodName: "OnlineBatchPushOneMsg",
Handler: _OnlineMessageRelayService_OnlineBatchPushOneMsg_Handler,
Handler: _Relay_OnlineBatchPushOneMsg_Handler,
},
{
MethodName: "SuperGroupOnlineBatchPushOneMsg",
Handler: _OnlineMessageRelayService_SuperGroupOnlineBatchPushOneMsg_Handler,
Handler: _Relay_SuperGroupOnlineBatchPushOneMsg_Handler,
},
{
MethodName: "KickUserOffline",
Handler: _OnlineMessageRelayService_KickUserOffline_Handler,
Handler: _Relay_KickUserOffline_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "relay/relay.proto",
}
func init() { proto.RegisterFile("relay/relay.proto", fileDescriptor_relay_eb517eee82ca0aca) }
func init() { proto.RegisterFile("relay/relay.proto", fileDescriptor_relay_9ac412c3c8c99f28) }
var fileDescriptor_relay_eb517eee82ca0aca = []byte{
// 749 bytes of a gzipped FileDescriptorProto
var fileDescriptor_relay_9ac412c3c8c99f28 = []byte{
// 737 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x4e, 0xdb, 0x5a,
0x10, 0x96, 0x31, 0xe1, 0x67, 0x80, 0x0b, 0x9c, 0x0b, 0x17, 0xe3, 0x45, 0xc8, 0xf5, 0xe2, 0x2a,
0xba, 0x6a, 0x13, 0x29, 0xed, 0xae, 0x3b, 0x88, 0xa0, 0x51, 0x89, 0x82, 0x4e, 0x5a, 0xb5, 0x62,
0x13, 0x99, 0xe4, 0x24, 0x58, 0x71, 0xe2, 0xc3, 0x19, 0x1b, 0xc4, 0xa6, 0xdb, 0xee, 0xfa, 0x08,
0x5d, 0xf4, 0x25, 0xfa, 0x02, 0x7d, 0xb0, 0xea, 0xfc, 0xc4, 0xb5, 0xf3, 0x03, 0x65, 0xc1, 0x06,
0x31, 0x73, 0xe6, 0xcc, 0xcc, 0xf7, 0x7d, 0x73, 0x26, 0x86, 0x5d, 0xc1, 0x42, 0xff, 0xbe, 0xaa,
0xfe, 0x56, 0xb8, 0x88, 0xe2, 0x88, 0x14, 0x94, 0xe1, 0xfe, 0xdb, 0xe2, 0x6c, 0xdc, 0x69, 0x34,
0xab, 0x7c, 0x38, 0xa8, 0xaa, 0x93, 0x2a, 0xf6, 0x86, 0x9d, 0x3b, 0xac, 0xde, 0xa1, 0x8e, 0xf4,
0xbe, 0x5a, 0xb0, 0xd3, 0x1a, 0x87, 0xc1, 0x98, 0x5d, 0x24, 0x78, 0xdd, 0xc4, 0x01, 0x65, 0x37,
0xa4, 0x04, 0x1b, 0x2d, 0xce, 0x84, 0x1f, 0x07, 0xd1, 0xb8, 0x51, 0x77, 0xac, 0x92, 0x55, 0x5e,
0xa7, 0x59, 0x17, 0x79, 0x0d, 0xab, 0x23, 0x1c, 0xd4, 0xfd, 0xd8, 0x77, 0x96, 0x4a, 0x56, 0x79,
0xa3, 0xe6, 0x56, 0x90, 0x89, 0x5b, 0x26, 0x3a, 0x3e, 0x0f, 0x3a, 0xdc, 0x17, 0xfe, 0x08, 0x2b,
0x4d, 0x1d, 0x41, 0x27, 0xa1, 0xc4, 0x83, 0x4d, 0x9e, 0xe0, 0xf5, 0xfb, 0xe8, 0x03, 0x32, 0xd1,
0xa8, 0x3b, 0xb6, 0x4a, 0x9c, 0xf3, 0x79, 0x67, 0xb0, 0x3b, 0xd5, 0x0f, 0x72, 0x52, 0x83, 0x65,
0xc1, 0x90, 0x3b, 0x56, 0xc9, 0x2e, 0x6f, 0xd4, 0x8a, 0x15, 0x8d, 0xb5, 0x1d, 0x8c, 0x07, 0x21,
0x6b, 0xe2, 0x40, 0x5f, 0xbe, 0x08, 0xfd, 0xb8, 0x1f, 0x89, 0x11, 0x55, 0xb1, 0xde, 0x17, 0x0b,
0x0e, 0x65, 0x04, 0x0b, 0xd3, 0x08, 0xca, 0x30, 0x09, 0xe3, 0xf3, 0x00, 0x63, 0xf2, 0x0f, 0xac,
0x24, 0xba, 0x09, 0x8d, 0xce, 0x58, 0x69, 0xa5, 0xa5, 0x3f, 0xaf, 0x44, 0x8a, 0x00, 0x51, 0xda,
0xb2, 0x02, 0xb5, 0x46, 0x33, 0x1e, 0xef, 0x9b, 0x05, 0x8e, 0xc6, 0x74, 0xec, 0xc7, 0xdd, 0x6b,
0xe9, 0x6b, 0x8d, 0xd9, 0x33, 0x73, 0xfd, 0x3f, 0xec, 0x64, 0x79, 0x95, 0xa0, 0x1d, 0xbb, 0x64,
0x97, 0xd7, 0xe9, 0x8c, 0xdf, 0x0b, 0xe0, 0x70, 0x41, 0x7f, 0xc8, 0xc9, 0x39, 0xec, 0xa0, 0x82,
0x2f, 0xfd, 0x9a, 0x41, 0xa3, 0x43, 0x29, 0xc3, 0xce, 0x5c, 0x96, 0xe9, 0xcc, 0x4d, 0xef, 0x1e,
0x0e, 0x16, 0x90, 0x29, 0x69, 0xd4, 0x41, 0x27, 0x51, 0x8f, 0x29, 0x22, 0x6c, 0x9a, 0xf1, 0x48,
0xc9, 0x28, 0xeb, 0xde, 0x36, 0xea, 0x8a, 0x86, 0x75, 0x6a, 0x2c, 0xf2, 0x1f, 0xfc, 0x25, 0xff,
0x93, 0x79, 0x4e, 0x23, 0x31, 0x32, 0x73, 0x55, 0xa0, 0x53, 0x5e, 0xef, 0x0e, 0x0e, 0xce, 0x58,
0x2c, 0x4b, 0xa2, 0x46, 0xdb, 0x8e, 0xfd, 0x38, 0x41, 0x29, 0x42, 0x11, 0x20, 0xf9, 0x4d, 0x93,
0xa5, 0x68, 0xca, 0x78, 0xa4, 0x48, 0x51, 0x46, 0x24, 0x5d, 0x3f, 0xeb, 0x22, 0x2e, 0xac, 0x45,
0x3c, 0x37, 0xd6, 0xa9, 0xed, 0xfd, 0x58, 0x06, 0x67, 0x7e, 0x65, 0xe4, 0xc4, 0x81, 0x55, 0x26,
0x44, 0x0a, 0xb9, 0x40, 0x27, 0xa6, 0xc4, 0xcb, 0x84, 0x68, 0xe2, 0x60, 0x82, 0x57, 0x5b, 0xa4,
0x0d, 0x5b, 0x98, 0x74, 0xbb, 0x0c, 0xd1, 0xa8, 0x61, 0x2b, 0x35, 0x5e, 0x1a, 0x35, 0x16, 0x55,
0xaa, 0xb4, 0xb3, 0x97, 0x68, 0x3e, 0x07, 0xb9, 0x80, 0xcd, 0xbe, 0x1f, 0x84, 0xac, 0x67, 0x72,
0x2e, 0xab, 0x9c, 0x2f, 0x1e, 0xcb, 0x79, 0xaa, 0xee, 0xd4, 0x59, 0xec, 0x07, 0x21, 0xcd, 0x65,
0x70, 0x4f, 0x60, 0xcb, 0x54, 0xd4, 0xc7, 0x92, 0x22, 0x6e, 0xb4, 0x36, 0x63, 0x9e, 0xda, 0x12,
0x2b, 0xaa, 0xac, 0x13, 0xac, 0xda, 0x72, 0x3f, 0xc1, 0x66, 0xb6, 0x44, 0xe6, 0xd9, 0xda, 0xb9,
0x67, 0xfb, 0x64, 0x16, 0xdd, 0xef, 0x56, 0xda, 0x9f, 0xa1, 0x60, 0xd1, 0x4a, 0x58, 0xd0, 0x1b,
0xf1, 0x61, 0xaf, 0xa7, 0xba, 0x9a, 0x4c, 0xb0, 0xe6, 0xe5, 0x89, 0x72, 0x18, 0xee, 0xe6, 0xa6,
0xf2, 0x3e, 0x03, 0x79, 0x17, 0x74, 0x87, 0x32, 0x41, 0xab, 0xdf, 0x97, 0x09, 0xcc, 0xca, 0x88,
0x66, 0x57, 0x46, 0x76, 0x1a, 0x8b, 0x00, 0x13, 0x6a, 0xcd, 0xb8, 0x16, 0x68, 0xc6, 0x23, 0x9f,
0xcc, 0xd0, 0xe4, 0xcd, 0xad, 0x86, 0x29, 0xaf, 0xb7, 0x0f, 0x7f, 0xcf, 0xd4, 0x47, 0x5e, 0xfb,
0x69, 0x4f, 0x16, 0x46, 0x93, 0x21, 0xfa, 0x03, 0x46, 0x25, 0xd4, 0x36, 0x13, 0xb7, 0x41, 0x97,
0x91, 0x63, 0xd8, 0xca, 0x6d, 0x70, 0x72, 0x60, 0xa8, 0x98, 0xfe, 0x9d, 0x71, 0x9d, 0xf9, 0x07,
0xc8, 0xc9, 0x47, 0xd8, 0x9b, 0x47, 0x1c, 0x29, 0x3e, 0xc8, 0xea, 0x8d, 0x7b, 0xf4, 0x08, 0xeb,
0xe4, 0x12, 0xf6, 0xe7, 0xae, 0x3a, 0x72, 0x94, 0xeb, 0x65, 0x76, 0x51, 0xbb, 0xa5, 0x87, 0x03,
0x90, 0x93, 0x1e, 0x1c, 0xb5, 0x13, 0xce, 0xc4, 0x99, 0x88, 0x12, 0xfe, 0x6c, 0x55, 0xde, 0xc2,
0xf6, 0x94, 0x26, 0xe4, 0xd0, 0x5c, 0x9a, 0x9d, 0x15, 0xd7, 0x5d, 0x74, 0x84, 0xfc, 0x78, 0xf7,
0x72, 0xbb, 0xa2, 0x3f, 0x1b, 0xde, 0xf0, 0x2b, 0x25, 0xe1, 0xd5, 0x8a, 0xfa, 0x2a, 0x78, 0xf5,
0x2b, 0x00, 0x00, 0xff, 0xff, 0x01, 0x6a, 0x94, 0x1f, 0x54, 0x08, 0x00, 0x00,
0x5d, 0xf4, 0x09, 0xba, 0xeb, 0xeb, 0x55, 0xe7, 0x27, 0xae, 0x9d, 0x1f, 0x28, 0x0b, 0x36, 0x90,
0x99, 0x33, 0xe7, 0x9b, 0xf9, 0xbe, 0x19, 0x8f, 0x0d, 0xbb, 0x82, 0x85, 0xfe, 0x7d, 0x55, 0xfd,
0xad, 0x70, 0x11, 0xc5, 0x11, 0x29, 0x28, 0xc3, 0xfd, 0xb7, 0xc5, 0xd9, 0xb8, 0xd3, 0x68, 0x56,
0xf9, 0x70, 0x50, 0x55, 0x27, 0x55, 0xec, 0x0d, 0x3b, 0x77, 0x58, 0xbd, 0x43, 0x1d, 0xe9, 0x7d,
0xb5, 0x60, 0xa7, 0x35, 0x0e, 0x83, 0x31, 0xbb, 0x48, 0xf0, 0xba, 0x89, 0x03, 0xca, 0x6e, 0x48,
0x09, 0x36, 0x5a, 0x9c, 0x09, 0x3f, 0x0e, 0xa2, 0x71, 0xa3, 0xee, 0x58, 0x25, 0xab, 0xbc, 0x4e,
0xb3, 0x2e, 0xf2, 0x1a, 0x56, 0x47, 0x38, 0xa8, 0xfb, 0xb1, 0xef, 0x2c, 0x95, 0xac, 0xf2, 0x46,
0xcd, 0xad, 0x20, 0x13, 0xb7, 0x4c, 0x74, 0x7c, 0x1e, 0x74, 0xb8, 0x2f, 0xfc, 0x11, 0x56, 0x9a,
0x3a, 0x82, 0x4e, 0x42, 0x89, 0x07, 0x9b, 0x3c, 0xc1, 0xeb, 0xf7, 0xd1, 0x07, 0x64, 0xa2, 0x51,
0x77, 0x6c, 0x05, 0x9c, 0xf3, 0x79, 0x67, 0xb0, 0x3b, 0x55, 0x0f, 0x72, 0x52, 0x83, 0x65, 0xc1,
0x90, 0x3b, 0x56, 0xc9, 0x2e, 0x6f, 0xd4, 0x8a, 0x15, 0xcd, 0xb5, 0x1d, 0x8c, 0x07, 0x21, 0x6b,
0xe2, 0x40, 0x5f, 0xbe, 0x08, 0xfd, 0xb8, 0x1f, 0x89, 0x11, 0x55, 0xb1, 0xde, 0x17, 0x0b, 0x0e,
0x65, 0x04, 0x0b, 0xd3, 0x08, 0xca, 0x30, 0x09, 0xe3, 0xf3, 0x00, 0x63, 0xf2, 0x0f, 0xac, 0x24,
0xba, 0x08, 0xcd, 0xce, 0x58, 0x69, 0xa6, 0xa5, 0x3f, 0xcf, 0x44, 0x8a, 0x00, 0x51, 0x5a, 0xb2,
0x22, 0xb5, 0x46, 0x33, 0x1e, 0xef, 0x9b, 0x05, 0x8e, 0xe6, 0x74, 0xec, 0xc7, 0xdd, 0x6b, 0xe9,
0x6b, 0x8d, 0xd9, 0x33, 0x6b, 0xfd, 0x3f, 0xec, 0x64, 0x75, 0x95, 0xa4, 0x1d, 0xbb, 0x64, 0x97,
0xd7, 0xe9, 0x8c, 0xdf, 0x0b, 0xe0, 0x70, 0x41, 0x7d, 0xc8, 0xc9, 0x39, 0xec, 0xa0, 0xa2, 0x2f,
0xfd, 0x5a, 0x41, 0xd3, 0x87, 0x52, 0x46, 0x9d, 0xb9, 0x2a, 0xd3, 0x99, 0x9b, 0xde, 0x3d, 0x1c,
0x2c, 0x10, 0x53, 0xca, 0xa8, 0x83, 0x4e, 0xa2, 0x1e, 0x53, 0x42, 0xd8, 0x34, 0xe3, 0x91, 0x2d,
0xa3, 0xac, 0x7b, 0xdb, 0xa8, 0x2b, 0x19, 0xd6, 0xa9, 0xb1, 0xc8, 0x7f, 0xf0, 0x97, 0xfc, 0x25,
0x71, 0x4e, 0x23, 0x31, 0x32, 0x73, 0x55, 0xa0, 0x53, 0x5e, 0xef, 0x0e, 0x0e, 0xce, 0x58, 0x2c,
0x53, 0xa2, 0x66, 0xdb, 0x8e, 0xfd, 0x38, 0x41, 0xd9, 0x84, 0x22, 0x40, 0xf2, 0x5b, 0x26, 0x4b,
0xc9, 0x94, 0xf1, 0xc8, 0x26, 0x45, 0x99, 0x26, 0xe9, 0xfc, 0x59, 0x17, 0x71, 0x61, 0x2d, 0xe2,
0xb9, 0xb1, 0x4e, 0x6d, 0xef, 0xe7, 0x32, 0x38, 0xf3, 0x33, 0x23, 0x27, 0x0e, 0xac, 0x32, 0x21,
0x52, 0xca, 0x05, 0x3a, 0x31, 0x25, 0x5f, 0x26, 0x44, 0x13, 0x07, 0x13, 0xbe, 0xda, 0x22, 0x6d,
0xd8, 0xc2, 0xa4, 0xdb, 0x65, 0x88, 0xa6, 0x1b, 0xb6, 0xea, 0xc6, 0x4b, 0xd3, 0x8d, 0x45, 0x99,
0x2a, 0xed, 0xec, 0x25, 0x9a, 0xc7, 0x20, 0x17, 0xb0, 0xd9, 0xf7, 0x83, 0x90, 0xf5, 0x0c, 0xe6,
0xb2, 0xc2, 0x7c, 0xf1, 0x18, 0xe6, 0xa9, 0xba, 0x53, 0x67, 0xb1, 0x1f, 0x84, 0x34, 0x87, 0xe0,
0x9e, 0xc0, 0x96, 0xc9, 0xa8, 0x8f, 0xa5, 0x44, 0xdc, 0xf4, 0xda, 0x8c, 0x79, 0x6a, 0x4b, 0xae,
0xa8, 0x50, 0x27, 0x5c, 0xb5, 0xe5, 0x7e, 0x82, 0xcd, 0x6c, 0x8a, 0xcc, 0x63, 0x6b, 0xe7, 0x1e,
0xdb, 0x27, 0xab, 0xe8, 0x7e, 0xb7, 0xd2, 0xfa, 0x8c, 0x04, 0x8b, 0x56, 0xc2, 0x82, 0xda, 0x88,
0x0f, 0x7b, 0x3d, 0x55, 0xd5, 0x64, 0x82, 0xb5, 0x2e, 0x4f, 0x6c, 0x87, 0xd1, 0x6e, 0x2e, 0x94,
0xf7, 0x19, 0xc8, 0xbb, 0xa0, 0x3b, 0x94, 0x00, 0xad, 0x7e, 0x5f, 0x02, 0x98, 0x95, 0x11, 0xcd,
0xae, 0x8c, 0xec, 0x34, 0x16, 0x01, 0x26, 0xd2, 0x9a, 0x71, 0x2d, 0xd0, 0x8c, 0x47, 0x3e, 0x32,
0x43, 0x83, 0x9b, 0x5b, 0x0d, 0x53, 0x5e, 0x6f, 0x1f, 0xfe, 0x9e, 0xc9, 0x8f, 0xbc, 0xf6, 0xc3,
0x06, 0xfd, 0x86, 0x21, 0xc7, 0xb0, 0x95, 0xdb, 0xd6, 0xe4, 0xc0, 0xd0, 0x9e, 0x7e, 0xa7, 0xb8,
0xce, 0xfc, 0x03, 0xe4, 0xe4, 0x23, 0xec, 0xcd, 0x13, 0x89, 0x14, 0x1f, 0x54, 0xf0, 0xc6, 0x3d,
0x7a, 0x44, 0x61, 0x72, 0x09, 0xfb, 0x73, 0xd7, 0x1a, 0x39, 0xca, 0xd5, 0x32, 0xbb, 0x94, 0xdd,
0xd2, 0xc3, 0x01, 0xc8, 0x49, 0x0f, 0x8e, 0xda, 0x09, 0x67, 0xe2, 0x4c, 0x44, 0x09, 0x7f, 0xb6,
0x2c, 0x6f, 0x61, 0x7b, 0x4a, 0x7f, 0x72, 0x68, 0x2e, 0xcd, 0xce, 0x85, 0xeb, 0x2e, 0x3a, 0x42,
0x7e, 0xbc, 0x7b, 0xb9, 0x5d, 0xd1, 0x9f, 0x08, 0x6f, 0xf8, 0x15, 0x95, 0xff, 0xaf, 0x56, 0xd4,
0x17, 0xc0, 0xab, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x08, 0x9a, 0x1f, 0x1c, 0x40, 0x08, 0x00,
0x00,
}

2
pkg/proto/relay/relay.proto
View File

@ -76,7 +76,7 @@ int32 platformID = 2;
message KickUserOfflineResp{
}
service OnlineMessageRelayService {
service relay {
rpc OnlinePushMsg(OnlinePushMsgReq) returns(OnlinePushMsgResp);
rpc GetUsersOnlineStatus(GetUsersOnlineStatusReq)returns(GetUsersOnlineStatusResp);
rpc OnlineBatchPushOneMsg(OnlineBatchPushOneMsgReq) returns(OnlineBatchPushOneMsgResp);

4
pkg/utils/strings.go
View File

@ -33,6 +33,10 @@ func Int32ToString(i int32) string {
return strconv.FormatInt(int64(i), 10)
}
func Uint32ToString(i uint32) string {
return strconv.FormatInt(int64(i), 10)
}
//judge a string whether in the string list
func IsContain(target string, List []string) bool {
for _, element := range List {