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))