Golang protocol.Message类代码示例

func (this *CacheComponent2) Dispatch2(msg *protocol.Message, flag bool) {
	cached := uint16(1 << 15)
	if (msg.Number & cached) != cached {
		return
	}
	msg.Number &= HEAD_RESET

	msg, err := this.MakeCacheMessage(msg)
	if err != nil {
		fmt.Println("CacheCompoennt Dispatch2 Error:" + err.Error())
		return
	}
	data1, err := msg.Encode()
	if err != nil {
		fmt.Println("CacheCompoennt Dispatch2 Error:", err)
		return
	}
	data2 := make([]byte, len(data1)+8)
	copy(data2[:8], msg.Data[0:8])
	copy(data2[8:], data1)

	snode_component.GetNodeComponent().Forward(stree_define.ADD_CACHE_ENTRY, msg.DestUuid, msg.DeviceId, data2)
	//if this message is a contact sync message, send it to root first.
	if (msg.Number == protocol.N_ACCOUNT_SYS || msg.DeviceId == 0) && flag {
		snode_component.GetNodeComponent().Forward(stree_define.BROADCAST_TO_CLIENT, msg.DestUuid, msg.DeviceId, data1)
	} else {
		GetDispatcherOutComponent().NPushBack(msg, flag)
	}
	return
}

func (this *DispatcherOutComponent) sendToClient2(msg *protocol.Message, forward bool, buffPool *buffpool.BuffPool) error {
	if msg == nil || buffPool == nil {
		err := errors.New("DispatcherOutComponent.sendToClient2() Error: invalid argument")
		fmt.Println(err.Error())
		return err
	}

	clientConnArr := make([]*model.Client, 0)
	if msg.Token > 0 {
		clientConn := buffPool.GetClient(msg.Number, msg.DestUuid, msg.DeviceId, msg.Token)
		if clientConn != nil && clientConn.Conn != nil {
			clientConnArr = append(clientConnArr, clientConn)
		}
		if (clientConnArr == nil || len(clientConnArr) <= 0) && forward && GetRunWithSnode().Flag {
			buf, err := msg.Encode()
			if err != nil {
				fmt.Println("DispatcherOutComponent.sendToClient2() Error: " + err.Error())
				fmt.Println("\n", time.Now().String(), "Not find user, not forward due to encode failed.", "\n")
				return err
			}
			snode_component.GetNodeComponent().Forward(stree_define.FORWARD, msg.DestUuid, msg.DeviceId, buf)
			return nil
		}
	} else if msg.Token == 0 && msg.DeviceId > 0 {
		clientConnArr = buffPool.QueryForDeviceId(msg.Number, msg.DestUuid, msg.DeviceId)
		if (clientConnArr == nil || len(clientConnArr) <= 0) && forward && GetRunWithSnode().Flag {
			buf, err := msg.Encode()
			if err != nil {
				fmt.Println("DispatcherOutComponent.sendToClient2() Error:" + err.Error())
				fmt.Println("\n", time.Now().String(), "Not find user, not forward due to encode failed.", "\n")
				return err
			}
			snode_component.GetNodeComponent().Forward(stree_define.FORWARD, msg.DestUuid, msg.DeviceId, buf)
			return nil
		}
	} else if msg.Token == 0 && msg.DeviceId == 0 {
		clientConnArr = buffPool.QueryForUuid(msg.Number, msg.DestUuid)
	}

	err := errors.New("DispatcherOutComponent.sendToClient2() Error: the client's connection not pass authorization yet")
	for _, client := range clientConnArr {
		if client == nil || client.Conn == nil {
			continue
		}
		if !this.checkConnActivity(client.Time, client, buffPool, msg.Number, msg.DestUuid, msg.DeviceId, msg.Token) {
			err := errors.New("DispatcherOutComponent.sendToClient2() Error: client's connection is not alive")
			fmt.Println(err.Error())
			continue
		}
		err2 := this.sendMessage(msg, client.Conn)
		if err2 != nil {
			err2 = errors.New("DispatcherOutComponent.sendToClient2() Error: can not send message to client's connection")
			fmt.Println(err.Error())
			continue
		}
	}
	return nil
}

func (this *NodeComponent) ForwardPush(msg *structure.Packet) {
	m := protocol.Message{}
	err := m.Decode(msg.Data)
	if err != nil {
		fmt.Println("NodeComponent Error:MSG Decode Failed", err)
		return
	}
	this.ForwardMsgs <- msg
}

func (this *CacheComponent2) MakeCacheMessage(msg *protocol.Message) (*protocol.Message, error) {
	data := make([]byte, 8+msg.DataLen)
	t := time.Now().UnixNano()
	binary.BigEndian.PutUint64(data[:8], uint64(t))
	msg.DataLen += 8
	msg.MsgType = protocol.MT_PUSH_WITH_RESPONSE
	copy(data[8:], msg.Data)
	msg.Data = data
	return msg, nil
}

func (this *NodeComponent) ReceiveMsg() {

	defer func() {
		if err := recover(); err != nil {
			fmt.Println("NodeComponent Error: " + err.(error).Error())
		}
	}()

	headbuff := make([]byte, define.PACKET_HEAD_LEN)
	for {

		var head structure.Head
		var Packet structure.Packet
		//如果无连接，尝试重新建立tcp连接
		if this.StreeConn == nil {
			this.ReConnect()
			continue
		}
		//从tcp连接中先读取头部信息
		n, err := this.StreeConn.Read(headbuff)
		//如果读取出错，则尝试重新建立tcp连接
		if n == 0 || n != define.PACKET_HEAD_LEN || err != nil {
			fmt.Println("NodeComponent Error:Read STree msg")
			this.ReConnect()
			continue
		}

		err = head.Decode(headbuff)
		if err != nil {
			fmt.Println("NodeComponent Error: Decode Stree msg")
			return
		}

		databuff := make([]byte, head.DataLen)
		//再从连接中读取剩余数据
		n, err = this.StreeConn.Read(databuff)
		if n == 0 || n != int(head.DataLen) || err != nil {
			fmt.Println("NodeComponent Error: Read Stree Data")
			this.ReConnect()
			continue
		}

		Packet.Head = head
		Packet.Data = databuff
		msg := protocol.Message{}
		//Packet.Data至少44位
		err = msg.Decode(Packet.Data)
		if err != nil {
			fmt.Println("NodeComponent Error:MSG Decode Failed", err)
			return
		}

		this.ReceiveMsgHandle(&Packet)
	}
}

func (this *DaughterHandler) ReceiveFromDaughter(conn *net.Conn) {
	for {
		//PACKET_HEAD_LEN = 19
		headBuf := make([]byte, define.PACKET_HEAD_LEN)
		//MAX_BUF = 2048
		data := make([]byte, define.MAX_BUF)
		//读取头部信息
		_, err := (*conn).Read(headBuf)
		if err != nil && err != io.EOF {
			fmt.Println(err.Error())
			continue
		} else if err == io.EOF {
			fmt.Println("\n", time.Now().String(), " In DaughterHander.ReceiverFromDaughter, connection ", (*conn).RemoteAddr(), " is invalid", "\n")
			(*conn).Close()
			return
		}
		head := structure.Head{}
		err = head.Decode(headBuf)
		if err != nil {
			err = errors.New("component: STree.Receive failed, can not decode the head buf, " + err.Error())
			fmt.Println(err.Error())
			continue
		}
		if head.DataLen > 0 {
			if int(head.DataLen) > len(data) {
				data = make([]byte, head.DataLen)
			}
			//从conn中读取Data[]部分
			_, err = (*conn).Read(data[:head.DataLen])
			if err != nil && err != io.EOF {
				fmt.Println("Got a error ", err)
				continue
			} else if err == io.EOF {
				fmt.Println("\n", time.Now().String(), " In DaughterHander.ReceiverFromDaughter, connection ", (*conn).RemoteAddr(), " is invalid", "\n")
				(*conn).Close()
				return
			}
		}

		packet := &structure.Packet{head, data[:head.DataLen]}
		if packet.Number == define.FORWARD {
			msg := push_protocol.Message{}
			err = msg.Decode(packet.Data)
			if err != nil {
				fmt.Println("MSG Decode Failed, ", err)
				return
			}
			fmt.Println("\n", time.Now().String(), " ReceiveFromDaughter, packet.Uuid: ", packet.Uuid, " msg.UserId: ", msg.UserId, " msg.DestId: ", msg.DestId, "\n")
		}
		this.Dispatch(packet, conn)
	}
}

func (this *DispatcherComponent) handleMTPublish(msg *protocol.Message, flag bool, buffPool *buffpool.BuffPool) error {
	if msg.DeviceId == 0 && flag && GetRunWithSnode().Flag {
		buf, err := msg.Encode()
		if err != nil {
			err = errors.New("DispatcherComponnet.handleMTPublish() Error: " + err.Error())
			fmt.Println(err.Error())
			return err
		}
		snode_component.GetNodeComponent().Forward(stree_define.BROADCAST_TO_CLIENT, msg.DestUuid, msg.DeviceId, buf)
		return nil
	} else {
		GetDispatcherOutComponent().NPushBack(msg, flag)
	}
	return nil
}

func (this *CacheComponent) Save(msg protocol.Message) error {
	this.CacheLock.Lock()
	defer this.CacheLock.Unlock()
	if this.Cache == nil {
		this.Cache = make(map[string]CacheDev, 0)
	}

	if _, ok := this.Cache[msg.DestUuid]; !ok {
		val := CacheDev{
			MDev: make(map[uint32]*CacheList, 0),
		}
		this.Cache[msg.DestUuid] = val
	}

	if _, ok := this.Cache[msg.DestUuid].MDev[msg.DeviceId]; !ok {
		val := &CacheList{
			List:  list.New(),
			Total: 0,
		}
		this.Cache[msg.DestUuid].MDev[msg.DeviceId] = val
	}

	this.Cache[msg.DestUuid].MDev[msg.DeviceId].Total++
	id := this.Cache[msg.DestUuid].MDev[msg.DeviceId].Total
	msg.DataLen = 4 + msg.DataLen
	buf := make([]byte, msg.DataLen)
	binary.BigEndian.PutUint32(buf[0:4], id)
	if len(msg.Data) > 0 {
		copy(buf[4:msg.DataLen], msg.Data)
	}
	msg.Data = buf

	msg.MsgType = protocol.MT_PUSH_WITH_RESPONSE
	msg.PushType = protocol.PT_PUSHSERVER
	msg.Number &= HEAD_RESET

	e := this.Cache[msg.DestUuid].MDev[msg.DeviceId].List.PushBack(CacheEntry{msg, id})
	if e == nil {
		err := errors.New("CacheComponent.Save() Error: can not save msg to list")
		fmt.Println(err.Error())
		return err
	}

	return nil
}

func sendResponse(conn *net.Conn, message *protocol.Message) error {
	if conn == nil || message == nil {
		err := errors.New("RegisterComponent sendResponse Error : the argument is invalid")
		return err
	}
	buffer, err := message.Encode()
	if err != nil {
		err = fmt.Errorf("RegisterComponent sendResposne Error: %v", err)
		return err
	}
	index := 0
	for index < len(buffer) {
		n, err := (*conn).Write(buffer[index:])
		index += n
		if index < len(buffer) && err != nil {
			return err
		}
	}
	return nil
}

func (this *NodeComponent) NoCacheForward(Uuid string, Data []byte) {
	Packet := GetPacket(define.FORWARD, Uuid, Data)

	buff, err := Packet.Encode()
	if err != nil {
		fmt.Println("NodeComponent Error:Encode No Cache Forward Packet")
		return
	}

	n, err := this.Write(buff)
	if n == 0 || err != nil {
		return
	}

	msg := protocol.Message{}
	err = msg.Decode(Packet.Data)
	if err != nil {
		fmt.Println("NodeComponent Error: MSG Decode Failed, ", err)
		return
	}
}

func (this *DispatcherOutComponent) sendMessage(msg *protocol.Message, conn *net.Conn) error {
	if msg == nil || conn == nil {
		err := errors.New("DispatcherOutComponent sendMessage() Error: invalid argument")
		fmt.Println(err.Error())
		return err
	}

	buf, err := msg.Encode()
	if err != nil {
		err = errors.New("DispatcherOutComponent sendMessage() Error: invalid argument " + err.Error())
		fmt.Println(err.Error())
		return err
	}

	n, err := (*conn).Write(buf)
	if err != nil {
		fmt.Println("\n", time.Now().String(), " Write buf to connection failed, the connection will be closed, n = ", n, err, "\n")
		(*conn).Close()
	}
	return nil
}

func (this *DaughterHandler) SendToDaughter() {
	for {
		//	fmt.Println("\n", time.Now().String(), " SendToDaughter Directly", "\n")
		//        packet := <-this.toDaughter
		//从toDaughter中接收数据
		packet := this.ToDaughterPop()
		//返回一个*net.Conn
		conn := GetSTree().UserMap.Get(packet.Uuid)
		if conn == nil && packet.Number == define.ALLOC_SERVER {
			fmt.Println("\n", "Geta Min LoadConn ", "\n")
			conn = GetSTree().GetMinLoadConn()
		}
		if conn == nil {
			err := errors.New("component: STree.SendToDaughter() failed, can not find user in user's list")
			fmt.Println(err.Error())
			fmt.Println("\n", "destID = ", packet.Uuid, "\n")
			continue
		}
		buf, err := packet.Encode()
		if err != nil {
			err = errors.New("component: STree.SendToDaughter() failed, can not get buf from packet, " + err.Error())
			fmt.Println(err.Error())
			continue
		}
		//向conn中写入Packet的buf
		_, err = (*conn).Write(buf)
		if err != nil {
			fmt.Println("\n", time.Now().String(), " in SendToDaughter, Got an error ", err, "\n")
			fmt.Println(err.Error())
			continue
		}
		msg := push_protocol.Message{}
		err = msg.Decode(packet.Data)
		if err != nil {
			fmt.Println("MSG Decode Failed, ", err)
			return
		}
		fmt.Println("\n", time.Now().String(), " SendToDaughter Directly OK, packet.Uuid: ", packet.Uuid, " msg.UserId: ", msg.UserId, " msg.DestId: ", msg.DestId, "\n")
	}
}

func (this *DispatcherOutComponent) sendToService2(msg *protocol.Message, forward bool, buffPool *buffpool.BuffPool) (*net.Conn, error) {
	if msg == nil || buffPool == nil {
		err := errors.New("DispatcherOutComponent.sendToService() Error: invalid argument")
		fmt.Println(err.Error())
		return nil, err
	}
	var conn *net.Conn
	if msg.DestUuid == P_UID {
		conn = buffPool.GetService(msg.Number)
	} else {
		conn = buffPool.QueryService(msg.Number, msg.DestUuid)
		if conn == nil && forward && GetRunWithSnode().Flag {
			buf, err := msg.Encode()
			if err != nil {
				fmt.Println(err)
				return nil, err
			}
			snode_component.GetNodeComponent().Forward(stree_define.FORWARD, msg.DestUuid, msg.DeviceId, buf)
			return nil, nil
		}
	}

	if conn == nil {
		err := errors.New("DispatcherOutComponent.sendToService() Error:  can not find dest server")
		fmt.Println(err.Error())
		return nil, err
	}

	err := this.sendMessage(msg, conn)
	if err != nil {
		err = errors.New("DispatcherOutComponent.sendToService() Error: can not send message to server's connection")
		fmt.Println(err.Error())
		return conn, err
	}
	if msg.MsgType == protocol.MT_PUBLISH {
		fmt.Println("\n", time.Now().String(), "MT_PUBLISH: sendToService2 Directly OK", "\n")
	}
	return conn, nil
}

func (this *DispatcherComponent) handleKeepAlive(msg *protocol.Message) error {
	if msg == nil {
		err := errors.New("DispatcherComponent.handleKeepAlive() Error: invalid argument")
		fmt.Println(err.Error())
		return err
	}
	buffPool := buffpool.GetBuffPool()
	err := buffPool.UpdateClientStatus(msg.Number, msg.UserUuid, msg.DeviceId, msg.Token, true)
	if err != nil {
		err = errors.New("DispatcherComponent.handleKeepAlive() Error: can not update client's connections status" + err.Error())
		fmt.Println(err.Error())
		return err
	}
	msg.PushType = protocol.PT_PUSHSERVER
	msg.UserUuid, msg.DestUuid = msg.DestUuid, msg.UserUuid
	GetDispatcherOutComponent().EPushBack(msg, false)
	return nil
}