msb-public
/
Open-IM-Server
mirror of https://github.com/OpenIMSDK/Open-IM-Server
2
0
Code Issues Projects Releases Wiki Activity

Adjust error code

Browse Source
pull/258/head
wenxu12345 2 years ago
parent 4c53023ebc
commit 6a19c8130c
7 changed files with 323 additions and 69 deletions
Show Stats Download Patch File Download Diff File

4
internal/api/auth/auth.go
Unescape View File

@ -150,7 +150,7 @@ func ParseToken(c *gin.Context) {
if err := c.BindJSON(&params); err != nil {
errMsg := " BindJSON failed " + err.Error()
log.NewError("0", errMsg)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
c.JSON(http.StatusBadRequest, gin.H{"errCode": 200, "errMsg": errMsg})
return
}
@ -161,7 +161,7 @@ func ParseToken(c *gin.Context) {
if !ok {
errMsg := params.OperationID + " " + "GetUserIDFromTokenExpireTime failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(params.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 200, "errMsg": errMsg})
return
}

3
internal/msg_gateway/gate/logic.go
Unescape View File

@ -52,6 +52,9 @@ func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) {
case constant.WSPullMsgBySeqList:
log.NewInfo(m.OperationID, "pullMsgBySeqListReq ", m.SendID, m.MsgIncr, m.ReqIdentifier)
ws.pullMsgBySeqListReq(conn, &m)
case constant.WsLogoutMsg:
log.NewInfo(m.OperationID, "conn.Close()", m.SendID, m.MsgIncr, m.ReqIdentifier)
conn.Close()
default:
log.Error(m.OperationID, "ReqIdentifier failed ", m.SendID, m.MsgIncr, m.ReqIdentifier)
}

7
internal/msg_gateway/gate/relay_rpc_server.go
Unescape View File

@ -28,6 +28,7 @@ type RPCServer struct {
etcdAddr []string
platformList []int
pushTerminal []int
target string
}
func (r *RPCServer) onInit(rpcPort int) {
@ -66,6 +67,7 @@ func (r *RPCServer) run() {
if err != nil {
log.Error("", "register push message rpc to etcd err", "", "err", err.Error(), r.etcdSchema, strings.Join(r.etcdAddr, ","), rpcRegisterIP, r.rpcPort, r.rpcRegisterName)
}
r.target = getcdv3.GetTarget(r.etcdSchema, rpcRegisterIP, r.rpcPort, r.rpcRegisterName)
err = srv.Serve(listener)
if err != nil {
log.Error("", "push message rpc listening err", "", "err", err.Error())
@ -301,6 +303,11 @@ func (r *RPCServer) KickUserOffline(_ context.Context, req *pbRelay.KickUserOffl
return &pbRelay.KickUserOfflineResp{}, nil
}
func (r *RPCServer) MultiTerminalLoginCheck(ctx context.Context, req *pbRelay.MultiTerminalLoginCheckReq) (*pbRelay.MultiTerminalLoginCheckResp, error) {
ws.MultiTerminalLoginCheckerWithLock(req.UserID, int(req.PlatformID), req.Token, req.OperationID)
return &pbRelay.MultiTerminalLoginCheckResp{}, nil
}
func sendMsgToUser(conn *UserConn, bMsg []byte, in *pbRelay.OnlinePushMsgReq, RecvPlatForm int, RecvID string) (ResultCode int64) {
err := ws.writeMsg(conn, websocket.BinaryMessage, bMsg)
if err != nil {

78
internal/msg_gateway/gate/ws_server.go
Unescape View File

@ -6,11 +6,15 @@ import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbRelay "Open_IM/pkg/proto/relay"
"Open_IM/pkg/utils"
"bytes"
"context"
"encoding/gob"
go_redis "github.com/go-redis/redis/v8"
"github.com/pkg/errors"
"strings"
//"gopkg.in/errgo.v2/errors"
"net/http"
@ -113,6 +117,79 @@ func (ws *WServer) SetWriteTimeoutWriteMsg(conn *UserConn, a int, msg []byte, ti
conn.SetWriteDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
return conn.WriteMessage(a, msg)
}
func (ws *WServer) MultiTerminalLoginRemoteChecker(userID string, platformID int32, token string, operationID string) {
grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImRelayName)
for _, v := range grpcCons {
if v.Target() == rpcSvr.target {
log.Debug(operationID, "Filter out this node ", rpcSvr.target)
continue
}
client := pbRelay.NewRelayClient(v)
req := &pbRelay.MultiTerminalLoginCheckReq{OperationID: operationID, PlatformID: platformID, UserID: userID, Token: token}
log.NewInfo(operationID, "MultiTerminalLoginCheckReq ", client, req.String())
resp, err := client.MultiTerminalLoginCheck(context.Background(), req)
if err != nil {
log.Error(operationID, "MultiTerminalLoginCheck failed ", err.Error())
}
if resp.ErrCode != 0 {
log.Error(operationID, "MultiTerminalLoginCheck errCode, errMsg: ", resp.ErrCode, resp.ErrMsg)
}
}
}
func (ws *WServer) MultiTerminalLoginCheckerWithLock(uid string, platformID int, token string, operationID string) {
rwLock.Lock()
defer rwLock.Unlock()
switch config.Config.MultiLoginPolicy {
case constant.AllLoginButSameTermKick:
if oldConnMap, ok := ws.wsUserToConn[uid]; ok { // user->map[platform->conn]
if oldConn, ok := oldConnMap[platformID]; ok {
log.NewDebug(operationID, uid, platformID, "kick old conn")
m, err := db.DB.GetTokenMapByUidPid(uid, constant.PlatformIDToName(platformID))
if err != nil && err != go_redis.Nil {
log.NewError(operationID, "get token from redis err", err.Error(), uid, constant.PlatformIDToName(platformID))
return
}
if m == nil {
log.NewError(operationID, "get token from redis err", "m is nil", uid, constant.PlatformIDToName(platformID))
return
}
log.NewDebug(operationID, "get token map is ", m, uid, constant.PlatformIDToName(platformID))
for k, _ := range m {
if k != token {
m[k] = constant.KickedToken
}
}
log.NewDebug(operationID, "set token map is ", m, uid, constant.PlatformIDToName(platformID))
err = db.DB.SetTokenMapByUidPid(uid, platformID, m)
if err != nil {
log.NewError(operationID, "SetTokenMapByUidPid err", err.Error(), uid, platformID, m)
return
}
err = oldConn.Close()
delete(oldConnMap, platformID)
ws.wsUserToConn[uid] = oldConnMap
if len(oldConnMap) == 0 {
delete(ws.wsUserToConn, uid)
}
delete(ws.wsConnToUser, oldConn)
if err != nil {
log.NewError(operationID, "conn close err", err.Error(), uid, platformID)
}
} else {
log.NewWarn(operationID, "abnormal uid-conn ", uid, platformID, oldConnMap[platformID])
}
} else {
log.NewDebug(operationID, "no other conn", ws.wsUserToConn, uid, platformID)
}
case constant.SingleTerminalLogin:
case constant.WebAndOther:
}
}
func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int, newConn *UserConn, token string, operationID string) {
switch config.Config.MultiLoginPolicy {
case constant.AllLoginButSameTermKick:
@ -191,6 +268,7 @@ func (ws *WServer) addUserConn(uid string, platformID int, conn *UserConn, token
if callbackResp.ErrCode != 0 {
log.NewError(operationID, utils.GetSelfFuncName(), "callbackUserOnline resp:", callbackResp)
}
go ws.MultiTerminalLoginRemoteChecker(uid, int32(platformID), token, operationID)
ws.MultiTerminalLoginChecker(uid, platformID, conn, token, operationID)
if oldConnMap, ok := ws.wsUserToConn[uid]; ok {
oldConnMap[platformID] = conn

5
pkg/grpc-etcdv3/getcdv3/register.go
Unescape View File

@ -37,6 +37,11 @@ func RegisterEtcd4Unique(schema, etcdAddr, myHost string, myPort int, serviceNam
return RegisterEtcd(schema, etcdAddr, myHost, myPort, serviceName, ttl)
}
func GetTarget(schema, myHost string, myPort int, serviceName string) string {
serviceName = serviceName + ":" + net.JoinHostPort(myHost, strconv.Itoa(myPort))
return serviceName
}
//etcdAddr separated by commas
func RegisterEtcd(schema, etcdAddr, myHost string, myPort int, serviceName string, ttl int) error {
operationID := utils.OperationIDGenerator()

275
pkg/proto/relay/relay.pb.go
Unescape 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_9ac412c3c8c99f28, []int{0}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{1}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{2}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{3}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{4}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{5}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{6}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{7}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{7, 0}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{7, 1}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{7, 2}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{8}
return fileDescriptor_relay_e9fd8824fb6cabec, []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_9ac412c3c8c99f28, []int{9}
return fileDescriptor_relay_e9fd8824fb6cabec, []int{9}
}
func (m *KickUserOfflineResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_KickUserOfflineResp.Unmarshal(m, b)
@ -674,6 +674,114 @@ func (m *KickUserOfflineResp) XXX_DiscardUnknown() {
var xxx_messageInfo_KickUserOfflineResp proto.InternalMessageInfo
type MultiTerminalLoginCheckReq struct {
UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
PlatformID int32 `protobuf:"varint,2,opt,name=platformID" json:"platformID,omitempty"`
Token string `protobuf:"bytes,3,opt,name=token" json:"token,omitempty"`
OperationID string `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MultiTerminalLoginCheckReq) Reset() { *m = MultiTerminalLoginCheckReq{} }
func (m *MultiTerminalLoginCheckReq) String() string { return proto.CompactTextString(m) }
func (*MultiTerminalLoginCheckReq) ProtoMessage() {}
func (*MultiTerminalLoginCheckReq) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_e9fd8824fb6cabec, []int{10}
}
func (m *MultiTerminalLoginCheckReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MultiTerminalLoginCheckReq.Unmarshal(m, b)
}
func (m *MultiTerminalLoginCheckReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MultiTerminalLoginCheckReq.Marshal(b, m, deterministic)
}
func (dst *MultiTerminalLoginCheckReq) XXX_Merge(src proto.Message) {
xxx_messageInfo_MultiTerminalLoginCheckReq.Merge(dst, src)
}
func (m *MultiTerminalLoginCheckReq) XXX_Size() int {
return xxx_messageInfo_MultiTerminalLoginCheckReq.Size(m)
}
func (m *MultiTerminalLoginCheckReq) XXX_DiscardUnknown() {
xxx_messageInfo_MultiTerminalLoginCheckReq.DiscardUnknown(m)
}
var xxx_messageInfo_MultiTerminalLoginCheckReq proto.InternalMessageInfo
func (m *MultiTerminalLoginCheckReq) GetUserID() string {
if m != nil {
return m.UserID
}
return ""
}
func (m *MultiTerminalLoginCheckReq) GetPlatformID() int32 {
if m != nil {
return m.PlatformID
}
return 0
}
func (m *MultiTerminalLoginCheckReq) GetToken() string {
if m != nil {
return m.Token
}
return ""
}
func (m *MultiTerminalLoginCheckReq) GetOperationID() string {
if m != nil {
return m.OperationID
}
return ""
}
type MultiTerminalLoginCheckResp 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 *MultiTerminalLoginCheckResp) Reset() { *m = MultiTerminalLoginCheckResp{} }
func (m *MultiTerminalLoginCheckResp) String() string { return proto.CompactTextString(m) }
func (*MultiTerminalLoginCheckResp) ProtoMessage() {}
func (*MultiTerminalLoginCheckResp) Descriptor() ([]byte, []int) {
return fileDescriptor_relay_e9fd8824fb6cabec, []int{11}
}
func (m *MultiTerminalLoginCheckResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MultiTerminalLoginCheckResp.Unmarshal(m, b)
}
func (m *MultiTerminalLoginCheckResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MultiTerminalLoginCheckResp.Marshal(b, m, deterministic)
}
func (dst *MultiTerminalLoginCheckResp) XXX_Merge(src proto.Message) {
xxx_messageInfo_MultiTerminalLoginCheckResp.Merge(dst, src)
}
func (m *MultiTerminalLoginCheckResp) XXX_Size() int {
return xxx_messageInfo_MultiTerminalLoginCheckResp.Size(m)
}
func (m *MultiTerminalLoginCheckResp) XXX_DiscardUnknown() {
xxx_messageInfo_MultiTerminalLoginCheckResp.DiscardUnknown(m)
}
var xxx_messageInfo_MultiTerminalLoginCheckResp proto.InternalMessageInfo
func (m *MultiTerminalLoginCheckResp) GetErrCode() int32 {
if m != nil {
return m.ErrCode
}
return 0
}
func (m *MultiTerminalLoginCheckResp) GetErrMsg() string {
if m != nil {
return m.ErrMsg
}
return ""
}
func init() {
proto.RegisterType((*OnlinePushMsgReq)(nil), "relay.OnlinePushMsgReq")
proto.RegisterType((*OnlinePushMsgResp)(nil), "relay.OnlinePushMsgResp")
@ -688,6 +796,8 @@ func init() {
proto.RegisterType((*GetUsersOnlineStatusResp_SuccessResult)(nil), "relay.GetUsersOnlineStatusResp.SuccessResult")
proto.RegisterType((*KickUserOfflineReq)(nil), "relay.KickUserOfflineReq")
proto.RegisterType((*KickUserOfflineResp)(nil), "relay.KickUserOfflineResp")
proto.RegisterType((*MultiTerminalLoginCheckReq)(nil), "relay.MultiTerminalLoginCheckReq")
proto.RegisterType((*MultiTerminalLoginCheckResp)(nil), "relay.MultiTerminalLoginCheckResp")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -706,6 +816,7 @@ type RelayClient interface {
OnlineBatchPushOneMsg(ctx context.Context, in *OnlineBatchPushOneMsgReq, opts ...grpc.CallOption) (*OnlineBatchPushOneMsgResp, error)
SuperGroupOnlineBatchPushOneMsg(ctx context.Context, in *OnlineBatchPushOneMsgReq, opts ...grpc.CallOption) (*OnlineBatchPushOneMsgResp, error)
KickUserOffline(ctx context.Context, in *KickUserOfflineReq, opts ...grpc.CallOption) (*KickUserOfflineResp, error)
MultiTerminalLoginCheck(ctx context.Context, in *MultiTerminalLoginCheckReq, opts ...grpc.CallOption) (*MultiTerminalLoginCheckResp, error)
}
type relayClient struct {
@ -761,6 +872,15 @@ func (c *relayClient) KickUserOffline(ctx context.Context, in *KickUserOfflineRe
return out, nil
}
func (c *relayClient) MultiTerminalLoginCheck(ctx context.Context, in *MultiTerminalLoginCheckReq, opts ...grpc.CallOption) (*MultiTerminalLoginCheckResp, error) {
out := new(MultiTerminalLoginCheckResp)
err := grpc.Invoke(ctx, "/relay.relay/MultiTerminalLoginCheck", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Relay service
type RelayServer interface {
@ -769,6 +889,7 @@ type RelayServer interface {
OnlineBatchPushOneMsg(context.Context, *OnlineBatchPushOneMsgReq) (*OnlineBatchPushOneMsgResp, error)
SuperGroupOnlineBatchPushOneMsg(context.Context, *OnlineBatchPushOneMsgReq) (*OnlineBatchPushOneMsgResp, error)
KickUserOffline(context.Context, *KickUserOfflineReq) (*KickUserOfflineResp, error)
MultiTerminalLoginCheck(context.Context, *MultiTerminalLoginCheckReq) (*MultiTerminalLoginCheckResp, error)
}
func RegisterRelayServer(s *grpc.Server, srv RelayServer) {
@ -865,6 +986,24 @@ func _Relay_KickUserOffline_Handler(srv interface{}, ctx context.Context, dec fu
return interceptor(ctx, in, info, handler)
}
func _Relay_MultiTerminalLoginCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MultiTerminalLoginCheckReq)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RelayServer).MultiTerminalLoginCheck(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/relay.relay/MultiTerminalLoginCheck",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RelayServer).MultiTerminalLoginCheck(ctx, req.(*MultiTerminalLoginCheckReq))
}
return interceptor(ctx, in, info, handler)
}
var _Relay_serviceDesc = grpc.ServiceDesc{
ServiceName: "relay.relay",
HandlerType: (*RelayServer)(nil),
@ -889,60 +1028,68 @@ var _Relay_serviceDesc = grpc.ServiceDesc{
MethodName: "KickUserOffline",
Handler: _Relay_KickUserOffline_Handler,
},
{
MethodName: "MultiTerminalLoginCheck",
Handler: _Relay_MultiTerminalLoginCheck_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "relay/relay.proto",
}
func init() { proto.RegisterFile("relay/relay.proto", fileDescriptor_relay_9ac412c3c8c99f28) }
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, 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,
func init() { proto.RegisterFile("relay/relay.proto", fileDescriptor_relay_e9fd8824fb6cabec) }
var fileDescriptor_relay_e9fd8824fb6cabec = []byte{
// 809 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4d, 0x4f, 0xdb, 0x4c,
0x10, 0x96, 0x49, 0xc2, 0xc7, 0x00, 0x2f, 0xb0, 0x2f, 0x34, 0xc6, 0x95, 0x42, 0xf0, 0xa1, 0x8a,
0xaa, 0x36, 0x91, 0xd2, 0xde, 0x7a, 0x83, 0x08, 0x1a, 0x95, 0x28, 0x68, 0x43, 0xd5, 0x8a, 0x4b,
0x6a, 0x92, 0x4d, 0x62, 0xc5, 0xb1, 0x97, 0x5d, 0x1b, 0xc4, 0xa5, 0xd7, 0x5e, 0xaa, 0x1e, 0xfa,
0x03, 0x7a, 0xe8, 0x9f, 0xe8, 0xdf, 0xab, 0xf6, 0x23, 0xa9, 0x9d, 0xc4, 0xa4, 0x54, 0xe2, 0x02,
0x99, 0xd9, 0xd9, 0x99, 0x79, 0x9e, 0x79, 0x76, 0xd7, 0xb0, 0xc3, 0x88, 0xe7, 0xdc, 0x55, 0xe4,
0xdf, 0x32, 0x65, 0x41, 0x18, 0xa0, 0x9c, 0x34, 0xac, 0xc3, 0x26, 0x25, 0x7e, 0xbb, 0xde, 0xa8,
0xd0, 0x61, 0xbf, 0x22, 0x57, 0x2a, 0xbc, 0x3b, 0x6c, 0xdf, 0xf2, 0xca, 0x2d, 0x57, 0x91, 0xf6,
0x37, 0x03, 0xb6, 0x9b, 0xbe, 0xe7, 0xfa, 0xe4, 0x3c, 0xe2, 0x83, 0x06, 0xef, 0x63, 0x72, 0x8d,
0x8a, 0xb0, 0xde, 0xa4, 0x84, 0x39, 0xa1, 0x1b, 0xf8, 0xf5, 0x9a, 0x69, 0x14, 0x8d, 0xd2, 0x1a,
0x8e, 0xbb, 0xd0, 0x6b, 0x58, 0x19, 0xf1, 0x7e, 0xcd, 0x09, 0x1d, 0x73, 0xa9, 0x68, 0x94, 0xd6,
0xab, 0x56, 0x99, 0x13, 0x76, 0x43, 0x58, 0xdb, 0xa1, 0x6e, 0x9b, 0x3a, 0xcc, 0x19, 0xf1, 0x72,
0x43, 0x45, 0xe0, 0x71, 0x28, 0xb2, 0x61, 0x83, 0x46, 0x7c, 0x70, 0x11, 0xbc, 0xe7, 0x84, 0xd5,
0x6b, 0x66, 0x46, 0x26, 0x4e, 0xf8, 0xec, 0x53, 0xd8, 0x99, 0xea, 0x87, 0x53, 0x54, 0x85, 0x2c,
0x23, 0x9c, 0x9a, 0x46, 0x31, 0x53, 0x5a, 0xaf, 0x16, 0xca, 0x0a, 0x6b, 0xcb, 0xf5, 0xfb, 0x1e,
0x69, 0xf0, 0xbe, 0xda, 0x7c, 0xee, 0x39, 0x61, 0x2f, 0x60, 0x23, 0x2c, 0x63, 0xed, 0x2f, 0x06,
0xec, 0x8b, 0x08, 0xe2, 0x4d, 0x22, 0x30, 0xe1, 0x91, 0x17, 0x9e, 0xb9, 0x3c, 0x44, 0x4f, 0x60,
0x39, 0x52, 0x4d, 0x28, 0x74, 0xda, 0x9a, 0x54, 0x5a, 0xfa, 0xfb, 0x4a, 0xa8, 0x00, 0x10, 0x4c,
0x5a, 0x96, 0xa0, 0x56, 0x71, 0xcc, 0x63, 0xff, 0x30, 0xc0, 0x54, 0x98, 0x8e, 0x9c, 0xb0, 0x33,
0x10, 0xbe, 0xa6, 0x4f, 0x1e, 0x99, 0xeb, 0xe7, 0xb0, 0x1d, 0xe7, 0x55, 0x80, 0x36, 0x33, 0xc5,
0x4c, 0x69, 0x0d, 0xcf, 0xf8, 0x6d, 0x17, 0xf6, 0x53, 0xfa, 0xe3, 0x14, 0x9d, 0xc1, 0x36, 0x97,
0xf0, 0x85, 0x5f, 0x31, 0xa8, 0xe7, 0x50, 0x8c, 0xb1, 0x33, 0x97, 0x65, 0x3c, 0xb3, 0xd3, 0xbe,
0x83, 0x7c, 0x0a, 0x99, 0x82, 0x46, 0x15, 0x74, 0x1c, 0x74, 0x89, 0x24, 0x22, 0x83, 0x63, 0x1e,
0x31, 0x32, 0x4c, 0x3a, 0x37, 0xf5, 0x9a, 0xa4, 0x61, 0x0d, 0x6b, 0x0b, 0x3d, 0x83, 0xff, 0xc4,
0x2f, 0x91, 0xe7, 0x24, 0x60, 0x23, 0xad, 0xab, 0x1c, 0x9e, 0xf2, 0xda, 0xb7, 0x90, 0x3f, 0x25,
0xa1, 0x28, 0xc9, 0x15, 0xda, 0x56, 0xe8, 0x84, 0x11, 0x17, 0x43, 0x28, 0x00, 0x44, 0x7f, 0x68,
0x32, 0x24, 0x4d, 0x31, 0x8f, 0x18, 0x52, 0x10, 0x1b, 0x92, 0xaa, 0x1f, 0x77, 0x21, 0x0b, 0x56,
0x03, 0x9a, 0x90, 0xf5, 0xc4, 0xb6, 0x7f, 0x65, 0xc1, 0x9c, 0x5f, 0x99, 0x53, 0x64, 0xc2, 0x0a,
0x61, 0x6c, 0x02, 0x39, 0x87, 0xc7, 0xa6, 0xc0, 0x4b, 0x18, 0x6b, 0xf0, 0xfe, 0x18, 0xaf, 0xb2,
0x50, 0x0b, 0x36, 0x79, 0xd4, 0xe9, 0x10, 0xce, 0xf5, 0x34, 0x32, 0x72, 0x1a, 0x2f, 0xf5, 0x34,
0xd2, 0x2a, 0x95, 0x5b, 0xf1, 0x4d, 0x38, 0x99, 0x03, 0x9d, 0xc3, 0x46, 0xcf, 0x71, 0x3d, 0xd2,
0xd5, 0x39, 0xb3, 0x32, 0xe7, 0x8b, 0x45, 0x39, 0x4f, 0xe4, 0x9e, 0x1a, 0x09, 0x1d, 0xd7, 0xc3,
0x89, 0x0c, 0xd6, 0x31, 0x6c, 0xea, 0x8a, 0x6a, 0x59, 0x50, 0x44, 0xf5, 0xac, 0xb5, 0xcc, 0x27,
0xb6, 0xc0, 0xca, 0x65, 0xd6, 0x31, 0x56, 0x65, 0x59, 0x1f, 0x61, 0x23, 0x5e, 0x22, 0x76, 0x6c,
0x33, 0x89, 0x63, 0xfb, 0x60, 0x16, 0xad, 0x9f, 0xc6, 0xa4, 0x3f, 0x4d, 0x41, 0xda, 0x95, 0x90,
0xd2, 0x1b, 0x72, 0x60, 0xb7, 0x2b, 0xbb, 0x1a, 0x2b, 0x58, 0xf1, 0xf2, 0xc0, 0x71, 0x68, 0xee,
0xe6, 0xa6, 0xb2, 0x3f, 0x03, 0x7a, 0xe7, 0x76, 0x86, 0x22, 0x41, 0xb3, 0xd7, 0x13, 0x09, 0xf4,
0x95, 0x11, 0xcc, 0x5e, 0x19, 0x71, 0x35, 0x16, 0x00, 0xc6, 0xd4, 0x6a, 0xb9, 0xe6, 0x70, 0xcc,
0x23, 0x8e, 0xcc, 0x50, 0xe7, 0x4d, 0x5c, 0x0d, 0x53, 0x5e, 0x7b, 0x0f, 0xfe, 0x9f, 0xa9, 0xcf,
0xa9, 0xfd, 0xd5, 0x00, 0xab, 0x11, 0x79, 0xa1, 0x7b, 0x41, 0xd8, 0xc8, 0xf5, 0x1d, 0xef, 0x2c,
0xe8, 0xbb, 0xfe, 0xf1, 0x80, 0x74, 0x86, 0xa2, 0xbf, 0x34, 0x22, 0x17, 0x75, 0xb5, 0x0b, 0xb9,
0x30, 0x18, 0x12, 0x5f, 0xcf, 0x56, 0x19, 0xd3, 0x68, 0xb3, 0x33, 0x68, 0xed, 0x26, 0x3c, 0x4d,
0xed, 0xe6, 0x5f, 0x4e, 0x58, 0xf5, 0x7b, 0x16, 0xd4, 0x0b, 0x8a, 0x8e, 0x60, 0x33, 0xf1, 0x1a,
0xa1, 0xbc, 0x1e, 0xeb, 0xf4, 0x9b, 0x69, 0x99, 0xf3, 0x17, 0x38, 0x45, 0x1f, 0x60, 0x77, 0x9e,
0x08, 0x50, 0xe1, 0x5e, 0x85, 0x5c, 0x5b, 0x07, 0x0b, 0x14, 0x84, 0x2e, 0x61, 0x6f, 0xee, 0xb5,
0x8d, 0x0e, 0x12, 0xbd, 0xcc, 0x3e, 0x3a, 0x56, 0xf1, 0xfe, 0x00, 0x4e, 0x51, 0x17, 0x0e, 0x5a,
0x11, 0x25, 0xec, 0x94, 0x05, 0x11, 0x7d, 0xb4, 0x2a, 0x6f, 0x61, 0x6b, 0x4a, 0x5f, 0x68, 0x5f,
0x6f, 0x9a, 0xd5, 0xbd, 0x65, 0xa5, 0x2d, 0x71, 0x8a, 0x3e, 0x41, 0x3e, 0x45, 0x03, 0xe8, 0x50,
0x6f, 0x4b, 0x57, 0xac, 0x65, 0x2f, 0x0a, 0xe1, 0xf4, 0x68, 0xe7, 0x72, 0xab, 0xac, 0x3e, 0xb2,
0xde, 0xd0, 0x2b, 0x2c, 0xfe, 0x5f, 0x2d, 0xcb, 0x6f, 0xa8, 0x57, 0xbf, 0x03, 0x00, 0x00, 0xff,
0xff, 0x8e, 0xbc, 0x1c, 0xdc, 0x82, 0x09, 0x00, 0x00,
}

16
pkg/proto/relay/relay.proto
Unescape View File

@ -76,12 +76,26 @@ int32 platformID = 2;
message KickUserOfflineResp{
}
message MultiTerminalLoginCheckReq{
string userID = 1;
int32 platformID = 2;
string token = 3;
string operationID = 4;
}
message MultiTerminalLoginCheckResp{
int32 errCode = 1;
string errMsg = 2;
}
service relay {
rpc OnlinePushMsg(OnlinePushMsgReq) returns(OnlinePushMsgResp);
rpc GetUsersOnlineStatus(GetUsersOnlineStatusReq) returns(GetUsersOnlineStatusResp);
rpc OnlineBatchPushOneMsg(OnlineBatchPushOneMsgReq) returns(OnlineBatchPushOneMsgResp);
rpc SuperGroupOnlineBatchPushOneMsg(OnlineBatchPushOneMsgReq) returns(OnlineBatchPushOneMsgResp);
rpc KickUserOffline(KickUserOfflineReq) returns(KickUserOfflineResp);
// rpc SendMsgByWS(SendMsgByWSReq) returns(MsgToUserResp);
rpc MultiTerminalLoginCheck(MultiTerminalLoginCheckReq) returns(MultiTerminalLoginCheckResp);
}

Write Preview
Loading…
Cancel
Save