def send_msg(self, dat):
"""
(internal use) send the message to the core node
:param dat:
:return query_id or None:
"""
if KeyType.domain_id not in dat or KeyType.source_user_id not in dat:
self.logger.warn("Message must include domain_id and source_id")
print(">>>>>1")
return None
try:
if self.is_secure_connection:
msg = message_key_types.make_message(
PayloadType.Type_encrypted_msgpack,
dat,
key_name=self.aes_key_name)
else:
msg = message_key_types.make_message(PayloadType.Type_msgpack,
dat)
self.connection.sendall(msg)
except Exception as e:
self.logger.error(traceback.format_exc())
print(">>>>>2", traceback.format_exc())
return None
return self.query_id
def direct_send_to_user(sock, msg, name=None):
if name is None:
sock.sendall(
message_key_types.make_message(PayloadType.Type_msgpack, msg))
else:
sock.sendall(
message_key_types.make_message(PayloadType.Type_encrypted_msgpack,
msg,
key_name=name))
def test_make_message2():
"""
"""
data = {
message_key_types.KeyType.command: MsgType.MESSAGE,
message_key_types.KeyType.asset_group_id: "asset_group_id_001",
message_key_types.KeyType.source_user_id: "source_user_id_12345",
message_key_types.KeyType.query_id: "query_id_67890",
message_key_types.KeyType.status: bbc_error.ESUCCESS,
}
message = message_key_types.make_message(
message_key_types.PayloadType.Type_msgpack, data, 0)
# print(message)
assert (message[:message_key_types.Message.HEADER_LEN] ==
b'\x00\x02\x00\x00\x00\x00\x00S')
msg_obj = message_key_types.Message()
msg_obj.recv(bytes(message))
parsed_data = msg_obj.parse()
assert (msg_obj.payload_type == message_key_types.PayloadType.Type_msgpack)
assert (msg_obj.format_version == 0)
assert (msg_obj.msg_len == 83) # 'S' == 83
print(parsed_data)
assert (parsed_data[message_key_types.KeyType.command] == MsgType.MESSAGE)
assert (_bytes_to_str(parsed_data[
message_key_types.KeyType.asset_group_id]) == "asset_group_id_001")
assert (_bytes_to_str(parsed_data[
message_key_types.KeyType.source_user_id]) == "source_user_id_12345")
assert (_bytes_to_str(
parsed_data[message_key_types.KeyType.query_id]) == "query_id_67890")
assert (
parsed_data[message_key_types.KeyType.status] == bbc_error.ESUCCESS)
def test_make_message():
"""
"""
data = {}
message = message_key_types.make_message(
message_key_types.PayloadType.Type_msgpack, data, 0)
# print(message)
assert (message == b'\x00\x02\x00\x00\x00\x00\x00\x01\x80')
assert (message[:message_key_types.Message.HEADER_LEN] ==
b'\x00\x02\x00\x00\x00\x00\x00\x01')
def send_msg(self, dat):
"""
(internal use) send the message to the core node
:param dat:
:return:
"""
if KeyType.asset_group_id not in dat or KeyType.source_user_id not in dat:
self.logger.warn(
"Message must include asset_group_id and source_id")
return False
try:
msg = message_key_types.make_message(PayloadType.Type_msgpack, dat)
self.connection.sendall(msg)
except Exception as e:
self.logger.error(e)
return False
return True
def send_message_in_network(self, nodeinfo, payload_type, msg):
"""
Send message over a domain network
:param nodeinfo: NodeInfo object
:param payload_type: PayloadType value
:param msg: data body
:return:
"""
data_to_send = message_key_types.make_message(payload_type, msg)
if len(data_to_send) > TCP_THRESHOLD_SIZE:
send_data_by_tcp(ipv4=nodeinfo.ipv4,
ipv6=nodeinfo.ipv6,
port=nodeinfo.port,
msg=data_to_send)
return
if nodeinfo.ipv4 != "":
self.socket_udp.sendto(data_to_send,
(nodeinfo.ipv4, nodeinfo.port))
return
if nodeinfo.ipv6 != "":
self.socket_udp6.sendto(data_to_send,
(nodeinfo.ipv6, nodeinfo.port))
def send_message_in_network(self,
nodeinfo=None,
payload_type=PayloadType.Type_any,
domain_id=None,
msg=None):
"""
Send message over a domain network
:param nodeinfo: NodeInfo object
:param payload_type: PayloadType value
:param domain_id: domain to send in
:param msg: data body
:return:
"""
if nodeinfo is None:
if domain_id not in self.domains:
return False
if msg[KeyType.destination_node_id] not in self.domains[domain_id][
'neighbor'].nodeinfo_list:
return False
nodeinfo = self.domains[domain_id]['neighbor'].nodeinfo_list[msg[
KeyType.destination_node_id]]
msg[KeyType.
source_node_id] = self.domains[domain_id]['neighbor'].my_node_id
if payload_type == PayloadType.Type_any:
if nodeinfo.key_manager is not None and nodeinfo.key_manager.key_name is not None and \
nodeinfo.key_manager.key_name in message_key_types.encryptors:
payload_type = PayloadType.Type_encrypted_msgpack
else:
payload_type = PayloadType.Type_msgpack
if payload_type in [PayloadType.Type_msgpack, PayloadType.Type_binary]:
data_to_send = message_key_types.make_message(payload_type, msg)
elif payload_type == PayloadType.Type_encrypted_msgpack:
payload_type = PayloadType.Type_encrypted_msgpack
data_to_send = message_key_types.make_message(
payload_type, msg, key_name=nodeinfo.key_manager.key_name)
if data_to_send is None:
self.logger.error("Fail to encrypt message")
return False
else:
return False
if len(data_to_send) > TCP_THRESHOLD_SIZE:
send_data_by_tcp(ipv4=nodeinfo.ipv4,
ipv6=nodeinfo.ipv6,
port=nodeinfo.port,
msg=data_to_send)
self.stats.update_stats_increment("network", "send_msg_by_tcp", 1)
self.stats.update_stats_increment("network", "sent_data_size",
len(data_to_send))
return True
if nodeinfo.ipv6 is not None and self.socket_udp6 is not None:
self.socket_udp6.sendto(data_to_send,
(nodeinfo.ipv6, nodeinfo.port))
self.stats.update_stats_increment("network", "send_msg_by_udp6", 1)
self.stats.update_stats_increment("network", "sent_data_size",
len(data_to_send))
return True
if nodeinfo.ipv4 is not None and self.socket_udp is not None:
self.socket_udp.sendto(data_to_send,
(nodeinfo.ipv4, nodeinfo.port))
self.stats.update_stats_increment("network", "send_msg_by_udp4", 1)
self.stats.update_stats_increment("network", "sent_data_size",
len(data_to_send))
return True