def test_retryqueue_not_idle_with_messages(
mock_matrix: MatrixTransport, retry_interval_initial: float
) -> None:
""" Ensure ``RetryQueue``s don't become idle while messages remain in the internal queue. """
retry_queue = mock_matrix._get_retrier(Address(factories.HOP1))
idle_after = RETRY_QUEUE_IDLE_AFTER * retry_interval_initial
queue_identifier = QueueIdentifier(
recipient=Address(factories.HOP1),
canonical_identifier=CANONICAL_IDENTIFIER_UNORDERED_QUEUE,
)
retry_queue.enqueue(queue_identifier, [make_message()])
# Without the `all_peers_reachable` fixture, the default reachability will be `UNREACHABLE`
# therefore the message will remain in the internal queue indefinitely.
# Wait for the idle timeout to expire
gevent.sleep(idle_after + (retry_interval_initial * 5))
assert not retry_queue.greenlet.ready()
assert retry_queue._idle_since == 0
assert not retry_queue.is_idle
retry_queue_2 = mock_matrix._get_retrier(Address(factories.HOP1))
# The first queue has never become idle, therefore the same object must be returned
assert retry_queue is retry_queue_2
def test_retryqueue_idle_terminate(mock_matrix: MatrixTransport, retry_interval_initial: float):
""" Ensure ``RetryQueue``s exit if they are idle for too long. """
retry_queue = mock_matrix._get_retrier(Address(factories.HOP1))
idle_after = RETRY_QUEUE_IDLE_AFTER * retry_interval_initial
with Timeout(idle_after + (retry_interval_initial * 5)):
# Retry
while not gevent.joinall({retry_queue.greenlet}, idle_after / 2, raise_error=True):
pass
assert retry_queue.greenlet.ready()
assert retry_queue._idle_since == RETRY_QUEUE_IDLE_AFTER
assert retry_queue.is_idle
retry_queue_2 = mock_matrix._get_retrier(Address(factories.HOP1))
# Since the initial RetryQueue has exited `get_retrier()` must return a new instance
assert retry_queue_2 is not retry_queue
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()
