def test_processed(): message = Processed(message_identifier=MessageID(18237677588114994956)) message.sign(signer) data_was_signed = message._data_to_sign() print("Processed signature: " + message.signature.hex()) assert recover(data_was_signed, message.signature) == to_canonical_address( "0x7ca28d3d760b4aa2b79e8d42cbdc187c7df9af40")
def test_matrix_cross_server_with_load_balance(matrix_transports, retry_interval): transport0, transport1, transport2 = matrix_transports received_messages0 = set() received_messages1 = set() received_messages2 = set() message_handler0 = MessageHandler(received_messages0) message_handler1 = MessageHandler(received_messages1) message_handler2 = MessageHandler(received_messages2) raiden_service0 = MockRaidenService(message_handler0) raiden_service1 = MockRaidenService(message_handler1) raiden_service2 = MockRaidenService(message_handler2) transport0.start(raiden_service0, message_handler0, '') transport1.start(raiden_service1, message_handler1, '') transport2.start(raiden_service2, message_handler2, '') transport0.start_health_check(raiden_service1.address) transport0.start_health_check(raiden_service2.address) transport1.start_health_check(raiden_service0.address) transport1.start_health_check(raiden_service2.address) transport2.start_health_check(raiden_service0.address) transport2.start_health_check(raiden_service1.address) queueid1 = QueueIdentifier( recipient=raiden_service1.address, channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE, ) queueid2 = QueueIdentifier( recipient=raiden_service2.address, channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE, ) message = Processed(0) message.sign(raiden_service0.private_key) transport0.send_async(queueid1, message) transport0.send_async(queueid2, message) with Timeout(retry_interval * 10, exception=False): while not ( len(received_messages0) == 1 and len(received_messages1) == 1 and len(received_messages2) == 1 ): gevent.sleep(.1) assert len(received_messages0) == 2 assert len(received_messages1) == 1 assert len(received_messages2) == 1 transport0.stop() transport1.stop() transport2.stop() transport0.get() transport1.get() transport2.get()
def test_processed(): message_identifier = random.randint(0, constants.UINT64_MAX) processed_message = Processed(message_identifier=message_identifier) processed_message.sign(signer) assert processed_message.sender == ADDRESS assert processed_message.message_identifier == message_identifier data = processed_message.encode() decoded_processed_message = decode(data) assert decoded_processed_message.message_identifier == message_identifier assert processed_message.message_identifier == message_identifier assert decoded_processed_message.sender == processed_message.sender assert sha3(decoded_processed_message.encode()) == sha3(data)
def test_processed(): message_identifier = random.randint(0, UINT64_MAX) processed_message = Processed(message_identifier) processed_message.sign(PRIVKEY, UNIT_CHAIN_ID) assert processed_message.sender == ADDRESS assert processed_message.message_identifier == message_identifier data = processed_message.encode() decoded_processed_message = decode(data) assert decoded_processed_message.message_identifier == message_identifier assert processed_message.message_identifier == message_identifier assert decoded_processed_message.sender == processed_message.sender assert sha3(decoded_processed_message.encode()) == sha3(data)
def test_processed(): message_identifier = random.randint(0, constants.UINT64_MAX) processed_message = Processed(message_identifier) processed_message.sign(PRIVKEY) assert processed_message.sender == ADDRESS assert processed_message.message_identifier == message_identifier data = processed_message.encode() decoded_processed_message = decode(data) assert decoded_processed_message.message_identifier == message_identifier assert processed_message.message_identifier == message_identifier assert decoded_processed_message.sender == processed_message.sender assert sha3(decoded_processed_message.encode()) == sha3(data)
def test_matrix_message_retry( local_matrix_servers, private_rooms, retry_interval, retries_before_backoff, ): """ Test the retry mechanism implemented into the matrix client. The test creates a transport and sends a message. Given that the receiver was online, the initial message is sent but the receiver doesn't respond in time and goes offline. The retrier should then wait for the `retry_interval` duration to pass and send the message again but this won't work because the receiver is offline. Once the receiver comes back again, the message should be sent again. """ partner_address = make_address() transport = MatrixTransport({ 'discovery_room': 'discovery', 'retries_before_backoff': retries_before_backoff, 'retry_interval': retry_interval, 'server': local_matrix_servers[0], 'server_name': local_matrix_servers[0].netloc, 'available_servers': [], 'private_rooms': private_rooms, }) transport._send_raw = MagicMock() raiden_service = MockRaidenService(None) transport.start( raiden_service, raiden_service.message_handler, None, ) transport.log = MagicMock() # Receiver is online transport._address_to_presence[partner_address] = UserPresence.ONLINE queueid = QueueIdentifier( recipient=partner_address, channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE, ) chain_state = raiden_service.wal.state_manager.current_state retry_queue: _RetryQueue = transport._get_retrier(partner_address) assert bool(retry_queue), 'retry_queue not running' # Send the initial message message = Processed(0) message.sign(transport._raiden_service.private_key) chain_state.queueids_to_queues[queueid] = [message] retry_queue.enqueue_global(message) gevent.sleep(1) transport._send_raw.call_count = 1 # Receiver goes offline transport._address_to_presence[partner_address] = UserPresence.OFFLINE gevent.sleep(retry_interval) transport.log.debug.assert_called_with( 'Partner not reachable. Skipping.', partner=pex(partner_address), status=UserPresence.OFFLINE, ) # Retrier did not call send_raw given that the receiver is still offline assert transport._send_raw.call_count == 1 # Receiver comes back online transport._address_to_presence[partner_address] = UserPresence.ONLINE gevent.sleep(retry_interval) # Retrier now should have sent the message again assert transport._send_raw.call_count == 2 transport.stop() transport.get()
def test_matrix_message_sync( local_matrix_servers, private_rooms, retry_interval, retries_before_backoff, ): transport0 = MatrixTransport({ 'discovery_room': 'discovery', 'retries_before_backoff': retries_before_backoff, 'retry_interval': retry_interval, 'server': local_matrix_servers[0], 'server_name': local_matrix_servers[0].netloc, 'available_servers': [], 'private_rooms': private_rooms, }) transport1 = MatrixTransport({ 'discovery_room': 'discovery', 'retries_before_backoff': retries_before_backoff, 'retry_interval': retry_interval, 'server': local_matrix_servers[0], 'server_name': local_matrix_servers[0].netloc, 'available_servers': [], 'private_rooms': private_rooms, }) latest_auth_data = None received_messages = set() message_handler = MessageHandler(received_messages) raiden_service0 = MockRaidenService(message_handler) raiden_service1 = MockRaidenService(message_handler) raiden_service1.handle_state_change = MagicMock() transport0.start( raiden_service0, message_handler, None, ) transport1.start( raiden_service1, message_handler, None, ) gevent.sleep(1) latest_auth_data = f'{transport1._user_id}/{transport1._client.api.token}' update_transport_auth_data = ActionUpdateTransportAuthData(latest_auth_data) raiden_service1.handle_state_change.assert_called_with(update_transport_auth_data) transport0.start_health_check(transport1._raiden_service.address) transport1.start_health_check(transport0._raiden_service.address) queue_identifier = QueueIdentifier( recipient=transport1._raiden_service.address, channel_identifier=1, ) for i in range(5): message = Processed(i) message.sign(transport0._raiden_service.private_key) transport0.send_async( queue_identifier, message, ) gevent.sleep(2) assert len(received_messages) == 10 for i in range(5): assert any(getattr(m, 'message_identifier', -1) == i for m in received_messages) transport1.stop() assert latest_auth_data # Send more messages while the other end is offline for i in range(10, 15): message = Processed(i) message.sign(transport0._raiden_service.private_key) transport0.send_async( queue_identifier, message, ) # Should fetch the 5 messages sent while transport1 was offline transport1.start( transport1._raiden_service, message_handler, latest_auth_data, ) gevent.sleep(2) assert len(set(received_messages)) == 20 for i in range(10, 15): assert any(getattr(m, 'message_identifier', -1) == i for m in received_messages) transport0.stop() transport1.stop() transport0.get() transport1.get()
def test_matrix_message_sync( skip_if_not_matrix, local_matrix_server, private_rooms, retry_interval, retries_before_backoff, ): transport0 = MatrixTransport({ 'discovery_room': 'discovery', 'retries_before_backoff': retries_before_backoff, 'retry_interval': retry_interval, 'server': local_matrix_server, 'server_name': 'matrix.local.raiden', 'available_servers': [], 'private_rooms': private_rooms, }) transport1 = MatrixTransport({ 'discovery_room': 'discovery', 'retries_before_backoff': retries_before_backoff, 'retry_interval': retry_interval, 'server': local_matrix_server, 'server_name': 'matrix.local.raiden', 'available_servers': [], 'private_rooms': private_rooms, }) latest_sync_token = None received_messages = set() def hook(sync_token): nonlocal latest_sync_token latest_sync_token = sync_token class MessageHandler: def on_message(self, _, message): nonlocal received_messages received_messages.add(message) transport0._client.set_post_sync_hook(hook) message_handler = MessageHandler() raiden_service0 = MockRaidenService(message_handler) raiden_service1 = MockRaidenService(message_handler) raiden_service1.handle_state_change = MagicMock() transport0.start( raiden_service0, message_handler, None, ) transport1.start( raiden_service1, message_handler, None, ) transport0.start_health_check(transport1._raiden_service.address) transport1.start_health_check(transport0._raiden_service.address) queue_identifier = QueueIdentifier( recipient=transport1._raiden_service.address, channel_identifier=1, ) for i in range(5): message = Processed(i) message.sign(transport0._raiden_service.private_key) transport0.send_async( queue_identifier, message, ) gevent.sleep(2) latest_sync_token = f'{transport1._user_id}/{latest_sync_token}' update_transport_sync_token = ActionUpdateTransportSyncToken(latest_sync_token) raiden_service1.handle_state_change.assert_called_with(update_transport_sync_token) assert len(received_messages) == 10 for i in range(5): assert any(getattr(m, 'message_identifier', -1) == i for m in received_messages) transport1.stop() assert latest_sync_token # Send more messages while the other end is offline for i in range(10, 15): message = Processed(i) message.sign(transport0._raiden_service.private_key) transport0.send_async( queue_identifier, message, ) # Should fetch the 5 messages sent while transport1 was offline transport1.start( transport1._raiden_service, message_handler, latest_sync_token, ) gevent.sleep(2) assert len(set(received_messages)) == 20 for i in range(10, 15): assert any(getattr(m, 'message_identifier', -1) == i for m in received_messages) transport0.stop() transport1.stop()