def _send_msg(self, dat):
"""Send the message to the core node
Args:
dat (dict): message object to send
Returns:
bytes: query ID for request/response type message
"""
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")
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())
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 send_message_in_network(self, nodeinfo=None, payload_type=PayloadType.Type_any, domain_id=None, msg=None):
"""Send message over a domain network
Args:
nodeinfo (NodeInfo): NodeInfo object of the destination
payload_type (bytes): message format type
domain_id (bytes): target domain_id
msg (dict): message to send
Returns:
bool: True if successful
"""
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
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')
