def _receive_message(self, message):
self.log.info(
'MESSAGE RECEIVED',
node=pex(self._raiden_service.address),
message=message,
message_sender=pex(message.sender),
)
try:
if on_udp_message(self._raiden_service, message):
# TODO: Maybe replace with Matrix read receipts.
# Unfortunately those work on an 'up to' basis, not on individual messages
# which means that message order is important which isn't guaranteed between
# federated servers.
# See: https://matrix.org/docs/spec/client_server/r0.3.0.html#id57
delivered_message = Delivered(message.message_identifier)
self._raiden_service.sign(delivered_message)
self._send_immediate(message.sender, json.dumps(delivered_message.to_dict()))
except (InvalidAddress, UnknownAddress, UnknownTokenAddress):
self.log.warn('Exception while processing message', exc_info=True)
return
self.log.debug(
'DELIVERED',
node=pex(self._raiden_service.address),
to=pex(message.sender),
message_identifier=message.message_identifier,
)
def receive_message(self, message: Message):
""" Handle a Raiden protocol message.
The protocol requires durability of the messages. The UDP transport
relies on the node's WAL for durability. The message will be converted
to a state change, saved to the WAL, and *processed* before the
durability is confirmed, which is a stronger property than what is
required of any transport.
"""
self.message_handler.on_message(self.raiden, message)
# Sending Delivered after the message is decoded and *processed*
# gives a stronger guarantee than what is required from a
# transport.
#
# Alternatives are, from weakest to strongest options:
# - Just save it on disk and asynchronously process the messages
# - Decode it, save to the WAL, and asynchronously process the
# state change
# - Decode it, save to the WAL, and process it (the current
# implementation)
delivered_message = Delivered(message.message_identifier)
self.raiden.sign(delivered_message)
self.maybe_send(
message.sender,
delivered_message,
)
def test_signature_without_secret():
dict_msg = {
"type": "Delivered",
"delivered_message_identifier": 15646344508401696016
}
message = Delivered.from_dict_unsigned(dict_msg)
message.sign(signer)
data_was_signed = message._data_to_sign()
print(message.signature.hex())
assert recover(data_was_signed, message.signature) == to_canonical_address(
"0x09fcbe7ceb49c944703b4820e29b0541edfe7e82")
def test_delivered():
dict_msg = {
"type": "Delivered",
"delivered_message_identifier": 18237677588114994956
}
message = Delivered.from_dict_unsigned(dict_msg)
message.sign(signer)
data_was_signed = message._data_to_sign()
print("Delivered signature: " + message.signature.hex())
assert recover(data_was_signed, message.signature) == to_canonical_address(
"0x7ca28d3d760b4aa2b79e8d42cbdc187c7df9af40")
def _receive_message(self, message):
self.log.info(
'MESSAGE RECEIVED',
node=pex(self._raiden_service.address),
message=message,
sender=pex(message.sender),
)
try:
if on_message(self._raiden_service, message) and not isinstance(message, Processed):
# TODO: Maybe replace with Matrix read receipts.
# Unfortunately those work on an 'up to' basis, not on individual messages
# which means that message order is important which isn't guaranteed between
# federated servers.
# See: https://matrix.org/docs/spec/client_server/r0.3.0.html#id57
delivered_message = Delivered(message.message_identifier)
self._raiden_service.sign(delivered_message)
self._send_immediate(message.sender, json.dumps(delivered_message.to_dict()))
except (InvalidAddress, UnknownAddress, UnknownTokenAddress):
self.log.warn('Exception while processing message', exc_info=True)
return
def ping_pong_message_success(transport0, transport1):
queueid0 = QueueIdentifier(
recipient=transport0._raiden_service.address,
channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,
)
queueid1 = QueueIdentifier(
recipient=transport1._raiden_service.address,
channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,
)
received_messages0 = transport0._raiden_service.message_handler.bag
received_messages1 = transport1._raiden_service.message_handler.bag
msg_id = random.randint(1e5, 9e5)
ping_message = Processed(message_identifier=msg_id)
pong_message = Delivered(delivered_message_identifier=msg_id)
transport0._raiden_service.sign(ping_message)
transport1._raiden_service.sign(pong_message)
transport0.send_async(queueid1, ping_message)
with Timeout(20, exception=False):
all_messages_received = False
while not all_messages_received:
all_messages_received = (ping_message in received_messages1
and pong_message in received_messages0)
gevent.sleep(0.1)
assert ping_message in received_messages1
assert pong_message in received_messages0
transport0._raiden_service.sign(pong_message)
transport1._raiden_service.sign(ping_message)
transport1.send_async(queueid0, ping_message)
with Timeout(20, exception=False):
all_messages_received = False
while not all_messages_received:
all_messages_received = (ping_message in received_messages0
and pong_message in received_messages1)
gevent.sleep(0.1)
assert ping_message in received_messages0
assert pong_message in received_messages1
return all_messages_received
def send_delivered_for(message: SignedMessage):
delivered_message = Delivered(message.message_identifier)
self._raiden_service.sign(delivered_message)
self._send_raw(message.sender, JSONSerializer.serialize(delivered_message))
