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 = 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_message_operators():
a = Processed(ADDRESS, HASH)
b = Processed(ADDRESS, HASH)
c = Processed(ADDRESS2, HASH2)
# pylint: disable=unneeded-not
assert a == b
assert not a != b
assert a != c
assert not a == c
def test_processed():
echo = sha3(b'random')
processed_message = Processed(ADDRESS, echo)
assert processed_message.echo == echo
data = processed_message.encode()
msghash = sha3(data)
decoded_processed_message = decode(data)
assert decoded_processed_message.echo == processed_message.echo
assert decoded_processed_message.sender == processed_message.sender
assert sha3(decoded_processed_message.encode()) == msghash
def test_processed():
processed_message_identifier = random.randint(0, UINT64_MAX)
processed_message = Processed(ADDRESS, processed_message_identifier)
assert processed_message.processed_message_identifier == processed_message_identifier
data = processed_message.encode()
decoded_processed_message = decode(data)
assert decoded_processed_message.processed_message_identifier == processed_message_identifier
assert processed_message.processed_message_identifier == processed_message_identifier
assert decoded_processed_message.sender == processed_message.sender
assert sha3(decoded_processed_message.encode()) == sha3(data)
def test_message_operators():
message_identifier = 10
message_identifier2 = 11
a = Processed(message_identifier)
b = Processed(message_identifier)
c = Processed(message_identifier2)
# pylint: disable=unneeded-not
assert a == b
assert not a != b
assert a != c
assert not a == c
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, 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_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_send_to_device(matrix_transports):
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)
transport1._receive_to_device = MagicMock()
transport0.start(raiden_service0, message_handler0, "")
transport1.start(raiden_service1, message_handler1, "")
transport0.start_health_check(raiden_service1.address)
transport1.start_health_check(raiden_service0.address)
message = Processed(message_identifier=1)
transport0._raiden_service.sign(message)
transport0.send_to_device(raiden_service1.address, message)
gevent.sleep(0.5)
transport1._receive_to_device.assert_not_called()
message = ToDevice(message_identifier=1)
transport0._raiden_service.sign(message)
transport0.send_to_device(raiden_service1.address, message)
gevent.sleep(0.5)
transport1._receive_to_device.assert_called()
def receive_message(self, message, message_id):
is_debug_log_enabled = log.isEnabledFor(logging.DEBUG)
if is_debug_log_enabled:
log.info('MESSAGE RECEIVED',
node=pex(self.raiden.address),
message_id=message_id,
message=message,
message_sender=pex(message.sender))
try:
on_udp_message(self.raiden, message)
# only send the Processed message if the message was handled without exceptions
processed_message = Processed(self.raiden.address, message_id)
self.maybe_send_processed(
message.sender,
processed_message,
)
except (InvalidAddress, UnknownAddress, UnknownTokenAddress) as e:
if is_debug_log_enabled:
log.warn(str(e))
else:
if is_debug_log_enabled:
log.debug(
'PROCESSED',
node=pex(self.raiden.address),
to=pex(message.sender),
message_id=message_id,
)
def test_matrix_send_global(
local_matrix_servers,
retries_before_backoff,
retry_interval,
private_rooms,
):
transport = MatrixTransport({
'global_rooms': ['discovery', 'monitoring'],
'retries_before_backoff': retries_before_backoff,
'retry_interval': retry_interval,
'server': local_matrix_servers[0],
'server_name': local_matrix_servers[0].netloc,
'available_servers': [local_matrix_servers[0]],
'private_rooms': private_rooms,
})
transport.start(MockRaidenService(None), MessageHandler(set()), '')
gevent.idle()
ms_room_name = transport._make_room_alias('monitoring')
ms_room = transport._global_rooms.get(ms_room_name)
assert isinstance(ms_room, Room)
ms_room.send_text = MagicMock(spec=ms_room.send_text)
for i in range(5):
message = Processed(i)
transport._raiden_service.sign(message)
transport.send_global(
'monitoring',
message,
)
gevent.idle()
assert ms_room.send_text.call_count == 5
# unknown room suffix is an error
with pytest.raises(AssertionError):
transport.send_global(
'unknown_suffix',
Processed(10),
)
transport.stop()
transport.get()
def handle_send_processed(
raiden: 'RaidenService',
processed_event: SendProcessed,
):
processed_message = Processed(raiden.address, processed_event.message_identifier)
raiden.sign(processed_message)
raiden.protocol.send_async(
processed_event.queue_name,
processed_event.recipient,
processed_message,
)
def test_matrix_send_global(
local_matrix_servers,
retries_before_backoff,
retry_interval,
private_rooms,
):
transport = MatrixTransport({
'global_rooms': ['discovery', MONITORING_BROADCASTING_ROOM],
'retries_before_backoff':
retries_before_backoff,
'retry_interval':
retry_interval,
'server':
local_matrix_servers[0],
'server_name':
local_matrix_servers[0].netloc,
'available_servers': [local_matrix_servers[0]],
'private_rooms':
private_rooms,
})
transport.start(MockRaidenService(None), MessageHandler(set()), '')
gevent.idle()
ms_room_name = make_room_alias(transport.network_id,
MONITORING_BROADCASTING_ROOM)
ms_room = transport._global_rooms.get(ms_room_name)
assert isinstance(ms_room, Room)
ms_room.send_text = MagicMock(spec=ms_room.send_text)
for i in range(5):
message = Processed(message_identifier=i)
transport._raiden_service.sign(message)
transport.send_global(
MONITORING_BROADCASTING_ROOM,
message,
)
transport._spawn(transport._global_send_worker)
gevent.idle()
assert ms_room.send_text.call_count >= 1
# messages could have been bundled
call_args_str = ' '.join(
str(arg) for arg in ms_room.send_text.call_args_list)
for i in range(5):
assert f'"message_identifier": {i}' in call_args_str
transport.stop()
transport.get()
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 test_matrix_send_global(
local_matrix_servers,
retries_before_backoff,
retry_interval,
private_rooms,
):
transport = MatrixTransport({
'global_rooms': ['discovery', MONITORING_BROADCASTING_ROOM],
'retries_before_backoff':
retries_before_backoff,
'retry_interval':
retry_interval,
'server':
local_matrix_servers[0],
'server_name':
local_matrix_servers[0].netloc,
'available_servers': [local_matrix_servers[0]],
'private_rooms':
private_rooms,
})
transport.start(MockRaidenService(None), MessageHandler(set()), '')
gevent.idle()
ms_room_name = make_room_alias(transport.network_id,
MONITORING_BROADCASTING_ROOM)
ms_room = transport._global_rooms.get(ms_room_name)
assert isinstance(ms_room, Room)
ms_room.send_text = MagicMock(spec=ms_room.send_text)
for i in range(5):
message = Processed(i)
transport._raiden_service.sign(message)
transport.send_global(
MONITORING_BROADCASTING_ROOM,
message,
)
gevent.idle()
assert ms_room.send_text.call_count == 5
transport.stop()
transport.get()
def receive_ping(self, ping, message_id):
if ping_log.isEnabledFor(logging.DEBUG):
ping_log.debug(
'PING RECEIVED',
node=pex(self.raiden.address),
message_id=message_id,
message=ping,
sender=pex(ping.sender),
)
processed_message = Processed(self.raiden.address, message_id)
try:
self.maybe_send_processed(
ping.sender,
processed_message,
)
except (InvalidAddress, UnknownAddress) as e:
log.debug("Couldn't send the `Processed` message", e=e)
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 message_from_sendevent(send_event: SendMessageEvent) -> Message:
if type(send_event) == SendLockedTransfer:
assert isinstance(send_event, SendLockedTransfer), MYPY_ANNOTATION
message = LockedTransfer.from_event(send_event)
elif type(send_event) == SendLockedTransferLight:
assert isinstance(send_event, SendLockedTransferLight), MYPY_ANNOTATION
message = send_event.signed_locked_transfer
elif type(send_event) == SendSecretReveal:
assert isinstance(send_event, SendSecretReveal), MYPY_ANNOTATION
message = RevealSecret.from_event(send_event)
elif type(send_event) == SendSecretRevealLight:
assert isinstance(send_event, SendSecretRevealLight), MYPY_ANNOTATION
message = send_event.signed_secret_reveal
elif type(send_event) == SendBalanceProof:
assert isinstance(send_event, SendBalanceProof), MYPY_ANNOTATION
message = Unlock.from_event(send_event)
elif type(send_event) == SendBalanceProofLight:
assert isinstance(send_event, SendBalanceProofLight), MYPY_ANNOTATION
message = send_event.signed_balance_proof
elif type(send_event) == SendSecretRequest:
assert isinstance(send_event, SendSecretRequest), MYPY_ANNOTATION
message = SecretRequest.from_event(send_event)
elif type(send_event) == SendSecretRequestLight:
assert isinstance(send_event, SendSecretRequestLight), MYPY_ANNOTATION
message = send_event.signed_secret_request
elif type(send_event) == SendRefundTransfer:
assert isinstance(send_event, SendRefundTransfer), MYPY_ANNOTATION
message = RefundTransfer.from_event(send_event)
elif type(send_event) == SendLockExpired:
assert isinstance(send_event, SendLockExpired), MYPY_ANNOTATION
message = LockExpired.from_event(send_event)
elif type(send_event) == SendProcessed:
assert isinstance(send_event, SendProcessed), MYPY_ANNOTATION
message = Processed.from_event(send_event)
else:
raise ValueError(f"Unknown event type {send_event}")
return message
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_processed(iterations=ITERATIONS):
msg = Processed(ADDRESS, HASH)
run_timeit('Processed', msg, iterations=iterations)
def test_matrix_message_retry(local_matrix_servers, private_rooms,
retry_interval, retries_before_backoff,
global_rooms):
""" 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 = factories.make_address()
transport = MatrixTransport({
"global_rooms": global_rooms,
"retries_before_backoff": retries_before_backoff,
"retry_interval": retry_interval,
"server": local_matrix_servers[0],
"server_name": local_matrix_servers[0].netloc,
"available_servers": [local_matrix_servers[0]],
"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_mgr._address_to_reachability[
partner_address] = AddressReachability.REACHABLE
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(message_identifier=0)
transport._raiden_service.sign(message)
chain_state.queueids_to_queues[queueid] = [message]
retry_queue.enqueue_global(message)
gevent.sleep(1)
assert transport._send_raw.call_count == 1
# Receiver goes offline
transport._address_mgr._address_to_reachability[
partner_address] = AddressReachability.UNREACHABLE
gevent.sleep(retry_interval)
transport.log.debug.assert_called_with(
"Partner not reachable. Skipping.",
partner=pex(partner_address),
status=AddressReachability.UNREACHABLE,
)
# 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_mgr._address_to_reachability[
partner_address] = AddressReachability.REACHABLE
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(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(0.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)
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()
