v3 - main to cut out

internal/msg_gateway/gate/init.go

@@ -0,0 +1,35 @@
+package gate
+
+import (
+	"Open_IM/pkg/common/config"
+
+	"Open_IM/pkg/statistics"
+	"fmt"
+	"github.com/go-playground/validator/v10"
+	"sync"
+)
+
+var (
+	rwLock       *sync.RWMutex
+	validate     *validator.Validate
+	ws           WServer
+	rpcSvr       RPCServer
+	sendMsgCount uint64
+	userCount    uint64
+)
+
+func Init(rpcPort, wsPort int) {
+	//log initialization
+
+	rwLock = new(sync.RWMutex)
+	validate = validator.New()
+	statistics.NewStatistics(&sendMsgCount, config.Config.ModuleName.LongConnSvrName, fmt.Sprintf("%d second recv to msg_gateway sendMsgCount", sendMsgCount), 300)
+	statistics.NewStatistics(&userCount, config.Config.ModuleName.LongConnSvrName, fmt.Sprintf("%d second add user conn", userCount), 300)
+	ws.onInit(wsPort)
+	rpcSvr.onInit(rpcPort)
+}
+
+func Run() {
+	go ws.run()
+	go rpcSvr.run()
+}

internal/msg_gateway/gate/logic.go

@@ -0,0 +1,297 @@
+package gate
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	pbRtc "Open_IM/pkg/proto/rtc"
+	sdk_ws "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"bytes"
+	"context"
+	"encoding/gob"
+	"github.com/golang/protobuf/proto"
+	"github.com/gorilla/websocket"
+	"google.golang.org/grpc"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) {
+	//ws online debug data
+	//{"ReqIdentifier":1001,"Token":"123","SendID":"c4ca4238a0b923820dcc509a6f75849b","Time":"123","OperationID":"123","MsgIncr":0}
+	//{"ReqIdentifier":1002,"Token":"123","SendID":"c4ca4238a0b923820dcc509a6f75849b","Time":"123","OperationID":"123","MsgIncr":0,"SeqBegin":1,"SeqEnd":6}
+	//{"ReqIdentifier":1003,"Token":"123","SendID":"c4ca4238a0b923820dcc509a6f75849b",
+	//"RecvID":"a87ff679a2f3e71d9181a67b7542122c","ClientMsgID":"2343","Time":"147878787","OperationID":
+	//"123","MsgIncr":0,"SubMsgType":101,"MsgType":100,"MsgFrom":1,"Content":"sdfsdf"}
+	b := bytes.NewBuffer(binaryMsg)
+	m := Req{}
+	dec := gob.NewDecoder(b)
+	err := dec.Decode(&m)
+	if err != nil {
+		log.NewError("", "ws Decode  err", err.Error())
+		ws.sendErrMsg(conn, 200, err.Error(), constant.WSDataError, "", "")
+		err = conn.Close()
+		if err != nil {
+			log.NewError("", "ws close err", err.Error())
+		}
+		return
+	}
+	if err := validate.Struct(m); err != nil {
+		log.NewError("", "ws args validate  err", err.Error())
+		ws.sendErrMsg(conn, 201, err.Error(), m.ReqIdentifier, m.MsgIncr, m.OperationID)
+		return
+	}
+	//if !utils.VerifyToken(m.Token, m.SendID) {
+	//	ws.sendErrMsg(conn, 202, "token validate err", m.ReqIdentifier, m.MsgIncr,m.OperationID)
+	//	return
+	//}
+	log.NewInfo(m.OperationID, "Basic Info Authentication Success", m)
+
+	switch m.ReqIdentifier {
+	case constant.WSGetNewestSeq:
+		ws.getSeqReq(conn, &m)
+	case constant.WSSendMsg:
+		ws.sendMsgReq(conn, &m)
+	case constant.WSSendSignalMsg:
+		ws.sendSignalMsgReq(conn, &m)
+	case constant.WSPullMsgBySeqList:
+		ws.pullMsgBySeqListReq(conn, &m)
+	default:
+	}
+	log.NewInfo("", "goroutine num is ", runtime.NumGoroutine())
+}
+func (ws *WServer) getSeqReq(conn *UserConn, m *Req) {
+	log.NewInfo(m.OperationID, "Ws call success to getNewSeq", m.MsgIncr, m.SendID, m.ReqIdentifier, m.Data)
+	rpcReq := pbChat.GetMaxAndMinSeqReq{}
+	nReply := new(pbChat.GetMaxAndMinSeqResp)
+	rpcReq.UserID = m.SendID
+	rpcReq.OperationID = m.OperationID
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	if grpcConn == nil {
+		log.ErrorByKv("get grpcConn err", rpcReq.OperationID, "args", m)
+	}
+	msgClient := pbChat.NewChatClient(grpcConn)
+	rpcReply, err := msgClient.GetMaxAndMinSeq(context.Background(), &rpcReq)
+	if err != nil {
+		log.Error(rpcReq.OperationID, "rpc call failed to getSeqReq", err, rpcReq.String())
+		nReply.ErrCode = 500
+		nReply.ErrMsg = err.Error()
+		ws.getSeqResp(conn, m, nReply)
+	} else {
+		log.InfoByKv("rpc call success to getSeqReq", rpcReq.OperationID, "replyData", rpcReply.String())
+		ws.getSeqResp(conn, m, rpcReply)
+	}
+}
+func (ws *WServer) getSeqResp(conn *UserConn, m *Req, pb *pbChat.GetMaxAndMinSeqResp) {
+	var mReplyData sdk_ws.GetMaxAndMinSeqResp
+	mReplyData.MaxSeq = pb.GetMaxSeq()
+	mReplyData.MinSeq = pb.GetMinSeq()
+	b, _ := proto.Marshal(&mReplyData)
+	mReply := Resp{
+		ReqIdentifier: m.ReqIdentifier,
+		MsgIncr:       m.MsgIncr,
+		ErrCode:       pb.GetErrCode(),
+		ErrMsg:        pb.GetErrMsg(),
+		OperationID:   m.OperationID,
+		Data:          b,
+	}
+	ws.sendMsg(conn, mReply)
+}
+
+func (ws *WServer) pullMsgBySeqListReq(conn *UserConn, m *Req) {
+	log.NewInfo(m.OperationID, "Ws call success to pullMsgBySeqListReq start", m.SendID, m.ReqIdentifier, m.MsgIncr, m.Data)
+	nReply := new(sdk_ws.PullMessageBySeqListResp)
+	isPass, errCode, errMsg, data := ws.argsValidate(m, constant.WSPullMsgBySeqList)
+	if isPass {
+		rpcReq := sdk_ws.PullMessageBySeqListReq{}
+		rpcReq.SeqList = data.(sdk_ws.PullMessageBySeqListReq).SeqList
+		rpcReq.UserID = m.SendID
+		rpcReq.OperationID = m.OperationID
+		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)
+		msgClient := pbChat.NewChatClient(grpcConn)
+		reply, err := msgClient.PullMessageBySeqList(context.Background(), &rpcReq)
+		if err != nil {
+			log.NewError(rpcReq.OperationID, "pullMsgBySeqListReq err", err.Error())
+			nReply.ErrCode = 200
+			nReply.ErrMsg = err.Error()
+			ws.pullMsgBySeqListResp(conn, m, nReply)
+		} else {
+			log.NewInfo(rpcReq.OperationID, "rpc call success to pullMsgBySeqListReq", reply.String(), len(reply.List))
+			ws.pullMsgBySeqListResp(conn, m, reply)
+		}
+	} else {
+		nReply.ErrCode = errCode
+		nReply.ErrMsg = errMsg
+		ws.pullMsgBySeqListResp(conn, m, nReply)
+	}
+}
+func (ws *WServer) pullMsgBySeqListResp(conn *UserConn, m *Req, pb *sdk_ws.PullMessageBySeqListResp) {
+	log.NewInfo(m.OperationID, "pullMsgBySeqListResp come  here ", pb.String())
+	c, _ := proto.Marshal(pb)
+	mReply := Resp{
+		ReqIdentifier: m.ReqIdentifier,
+		MsgIncr:       m.MsgIncr,
+		ErrCode:       pb.GetErrCode(),
+		ErrMsg:        pb.GetErrMsg(),
+		OperationID:   m.OperationID,
+		Data:          c,
+	}
+	log.NewInfo(m.OperationID, "pullMsgBySeqListResp all data  is ", mReply.ReqIdentifier, mReply.MsgIncr, mReply.ErrCode, mReply.ErrMsg,
+		len(mReply.Data))
+
+	ws.sendMsg(conn, mReply)
+
+}
+func (ws *WServer) sendMsgReq(conn *UserConn, m *Req) {
+	sendMsgCount++
+	log.NewInfo(m.OperationID, "Ws call success to sendMsgReq start", m.MsgIncr, m.ReqIdentifier, m.SendID, m.Data)
+	nReply := new(pbChat.SendMsgResp)
+	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendMsg)
+	if isPass {
+		data := pData.(sdk_ws.MsgData)
+		pbData := pbChat.SendMsgReq{
+			Token:       m.Token,
+			OperationID: m.OperationID,
+			MsgData:     &data,
+		}
+		log.NewInfo(m.OperationID, "Ws call success to sendMsgReq middle", m.ReqIdentifier, m.SendID, m.MsgIncr, data)
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+		client := pbChat.NewChatClient(etcdConn)
+		reply, err := client.SendMsg(context.Background(), &pbData)
+		if err != nil {
+			log.NewError(pbData.OperationID, "UserSendMsg err", err.Error())
+			nReply.ErrCode = 200
+			nReply.ErrMsg = err.Error()
+			ws.sendMsgResp(conn, m, nReply)
+		} else {
+			log.NewInfo(pbData.OperationID, "rpc call success to sendMsgReq", reply.String())
+			ws.sendMsgResp(conn, m, reply)
+		}
+
+	} else {
+		nReply.ErrCode = errCode
+		nReply.ErrMsg = errMsg
+		ws.sendMsgResp(conn, m, nReply)
+	}
+
+}
+func (ws *WServer) sendMsgResp(conn *UserConn, m *Req, pb *pbChat.SendMsgResp) {
+	// := make(map[string]interface{})
+
+	var mReplyData sdk_ws.UserSendMsgResp
+	mReplyData.ClientMsgID = pb.GetClientMsgID()
+	mReplyData.ServerMsgID = pb.GetServerMsgID()
+	mReplyData.SendTime = pb.GetSendTime()
+	b, _ := proto.Marshal(&mReplyData)
+	mReply := Resp{
+		ReqIdentifier: m.ReqIdentifier,
+		MsgIncr:       m.MsgIncr,
+		ErrCode:       pb.GetErrCode(),
+		ErrMsg:        pb.GetErrMsg(),
+		OperationID:   m.OperationID,
+		Data:          b,
+	}
+	ws.sendMsg(conn, mReply)
+}
+
+func (ws *WServer) sendSignalMsgReq(conn *UserConn, m *Req) {
+	log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq start", m.MsgIncr, m.ReqIdentifier, m.SendID, m.Data)
+	nReply := new(pbChat.SendMsgResp)
+	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendSignalMsg)
+	if isPass {
+		signalResp := pbRtc.SignalResp{}
+		//isPass2, errCode2, errMsg2, signalResp, msgData := ws.signalMessageAssemble(pData.(*sdk_ws.SignalReq), m.OperationID)
+		connGrpc, err := grpc.Dial(config.Config.Rtc.Address+":"+strconv.Itoa(config.Config.Rtc.Port), grpc.WithInsecure())
+		if err != nil {
+			log.NewError(m.OperationID, utils.GetSelfFuncName(), "grpc.Dial failed", err.Error())
+			ws.sendSignalMsgResp(conn, 204, "create grpc failed"+err.Error(), m, nil)
+			return
+		}
+		rtcClient := pbRtc.NewRtcServiceClient(connGrpc)
+		req := &pbRtc.SignalMessageAssembleReq{
+			SignalReq:   pData.(*pbRtc.SignalReq),
+			OperationID: m.OperationID,
+		}
+		respPb, err := rtcClient.SignalMessageAssemble(context.Background(), req)
+		if err != nil {
+			log.NewError(m.OperationID, utils.GetSelfFuncName(), "SignalMessageAssemble", err.Error(), config.Config.Rtc.Address+":"+strconv.Itoa(config.Config.Rtc.Port))
+			ws.sendSignalMsgResp(conn, 204, "grpc SignalMessageAssemble failed: "+err.Error(), m, &signalResp)
+			return
+		}
+		signalResp.Payload = respPb.SignalResp.Payload
+		msgData := sdk_ws.MsgData{}
+		utils.CopyStructFields(&msgData, respPb.MsgData)
+		log.NewInfo(m.OperationID, utils.GetSelfFuncName(), respPb.String())
+		if respPb.IsPass {
+			pbData := pbChat.SendMsgReq{
+				Token:       m.Token,
+				OperationID: m.OperationID,
+				MsgData:     &msgData,
+			}
+			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)
+			client := pbChat.NewChatClient(etcdConn)
+			reply, err := client.SendMsg(context.Background(), &pbData)
+			if err != nil {
+				log.NewError(pbData.OperationID, utils.GetSelfFuncName(), "rpc sendMsg err", err.Error())
+				nReply.ErrCode = 200
+				nReply.ErrMsg = err.Error()
+				ws.sendSignalMsgResp(conn, 200, err.Error(), m, &signalResp)
+			} else {
+				log.NewInfo(pbData.OperationID, "rpc call success to sendMsgReq", reply.String())
+				ws.sendSignalMsgResp(conn, 0, "", m, &signalResp)
+			}
+		} else {
+			log.NewError(m.OperationID, utils.GetSelfFuncName(), respPb.IsPass, respPb.CommonResp.ErrCode, respPb.CommonResp.ErrMsg)
+			ws.sendSignalMsgResp(conn, respPb.CommonResp.ErrCode, respPb.CommonResp.ErrMsg, m, &signalResp)
+		}
+	} else {
+		ws.sendSignalMsgResp(conn, errCode, errMsg, m, nil)
+	}
+
+}
+func (ws *WServer) sendSignalMsgResp(conn *UserConn, errCode int32, errMsg string, m *Req, pb *pbRtc.SignalResp) {
+	// := make(map[string]interface{})
+	log.Debug(m.OperationID, "SignalMsgResp is", pb.String())
+	b, _ := proto.Marshal(pb)
+	mReply := Resp{
+		ReqIdentifier: m.ReqIdentifier,
+		MsgIncr:       m.MsgIncr,
+		ErrCode:       errCode,
+		ErrMsg:        errMsg,
+		OperationID:   m.OperationID,
+		Data:          b,
+	}
+	ws.sendMsg(conn, mReply)
+}
+func (ws *WServer) sendMsg(conn *UserConn, mReply interface{}) {
+	var b bytes.Buffer
+	enc := gob.NewEncoder(&b)
+	err := enc.Encode(mReply)
+	if err != nil {
+		uid, platform := ws.getUserUid(conn)
+		log.NewError(mReply.(Resp).OperationID, mReply.(Resp).ReqIdentifier, mReply.(Resp).ErrCode, mReply.(Resp).ErrMsg, "Encode Msg error", conn.RemoteAddr().String(), uid, platform, err.Error())
+		return
+	}
+	err = ws.writeMsg(conn, websocket.BinaryMessage, b.Bytes())
+	if err != nil {
+		uid, platform := ws.getUserUid(conn)
+		log.NewError(mReply.(Resp).OperationID, mReply.(Resp).ReqIdentifier, mReply.(Resp).ErrCode, mReply.(Resp).ErrMsg, "WS WriteMsg error", conn.RemoteAddr().String(), uid, platform, err.Error())
+	}
+}
+func (ws *WServer) sendErrMsg(conn *UserConn, errCode int32, errMsg string, reqIdentifier int32, msgIncr string, operationID string) {
+	mReply := Resp{
+		ReqIdentifier: reqIdentifier,
+		MsgIncr:       msgIncr,
+		ErrCode:       errCode,
+		ErrMsg:        errMsg,
+		OperationID:   operationID,
+	}
+	ws.sendMsg(conn, mReply)
+}

internal/msg_gateway/gate/open_im_media/room.go

@@ -0,0 +1,58 @@
+package open_im_media
+
+const (
+	// Address gRPC服务地址
+	Address = "127.0.0.1:11300"
+)
+
+//var roomClient *lksdk.RoomServiceClient
+
+type Media struct {
+}
+
+func NewMedia() *Media {
+	return &Media{}
+}
+
+//func (m *Media) GetJoinToken(room, identity string, operationID string, data *open_im_sdk.ParticipantMetaData) (string, string, error) {
+//	var newData pbRtc.ParticipantMetaData
+//	copier.Copy(&newData, data)
+//	conn, err := grpc.Dial(Address, grpc.WithInsecure())
+//	if err != nil {
+//		return "", "", err
+//	}
+//	defer conn.Close()
+//	c := pbRtc.NewRtcServiceClient(conn)
+//	req := &pbRtc.GetJoinTokenReq{Room: room, OperationID: operationID, Identity: identity, MetaData: &newData}
+//	resp, err := c.GetJoinToken(context.Background(), req)
+//	if err != nil {
+//		return "", "", err
+//	}
+//	if resp.CommonResp.ErrCode != 0 {
+//		return "", "", errors.New(resp.CommonResp.ErrMsg)
+//	}
+//	return resp.Jwt, resp.LiveURL, nil
+//	//at := auth.NewAccessToken(m.ApiKey, m.ApiSecret)
+//	//grant := &auth.VideoGrant{
+//	//	RoomJoin: true,
+//	//	Room:     room,
+//	//}
+//	//at.AddGrant(grant).
+//	//	SetIdentity(identity).
+//	//	SetValidFor(time.Hour)
+//	//
+//	//return at.ToJWT()
+//}
+
+func init() {
+	//roomClient = lksdk.NewRoomServiceClient(MediaAddress, ApiKey, ApiSecret)
+}
+
+func (m *Media) CreateRoom(roomName string) (error, error) {
+	return nil, nil
+	//return roomClient.CreateRoom(context.Background(), &livekit.CreateRoomRequest{
+	//	Name:         roomName,
+	//	EmptyTimeout: 60 * 3,
+	//})
+
+}

internal/msg_gateway/gate/rpc_server.go

@@ -0,0 +1,149 @@
+package gate
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"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"
+	"fmt"
+	"github.com/golang/protobuf/proto"
+	"net"
+	"strings"
+
+	"github.com/gorilla/websocket"
+	"google.golang.org/grpc"
+)
+
+type RPCServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func (r *RPCServer) onInit(rpcPort int) {
+	r.rpcPort = rpcPort
+	r.rpcRegisterName = config.Config.RpcRegisterName.OpenImOnlineMessageRelayName
+	r.etcdSchema = config.Config.Etcd.EtcdSchema
+	r.etcdAddr = config.Config.Etcd.EtcdAddr
+}
+func (r *RPCServer) run() {
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + utils.IntToString(r.rpcPort)
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.ErrorByArgs(fmt.Sprintf("fail to listening consumer, err:%v\n", err))
+		return
+	}
+	defer listener.Close()
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	pbRelay.RegisterOnlineMessageRelayServiceServer(srv, r)
+	err = getcdv3.RegisterEtcd4Unique(r.etcdSchema, strings.Join(r.etcdAddr, ","), ip, r.rpcPort, r.rpcRegisterName, 10)
+	if err != nil {
+		log.ErrorByKv("register push message rpc to etcd err", "", "err", err.Error())
+	}
+	err = srv.Serve(listener)
+	if err != nil {
+		log.ErrorByKv("push message rpc listening err", "", "err", err.Error())
+		return
+	}
+}
+func (r *RPCServer) OnlinePushMsg(_ context.Context, in *pbRelay.OnlinePushMsgReq) (*pbRelay.OnlinePushMsgResp, error) {
+	log.InfoByKv("PushMsgToUser is arriving", in.OperationID, "args", in.String())
+	var resp []*pbRelay.SingleMsgToUser
+	msgBytes, _ := proto.Marshal(in.MsgData)
+	mReply := Resp{
+		ReqIdentifier: constant.WSPushMsg,
+		OperationID:   in.OperationID,
+		Data:          msgBytes,
+	}
+	var replyBytes bytes.Buffer
+	enc := gob.NewEncoder(&replyBytes)
+	err := enc.Encode(mReply)
+	if err != nil {
+		log.NewError(in.OperationID, "data encode err", err.Error())
+	}
+	var tag bool
+	recvID := in.PushToUserID
+	platformList := genPlatformArray()
+	for _, v := range platformList {
+		if conn := ws.getUserConn(recvID, v); conn != nil {
+			tag = true
+			resultCode := sendMsgToUser(conn, replyBytes.Bytes(), in, v, recvID)
+			temp := &pbRelay.SingleMsgToUser{
+				ResultCode:     resultCode,
+				RecvID:         recvID,
+				RecvPlatFormID: constant.PlatformNameToID(v),
+			}
+			resp = append(resp, temp)
+		} else {
+			temp := &pbRelay.SingleMsgToUser{
+				ResultCode:     -1,
+				RecvID:         recvID,
+				RecvPlatFormID: constant.PlatformNameToID(v),
+			}
+			resp = append(resp, temp)
+		}
+	}
+	if !tag {
+		log.NewError(in.OperationID, "push err ,no matched ws conn not in map", in.String())
+	}
+	return &pbRelay.OnlinePushMsgResp{
+		Resp: resp,
+	}, nil
+}
+func (r *RPCServer) GetUsersOnlineStatus(_ context.Context, req *pbRelay.GetUsersOnlineStatusReq) (*pbRelay.GetUsersOnlineStatusResp, error) {
+	log.NewInfo(req.OperationID, "rpc GetUsersOnlineStatus arrived server", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		log.NewError(req.OperationID, "no permission GetUsersOnlineStatus ", req.OpUserID)
+		return &pbRelay.GetUsersOnlineStatusResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	var resp pbRelay.GetUsersOnlineStatusResp
+	for _, userID := range req.UserIDList {
+		platformList := genPlatformArray()
+		temp := new(pbRelay.GetUsersOnlineStatusResp_SuccessResult)
+		temp.UserID = userID
+		for _, platform := range platformList {
+			if conn := ws.getUserConn(userID, platform); conn != nil {
+				ps := new(pbRelay.GetUsersOnlineStatusResp_SuccessDetail)
+				ps.Platform = platform
+				ps.Status = constant.OnlineStatus
+				temp.Status = constant.OnlineStatus
+				temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, ps)
+
+			}
+		}
+		if temp.Status == constant.OnlineStatus {
+			resp.SuccessResult = append(resp.SuccessResult, temp)
+		}
+	}
+	log.NewInfo(req.OperationID, "GetUsersOnlineStatus rpc return ", resp.String())
+	return &resp, nil
+}
+func sendMsgToUser(conn *UserConn, bMsg []byte, in *pbRelay.OnlinePushMsgReq, RecvPlatForm, RecvID string) (ResultCode int64) {
+	err := ws.writeMsg(conn, websocket.BinaryMessage, bMsg)
+	if err != nil {
+		log.ErrorByKv("PushMsgToUser is failed By Ws", "", "Addr", conn.RemoteAddr().String(),
+			"error", err, "senderPlatform", constant.PlatformIDToName(in.MsgData.SenderPlatformID), "recvPlatform", RecvPlatForm, "args", in.String(), "recvID", RecvID)
+		ResultCode = -2
+		return ResultCode
+	} else {
+		log.InfoByKv("PushMsgToUser is success By Ws", in.OperationID, "args", in.String(), "recvPlatForm", RecvPlatForm, "recvID", RecvID)
+		ResultCode = 0
+		return ResultCode
+	}
+
+}
+func genPlatformArray() (array []string) {
+	for i := 1; i <= constant.LinuxPlatformID; i++ {
+		array = append(array, constant.PlatformIDToName(int32(i)))
+	}
+	return array
+}

internal/msg_gateway/gate/validate.go

@@ -0,0 +1,253 @@
+/*
+** description("").
+** copyright('Open_IM,www.Open_IM.io').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/5/21 15:29).
+ */
+package gate
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	pbRtc "Open_IM/pkg/proto/rtc"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"github.com/golang/protobuf/proto"
+)
+
+type Req struct {
+	ReqIdentifier int32  `json:"reqIdentifier" validate:"required"`
+	Token         string `json:"token" `
+	SendID        string `json:"sendID" validate:"required"`
+	OperationID   string `json:"operationID" validate:"required"`
+	MsgIncr       string `json:"msgIncr" validate:"required"`
+	Data          []byte `json:"data"`
+}
+type Resp struct {
+	ReqIdentifier int32  `json:"reqIdentifier"`
+	MsgIncr       string `json:"msgIncr"`
+	OperationID   string `json:"operationID"`
+	ErrCode       int32  `json:"errCode"`
+	ErrMsg        string `json:"errMsg"`
+	Data          []byte `json:"data"`
+}
+
+type SeqData struct {
+	SeqBegin int64 `mapstructure:"seqBegin" validate:"required"`
+	SeqEnd   int64 `mapstructure:"seqEnd" validate:"required"`
+}
+type MsgData struct {
+	PlatformID  int32                  `mapstructure:"platformID" validate:"required"`
+	SessionType int32                  `mapstructure:"sessionType" validate:"required"`
+	MsgFrom     int32                  `mapstructure:"msgFrom" validate:"required"`
+	ContentType int32                  `mapstructure:"contentType" validate:"required"`
+	RecvID      string                 `mapstructure:"recvID" validate:"required"`
+	ForceList   []string               `mapstructure:"forceList"`
+	Content     string                 `mapstructure:"content" validate:"required"`
+	Options     map[string]interface{} `mapstructure:"options" validate:"required"`
+	ClientMsgID string                 `mapstructure:"clientMsgID" validate:"required"`
+	OfflineInfo map[string]interface{} `mapstructure:"offlineInfo" validate:"required"`
+	Ext         map[string]interface{} `mapstructure:"ext"`
+}
+type MaxSeqResp struct {
+	MaxSeq int64 `json:"maxSeq"`
+}
+type PullMessageResp struct {
+}
+type SeqListData struct {
+	SeqList []int64 `mapstructure:"seqList" validate:"required"`
+}
+
+func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, errMsg string, returnData interface{}) {
+	switch r {
+	case constant.WSSendMsg:
+		data := open_im_sdk.MsgData{}
+		if err := proto.Unmarshal(m.Data, &data); err != nil {
+			log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 203, err.Error(), nil
+		}
+		if err := validate.Struct(data); err != nil {
+			log.ErrorByKv("data args validate  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 204, err.Error(), nil
+
+		}
+		return true, 0, "", data
+	case constant.WSSendSignalMsg:
+		data := pbRtc.SignalReq{}
+		if err := proto.Unmarshal(m.Data, &data); err != nil {
+			log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 203, err.Error(), nil
+		}
+		if err := validate.Struct(data); err != nil {
+			log.ErrorByKv("data args validate  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 204, err.Error(), nil
+
+		}
+		return true, 0, "", &data
+	case constant.WSPullMsgBySeqList:
+		data := open_im_sdk.PullMessageBySeqListReq{}
+		if err := proto.Unmarshal(m.Data, &data); err != nil {
+			log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 203, err.Error(), nil
+		}
+		if err := validate.Struct(data); err != nil {
+			log.ErrorByKv("data args validate  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 204, err.Error(), nil
+
+		}
+		return true, 0, "", data
+
+	default:
+	}
+
+	return false, 204, "args err", nil
+
+	//b := bytes.NewBuffer(m.Data)
+	//dec := gob.NewDecoder(b)
+	//err := dec.Decode(&data)
+	//if err != nil {
+	//	log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+	//	return false, 203, err.Error(), nil
+	//}
+	//if err := mapstructure.WeakDecode(m.Data, &data); err != nil {
+	//	log.ErrorByKv("map to Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+	//	return false, 203, err.Error(), nil
+	//} else
+
+}
+
+//func (ws *WServer) signalMessageAssemble(s *open_im_sdk.SignalReq, operationID string) (isPass bool, errCode int32, errMsg string, r *open_im_sdk.SignalResp, msgData *open_im_sdk.MsgData) {
+//	var msg open_im_sdk.MsgData
+//	var resp open_im_sdk.SignalResp
+//	media := open_im_media.NewMedia()
+//	msg.MsgFrom = constant.UserMsgType
+//	msg.ContentType = constant.SignalingNotification
+//	reqData, e := proto.Marshal(s)
+//	if e != nil {
+//		return false, 201, e.Error(), nil, nil
+//	}
+//	msg.Content = reqData
+//	msg.CreateTime = utils.GetCurrentTimestampByMill()
+//	options := make(map[string]bool, 6)
+//	utils.SetSwitchFromOptions(options, constant.IsHistory, false)
+//	utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
+//	utils.SetSwitchFromOptions(options, constant.IsSenderSync, true)
+//	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false)
+//	utils.SetSwitchFromOptions(options, constant.IsSenderConversationUpdate, false)
+//	utils.SetSwitchFromOptions(options, constant.IsUnreadCount, false)
+//	utils.SetSwitchFromOptions(options, constant.IsOfflinePush, true)
+//	msg.Options = options
+//	switch payload := s.Payload.(type) {
+//	case *open_im_sdk.SignalReq_Invite:
+//		token, liveURL, err2 := media.GetJoinToken(payload.Invite.Invitation.RoomID, payload.Invite.Invitation.InviterUserID, operationID, payload.Invite.Participant)
+//		if err2 != nil {
+//			return false, 202, err2.Error(), nil, nil
+//		}
+//		invite := open_im_sdk.SignalResp_Invite{&open_im_sdk.SignalInviteReply{
+//			Token:   token,
+//			RoomID:  payload.Invite.Invitation.RoomID,
+//			LiveURL: liveURL,
+//		}}
+//		resp.Payload = &invite
+//		msg.SenderPlatformID = payload.Invite.Invitation.PlatformID
+//		msg.SessionType = payload.Invite.Invitation.SessionType
+//		msg.OfflinePushInfo = payload.Invite.OfflinePushInfo
+//		msg.SendID = payload.Invite.Invitation.InviterUserID
+//		if len(payload.Invite.Invitation.InviteeUserIDList) > 0 {
+//			msg.RecvID = payload.Invite.Invitation.InviteeUserIDList[0]
+//		} else {
+//			return false, 203, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Invite.Invitation.InviterUserID)
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_InviteInGroup:
+//		token, liveURL, err2 := media.GetJoinToken(payload.InviteInGroup.Invitation.RoomID, payload.InviteInGroup.Invitation.InviterUserID, operationID, payload.InviteInGroup.Participant)
+//		if err2 != nil {
+//			return false, 204, err2.Error(), nil, nil
+//		}
+//		inviteGroup := open_im_sdk.SignalResp_InviteInGroup{&open_im_sdk.SignalInviteInGroupReply{
+//			RoomID:  payload.InviteInGroup.Invitation.RoomID,
+//			Token:   token,
+//			LiveURL: liveURL,
+//		}}
+//		resp.Payload = &inviteGroup
+//		msg.SenderPlatformID = payload.InviteInGroup.Invitation.PlatformID
+//		msg.SessionType = payload.InviteInGroup.Invitation.SessionType
+//		msg.OfflinePushInfo = payload.InviteInGroup.OfflinePushInfo
+//		msg.SendID = payload.InviteInGroup.Invitation.InviterUserID
+//		if len(payload.InviteInGroup.Invitation.InviteeUserIDList) > 0 {
+//			msg.GroupID = payload.InviteInGroup.Invitation.GroupID
+//		} else {
+//			return false, 205, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.InviteInGroup.Invitation.InviterUserID)
+//
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_Cancel:
+//		cancel := open_im_sdk.SignalResp_Cancel{&open_im_sdk.SignalCancelReply{}}
+//		resp.Payload = &cancel
+//		msg.OfflinePushInfo = payload.Cancel.OfflinePushInfo
+//		msg.SendID = payload.Cancel.Invitation.InviterUserID
+//		msg.SenderPlatformID = payload.Cancel.Invitation.PlatformID
+//		msg.SessionType = payload.Cancel.Invitation.SessionType
+//		if len(payload.Cancel.Invitation.InviteeUserIDList) > 0 {
+//			switch payload.Cancel.Invitation.SessionType {
+//			case constant.SingleChatType:
+//				msg.RecvID = payload.Cancel.Invitation.InviteeUserIDList[0]
+//			case constant.GroupChatType:
+//				msg.GroupID = payload.Cancel.Invitation.GroupID
+//			}
+//		} else {
+//			return false, 206, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Cancel.OpUserID)
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_Accept:
+//		token, liveURL, err2 := media.GetJoinToken(payload.Accept.Invitation.RoomID, payload.Accept.OpUserID, operationID, payload.Accept.Participant)
+//		if err2 != nil {
+//			return false, 207, err2.Error(), nil, nil
+//		}
+//		accept := open_im_sdk.SignalResp_Accept{&open_im_sdk.SignalAcceptReply{
+//			Token:   token,
+//			LiveURL: liveURL,
+//			RoomID:  payload.Accept.Invitation.RoomID,
+//		}}
+//		resp.Payload = &accept
+//		msg.OfflinePushInfo = payload.Accept.OfflinePushInfo
+//		msg.SendID = payload.Accept.OpUserID
+//		msg.SenderPlatformID = payload.Accept.Invitation.PlatformID
+//		msg.SessionType = payload.Accept.Invitation.SessionType
+//		if len(payload.Accept.Invitation.InviteeUserIDList) > 0 {
+//			switch payload.Accept.Invitation.SessionType {
+//			case constant.SingleChatType:
+//				msg.RecvID = payload.Accept.Invitation.InviterUserID
+//			case constant.GroupChatType:
+//				msg.GroupID = payload.Accept.Invitation.GroupID
+//			}
+//		} else {
+//			return false, 208, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Accept.OpUserID)
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_HungUp:
+//	case *open_im_sdk.SignalReq_Reject:
+//		reject := open_im_sdk.SignalResp_Reject{&open_im_sdk.SignalRejectReply{}}
+//		resp.Payload = &reject
+//		msg.OfflinePushInfo = payload.Reject.OfflinePushInfo
+//		msg.SendID = payload.Reject.OpUserID
+//		msg.SenderPlatformID = payload.Reject.Invitation.PlatformID
+//		msg.SessionType = payload.Reject.Invitation.SessionType
+//		if len(payload.Reject.Invitation.InviteeUserIDList) > 0 {
+//			switch payload.Reject.Invitation.SessionType {
+//			case constant.SingleChatType:
+//				msg.RecvID = payload.Reject.Invitation.InviterUserID
+//			case constant.GroupChatType:
+//				msg.GroupID = payload.Reject.Invitation.GroupID
+//			}
+//		} else {
+//			return false, 209, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Reject.OpUserID)
+//		return true, 0, "", &resp, &msg
+//	}
+//	return false, 210, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//}

internal/msg_gateway/gate/ws_server.go

@@ -0,0 +1,285 @@
+package gate
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/utils"
+	"bytes"
+	"encoding/gob"
+	"github.com/garyburd/redigo/redis"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+type UserConn struct {
+	*websocket.Conn
+	w *sync.Mutex
+}
+type WServer struct {
+	wsAddr       string
+	wsMaxConnNum int
+	wsUpGrader   *websocket.Upgrader
+	wsConnToUser map[*UserConn]map[string]string
+	wsUserToConn map[string]map[string]*UserConn
+}
+
+func (ws *WServer) onInit(wsPort int) {
+	ws.wsAddr = ":" + utils.IntToString(wsPort)
+	ws.wsMaxConnNum = config.Config.LongConnSvr.WebsocketMaxConnNum
+	ws.wsConnToUser = make(map[*UserConn]map[string]string)
+	ws.wsUserToConn = make(map[string]map[string]*UserConn)
+	ws.wsUpGrader = &websocket.Upgrader{
+		HandshakeTimeout: time.Duration(config.Config.LongConnSvr.WebsocketTimeOut) * time.Second,
+		ReadBufferSize:   config.Config.LongConnSvr.WebsocketMaxMsgLen,
+		CheckOrigin:      func(r *http.Request) bool { return true },
+	}
+}
+
+func (ws *WServer) run() {
+	http.HandleFunc("/", ws.wsHandler)         //Get request from client to handle by wsHandler
+	err := http.ListenAndServe(ws.wsAddr, nil) //Start listening
+	if err != nil {
+		log.ErrorByKv("Ws listening err", "", "err", err.Error())
+	}
+}
+
+func (ws *WServer) wsHandler(w http.ResponseWriter, r *http.Request) {
+	if ws.headerCheck(w, r) {
+		query := r.URL.Query()
+		conn, err := ws.wsUpGrader.Upgrade(w, r, nil) //Conn is obtained through the upgraded escalator
+		if err != nil {
+			log.ErrorByKv("upgrade http conn err", "", "err", err)
+			return
+		} else {
+			//Connection mapping relationship,
+			//userID+" "+platformID->conn
+
+			//Initialize a lock for each user
+			newConn := &UserConn{conn, new(sync.Mutex)}
+			ws.addUserConn(query["sendID"][0], int32(utils.StringToInt64(query["platformID"][0])), newConn, query["token"][0])
+			go ws.readMsg(newConn)
+		}
+	}
+}
+
+func (ws *WServer) readMsg(conn *UserConn) {
+	for {
+		messageType, msg, err := conn.ReadMessage()
+		if messageType == websocket.PingMessage {
+			log.NewInfo("", "this is a  pingMessage")
+		}
+		if err != nil {
+			uid, platform := ws.getUserUid(conn)
+			log.ErrorByKv("WS ReadMsg error", "", "userIP", conn.RemoteAddr().String(), "userUid", uid, "platform", platform, "error", err.Error())
+			ws.delUserConn(conn)
+			return
+		} else {
+			//log.ErrorByKv("test", "", "msgType", msgType, "userIP", conn.RemoteAddr().String(), "userUid", ws.getUserUid(conn))
+		}
+		ws.msgParse(conn, msg)
+		//ws.writeMsg(conn, 1, chat)
+	}
+
+}
+func (ws *WServer) writeMsg(conn *UserConn, a int, msg []byte) error {
+	conn.w.Lock()
+	defer conn.w.Unlock()
+	return conn.WriteMessage(a, msg)
+
+}
+func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int32, newConn *UserConn, token string, operationID string) {
+	switch config.Config.MultiLoginPolicy {
+	case constant.AllLoginButSameTermKick:
+		if oldConnMap, ok := ws.wsUserToConn[uid]; ok { // user->map[platform->conn]
+			if oldConn, ok := oldConnMap[constant.PlatformIDToName(platformID)]; ok {
+				log.NewDebug(operationID, uid, platformID, "kick old conn")
+				ws.sendKickMsg(oldConn, newConn)
+				m, err := db.DB.GetTokenMapByUidPid(uid, constant.PlatformIDToName(platformID))
+				if err != nil && err != redis.ErrNil {
+					log.NewError(operationID, "get token from redis err", err.Error())
+					return
+				}
+				if m == nil {
+					log.NewError(operationID, "get token from redis err", "m is nil")
+					return
+				}
+				for k, _ := range m {
+					if k != token {
+						m[k] = constant.KickedToken
+					}
+				}
+				log.NewDebug(operationID, "get map is ", m)
+				err = db.DB.SetTokenMapByUidPid(uid, platformID, m)
+				if err != nil {
+					log.NewError(operationID, "SetTokenMapByUidPid err", err.Error())
+					return
+				}
+				err = oldConn.Close()
+				delete(oldConnMap, constant.PlatformIDToName(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[constant.PlatformIDToName(platformID)])
+			}
+
+		} else {
+			log.NewDebug(operationID, "no other conn", ws.wsUserToConn, uid, platformID)
+		}
+
+	case constant.SingleTerminalLogin:
+	case constant.WebAndOther:
+	}
+}
+func (ws *WServer) sendKickMsg(oldConn, newConn *UserConn) {
+	mReply := Resp{
+		ReqIdentifier: constant.WSKickOnlineMsg,
+		ErrCode:       constant.ErrTokenInvalid.ErrCode,
+		ErrMsg:        constant.ErrTokenInvalid.ErrMsg,
+	}
+	var b bytes.Buffer
+	enc := gob.NewEncoder(&b)
+	err := enc.Encode(mReply)
+	if err != nil {
+		log.NewError(mReply.OperationID, mReply.ReqIdentifier, mReply.ErrCode, mReply.ErrMsg, "Encode Msg error", oldConn.RemoteAddr().String(), newConn.RemoteAddr().String(), err.Error())
+		return
+	}
+	err = ws.writeMsg(oldConn, websocket.BinaryMessage, b.Bytes())
+	if err != nil {
+		log.NewError(mReply.OperationID, mReply.ReqIdentifier, mReply.ErrCode, mReply.ErrMsg, "WS WriteMsg error", oldConn.RemoteAddr().String(), newConn.RemoteAddr().String(), err.Error())
+	}
+}
+func (ws *WServer) addUserConn(uid string, platformID int32, conn *UserConn, token string) {
+	rwLock.Lock()
+	defer rwLock.Unlock()
+	operationID := utils.OperationIDGenerator()
+	ws.MultiTerminalLoginChecker(uid, platformID, conn, token, operationID)
+	if oldConnMap, ok := ws.wsUserToConn[uid]; ok {
+		oldConnMap[constant.PlatformIDToName(platformID)] = conn
+		ws.wsUserToConn[uid] = oldConnMap
+		log.Debug(operationID, "user not first come in, add conn ", uid, platformID, conn, oldConnMap)
+	} else {
+		i := make(map[string]*UserConn)
+		i[constant.PlatformIDToName(platformID)] = conn
+		ws.wsUserToConn[uid] = i
+		log.Debug(operationID, "user first come in, new user, conn", uid, platformID, conn, ws.wsUserToConn[uid])
+	}
+	if oldStringMap, ok := ws.wsConnToUser[conn]; ok {
+		oldStringMap[constant.PlatformIDToName(platformID)] = uid
+		ws.wsConnToUser[conn] = oldStringMap
+	} else {
+		i := make(map[string]string)
+		i[constant.PlatformIDToName(platformID)] = uid
+		ws.wsConnToUser[conn] = i
+	}
+	count := 0
+	for _, v := range ws.wsUserToConn {
+		count = count + len(v)
+	}
+	log.Debug(operationID, "WS Add operation", "", "wsUser added", ws.wsUserToConn, "connection_uid", uid, "connection_platform", constant.PlatformIDToName(platformID), "online_user_num", len(ws.wsUserToConn), "online_conn_num", count)
+	userCount = uint64(len(ws.wsUserToConn))
+
+}
+
+func (ws *WServer) delUserConn(conn *UserConn) {
+	rwLock.Lock()
+	defer rwLock.Unlock()
+	var platform, uid string
+	if oldStringMap, ok := ws.wsConnToUser[conn]; ok {
+		for k, v := range oldStringMap {
+			platform = k
+			uid = v
+		}
+		if oldConnMap, ok := ws.wsUserToConn[uid]; ok {
+			delete(oldConnMap, platform)
+			ws.wsUserToConn[uid] = oldConnMap
+			if len(oldConnMap) == 0 {
+				delete(ws.wsUserToConn, uid)
+			}
+			count := 0
+			for _, v := range ws.wsUserToConn {
+				count = count + len(v)
+			}
+			log.WarnByKv("WS delete operation", "", "wsUser deleted", ws.wsUserToConn, "disconnection_uid", uid, "disconnection_platform", platform, "online_user_num", len(ws.wsUserToConn), "online_conn_num", count)
+		} else {
+			log.WarnByKv("WS delete operation", "", "wsUser deleted", ws.wsUserToConn, "disconnection_uid", uid, "disconnection_platform", platform, "online_user_num", len(ws.wsUserToConn))
+		}
+		userCount = uint64(len(ws.wsUserToConn))
+		delete(ws.wsConnToUser, conn)
+
+	}
+	err := conn.Close()
+	if err != nil {
+		log.ErrorByKv("close err", "", "uid", uid, "platform", platform)
+
+	}
+
+}
+
+func (ws *WServer) getUserConn(uid string, platform string) *UserConn {
+	rwLock.RLock()
+	defer rwLock.RUnlock()
+	if connMap, ok := ws.wsUserToConn[uid]; ok {
+		if conn, flag := connMap[platform]; flag {
+			return conn
+		}
+	}
+	return nil
+}
+func (ws *WServer) getSingleUserAllConn(uid string) map[string]*UserConn {
+	rwLock.RLock()
+	defer rwLock.RUnlock()
+	if connMap, ok := ws.wsUserToConn[uid]; ok {
+		return connMap
+	}
+	return nil
+}
+func (ws *WServer) getUserUid(conn *UserConn) (uid, platform string) {
+	rwLock.RLock()
+	defer rwLock.RUnlock()
+
+	if stringMap, ok := ws.wsConnToUser[conn]; ok {
+		for k, v := range stringMap {
+			platform = k
+			uid = v
+		}
+		return uid, platform
+	}
+	return "", ""
+}
+func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request) bool {
+	status := http.StatusUnauthorized
+	query := r.URL.Query()
+	if len(query["token"]) != 0 && len(query["sendID"]) != 0 && len(query["platformID"]) != 0 {
+		if ok, err, msg := token_verify.WsVerifyToken(query["token"][0], query["sendID"][0], query["platformID"][0]); !ok {
+			e := err.(*constant.ErrInfo)
+			log.ErrorByKv("Token verify failed", "", "query", query, msg)
+			w.Header().Set("Sec-Websocket-Version", "13")
+			http.Error(w, e.ErrMsg, int(e.ErrCode))
+			return false
+		} else {
+			log.InfoByKv("Connection Authentication Success", "", "token", query["token"][0], "userID", query["sendID"][0])
+			return true
+		}
+	} else {
+		log.ErrorByKv("Args err", "", "query", query)
+		w.Header().Set("Sec-Websocket-Version", "13")
+		http.Error(w, http.StatusText(status), status)
+		return false
+	}
+}
+func genMapKey(uid string, platformID int32) string {
+	return uid + " " + constant.PlatformIDToName(platformID)
+}