def handle_delivered(chain_state: ChainState,
state_change: ReceiveDelivered) -> TransitionResult:
""" Check if the "Delivered" message exists in the global queue and delete if found."""
queueid = QueueIdentifier(state_change.sender,
CHANNEL_IDENTIFIER_GLOBAL_QUEUE)
inplace_delete_message_queue(chain_state, state_change, queueid)
return TransitionResult(chain_state, [])
def test_delivered_message_must_clean_unordered_messages(chain_id):
pseudo_random_generator = random.Random()
block_number = 10
our_address = factories.make_address()
recipient = factories.make_address()
channel_identifier = 1
message_identifier = random.randint(0, 2**16)
secret = factories.random_secret()
chain_state = state.ChainState(
pseudo_random_generator,
block_number,
our_address,
chain_id,
)
queue_identifier = QueueIdentifier(
recipient,
events.CHANNEL_IDENTIFIER_GLOBAL_QUEUE,
)
message = events.SendRevealSecret(
recipient,
channel_identifier,
message_identifier,
secret,
)
chain_state.queueids_to_queues[queue_identifier] = [message]
delivered_message = state_change.ReceiveDelivered(message_identifier)
iteration = node.handle_delivered(chain_state, delivered_message)
new_queue = iteration.new_state.queueids_to_queues.get(
queue_identifier, [])
assert not new_queue
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
number_of_received_messages0 = len(received_messages0)
number_of_received_messages1 = len(received_messages1)
message = Processed(message_identifier=number_of_received_messages0)
transport0._raiden_service.sign(message)
transport0.send_async(queueid1, message)
with Timeout(20):
all_messages_received = False
while not all_messages_received:
all_messages_received = (len(received_messages0)
== number_of_received_messages0 + 1
and len(received_messages1)
== number_of_received_messages1 + 1)
gevent.sleep(.1)
transport1._raiden_service.sign(message)
transport1.send_async(queueid0, message)
with Timeout(20):
all_messages_received = False
while not all_messages_received:
all_messages_received = (len(received_messages0)
== number_of_received_messages0 + 2
and len(received_messages1)
== number_of_received_messages1 + 2)
gevent.sleep(.1)
return all_messages_received
def test_delivered_message_must_clean_unordered_messages(chain_id):
pseudo_random_generator = random.Random()
block_number = 10
our_address = factories.make_address()
recipient = factories.make_address()
channel_identifier = 1
message_identifier = random.randint(0, 2**16)
secret = factories.random_secret()
chain_state = state.ChainState(
pseudo_random_generator=pseudo_random_generator,
block_number=block_number,
block_hash=factories.make_block_hash(),
our_address=our_address,
chain_id=chain_id,
)
queue_identifier = QueueIdentifier(
recipient,
events.CHANNEL_IDENTIFIER_GLOBAL_QUEUE,
)
# Regression test:
# The code delivered_message handler worked only with a queue of one
# element
first_message = events.SendSecretReveal(
recipient,
channel_identifier,
message_identifier,
secret,
)
second_message = events.SendSecretReveal(
recipient,
channel_identifier,
random.randint(0, 2**16),
secret,
)
chain_state.queueids_to_queues[queue_identifier] = [
first_message, second_message
]
delivered_message = state_change.ReceiveDelivered(recipient,
message_identifier)
iteration = node.handle_delivered(chain_state, delivered_message)
new_queue = iteration.new_state.queueids_to_queues.get(
queue_identifier, [])
assert first_message not in new_queue
def __init__(
self,
recipient: Address,
channel_identifier: ChannelID,
message_identifier: MessageID,
):
# Note that here and only here channel identifier can also be 0 which stands
# for the identifier of no channel (i.e. the global queue)
if not isinstance(channel_identifier, T_ChannelID):
raise ValueError('channel identifier must be of type T_ChannelIdentifier')
self.recipient = recipient
self.queue_identifier = QueueIdentifier(
recipient=recipient,
channel_identifier=channel_identifier,
)
self.message_identifier = message_identifier
def test_channel_closed_must_clear_ordered_messages(
chain_id,
chain_state,
payment_network_state,
token_network_state,
netting_channel_state,
):
recipient = netting_channel_state.partner_state.address
channel_identifier = netting_channel_state.identifier
message_identifier = random.randint(0, 2**16)
amount = 10
queue_identifier = QueueIdentifier(
recipient,
channel_identifier,
)
# Regression test:
# The code delivered_message handler worked only with a queue of one
# element
message = make_direct_transfer(
message_identifier=message_identifier,
registry_address=payment_network_state.address,
token=token_network_state.token_address,
channel_identifier=channel_identifier,
transferred_amount=amount,
recipient=recipient,
)
chain_state.queueids_to_queues[queue_identifier] = [message]
closed = state_change.ContractReceiveChannelClosed(
transaction_hash=EMPTY_HASH,
transaction_from=recipient,
token_network_identifier=token_network_state.address,
channel_identifier=channel_identifier,
block_number=1,
)
iteration = node.handle_state_change(
chain_state,
closed,
)
assert queue_identifier not in iteration.new_state.queueids_to_queues
def handle_contract_receive_channel_closed(
chain_state: ChainState,
state_change: StateChange,
) -> TransitionResult:
# cleanup queue for channel
channel_state = views.get_channelstate_by_token_network_identifier(
chain_state=chain_state,
token_network_id=state_change.token_network_identifier,
channel_id=state_change.channel_identifier,
)
if channel_state:
queue_id = QueueIdentifier(
recipient=channel_state.partner_state.address,
channel_identifier=state_change.channel_identifier,
)
if queue_id in chain_state.queueids_to_queues:
chain_state.queueids_to_queues.pop(queue_id)
return handle_token_network_action(chain_state=chain_state, state_change=state_change)
def test_matrix_cross_server(matrix_transports, retry_interval):
transport0, transport1 = matrix_transports
received_messages0 = set()
received_messages1 = set()
message_handler0 = MessageHandler(received_messages0)
message_handler1 = MessageHandler(received_messages1)
raiden_service0 = MockRaidenService(message_handler0)
raiden_service1 = MockRaidenService(message_handler1)
transport0.start(raiden_service0, message_handler0, '')
transport1.start(raiden_service1, message_handler1, '')
transport1.start_health_check(raiden_service0.address)
transport0.start_health_check(raiden_service1.address)
queueid = QueueIdentifier(
recipient=raiden_service1.address,
channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,
)
message = Processed(0)
message.sign(raiden_service0.private_key)
transport0.send_async(queueid, message)
with Timeout(retry_interval * 10, exception=False):
while not (len(received_messages0) == 1
and len(received_messages1) == 1):
gevent.sleep(.1)
assert len(received_messages0) == 1
assert len(received_messages1) == 1
transport0.stop()
transport1.stop()
transport0.get()
transport1.get()
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_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)
raiden_service0.sign(message)
transport0.send_async(queueid1, message)
transport0.send_async(queueid2, message)
with Timeout(retry_interval * 10, exception=False):
all_messages_received = False
while not all_messages_received:
all_messages_received = (
len(received_messages0) == 2 and
len(received_messages1) == 1 and
len(received_messages2) == 1
)
gevent.sleep(.1)
assert all_messages_received
transport0.stop()
transport1.stop()
transport2.stop()
transport0.get()
transport1.get()
transport2.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()
def test_matrix_message_sync(matrix_transports):
transport0, transport1 = matrix_transports
received_messages = set()
message_handler = MessageHandler(received_messages)
raiden_service0 = MockRaidenService(message_handler)
raiden_service1 = MockRaidenService(message_handler)
raiden_service1.handle_and_track_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_and_track_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(message_identifier=i)
transport0._raiden_service.sign(message)
transport0.send_async(
queue_identifier,
message,
)
with Timeout(40):
while not len(received_messages) == 10:
gevent.sleep(.1)
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(message_identifier=i)
transport0._raiden_service.sign(message)
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)