def test_join_invalid_discovery(local_matrix_servers, private_rooms,
retry_interval, retries_before_backoff,
global_rooms):
"""join_global_room tries to join on all servers on available_servers config
If any of the servers isn't reachable by synapse, it'll return a 500 response, which needs
to be handled, and if no discovery room is found on any of the available_servers, one in
our current server should be created
"""
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": ["http://invalid.server"],
"private_rooms": private_rooms,
})
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
transport.start(raiden_service, raiden_service.message_handler, None)
transport.log = MagicMock()
discovery_room_name = make_room_alias(transport.network_id, "discovery")
assert isinstance(transport._global_rooms.get(discovery_room_name), Room)
transport.stop()
transport.get()
def mock_matrix(
monkeypatch,
retry_interval,
retries_before_backoff,
local_matrix_servers,
private_rooms,
):
from raiden.network.transport.matrix.client import User
monkeypatch.setattr(User, 'get_display_name',
lambda _: 'random_display_name')
def mock_get_user(klass, user: Union[User, str]) -> User: # pylint: disable=unused-argument
return User(None, USERID1)
def mock_get_room_ids_for_address( # pylint: disable=unused-argument
klass,
address: Address,
filter_private: bool = None,
) -> List[str]:
return ['!roomID:server']
def mock_set_room_id_for_address( # pylint: disable=unused-argument
self,
address: Address,
room_id: Optional[str],
):
pass
def mock_receive_message(klass, message): # pylint: disable=unused-argument
# We are just unit testing the matrix transport receive so do nothing
assert message
config = dict(
retry_interval=retry_interval,
retries_before_backoff=retries_before_backoff,
server=local_matrix_servers[0],
server_name=local_matrix_servers[0].netloc,
available_servers=[],
global_rooms=['discovery'],
private_rooms=private_rooms,
)
transport = MatrixTransport(config)
transport._raiden_service = MockRaidenService()
transport._stop_event.clear()
transport._address_to_userids[HOP1] = USERID1
monkeypatch.setattr(MatrixTransport, '_get_user', mock_get_user)
monkeypatch.setattr(
MatrixTransport,
'_get_room_ids_for_address',
mock_get_room_ids_for_address,
)
monkeypatch.setattr(MatrixTransport, '_set_room_id_for_address',
mock_set_room_id_for_address)
monkeypatch.setattr(MatrixTransport, '_receive_message',
mock_receive_message)
return transport
def test_pfs_global_messages(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
monkeypatch,
global_rooms,
):
"""
Test that RaidenService sends UpdatePFS messages to global
PATH_FINDING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport({
"global_rooms": global_rooms, # FIXME: #3735
"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._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
transport.start(raiden_service, raiden_service.message_handler, None)
pfs_room_name = make_room_alias(transport.network_id,
PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._global_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = factories.create(HOP1_BALANCE_PROOF)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
"get_channelstate_by_canonical_identifier",
lambda *a, **kw: channel_state,
)
update_path_finding_service_from_balance_proof(
raiden=raiden_service,
chain_state=None,
new_balance_proof=balance_proof)
gevent.idle()
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 1:
gevent.idle()
assert pfs_room.send_text.call_count == 1
transport.stop()
transport.get()
def mock_matrix(
monkeypatch,
retry_interval,
retries_before_backoff,
local_matrix_server,
private_rooms,
):
from matrix_client.user import User
monkeypatch.setattr(User, 'get_display_name', lambda _: 'random_display_name')
def mock_get_user(klass, user: Union[User, str]) -> User:
return User(None, USERID1)
def mock_get_room_ids_for_address(
klass,
address: Address,
filter_private: bool=None,
) -> List[str]:
return ['!roomID:server']
def mock_set_room_id_for_address(self, address: Address, room_id: Optional[str]):
pass
def mock_receive_message(klass, message):
# We are just unit testing the matrix transport receive so do nothing
assert message
def mock_receive_delivered(klass, delivered):
# We are just unit testing the matrix transport receive so do nothing
assert delivered
config = dict(
retry_interval=retry_interval,
retries_before_backoff=retries_before_backoff,
server=local_matrix_server,
server_name='matrix.local.raiden',
available_servers=[],
discovery_room='discovery',
private_rooms=private_rooms,
)
transport = MatrixTransport(config)
transport.raiden = MockRaidenService(ADDR)
transport._stop_event.clear()
transport._address_to_userids[HOP1] = USERID1
monkeypatch.setattr(MatrixTransport, '_get_user', mock_get_user)
monkeypatch.setattr(
MatrixTransport,
'_get_room_ids_for_address',
mock_get_room_ids_for_address,
)
monkeypatch.setattr(MatrixTransport, '_set_room_id_for_address', mock_set_room_id_for_address)
monkeypatch.setattr(MatrixTransport, '_receive_message', mock_receive_message)
return transport
def mock_matrix(
monkeypatch,
retry_interval,
retries_before_backoff,
):
from matrix_client.user import User
monkeypatch.setattr(User, 'get_display_name',
lambda _: 'random_display_name')
def mock_get_user(klass, user: Union[User, str]) -> User:
return User(None, USERID1)
def mock_get_room_id_for_address(klass, address: Address) -> Optional[str]:
return '42'
def mock_set_room_id_for_address(self, address: Address,
room_id: Optional[str]):
pass
def mock_receive_message(klass, message):
# We are just unit testing the matrix transport receive so do nothing
assert message
def mock_receive_delivered(klass, delivered):
# We are just unit testing the matrix transport receive so do nothing
assert delivered
config = dict(
retry_interval=retry_interval,
retries_before_backoff=retries_before_backoff,
server='auto',
available_servers=[
'https://transport01.raiden.network',
'https://transport02.raiden.network',
'https://transport03.raiden.network',
],
discovery_room={
'alias_fragment': 'discovery',
'server': 'transport01.raiden.network',
},
)
transport = MatrixTransport(config)
transport.raiden = MockRaidenService(ADDR)
transport._stop_event.clear()
transport._address_to_userids[HOP1] = USERID1
monkeypatch.setattr(MatrixTransport, '_get_user', mock_get_user)
monkeypatch.setattr(MatrixTransport, '_get_room_id_for_address',
mock_get_room_id_for_address)
monkeypatch.setattr(MatrixTransport, '_set_room_id_for_address',
mock_set_room_id_for_address)
monkeypatch.setattr(MatrixTransport, '_receive_message',
mock_receive_message)
return transport
def test_monitoring_global_messages(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
):
"""
Test that RaidenService sends RequestMonitoring messages to global
MONITORING_BROADCASTING_ROOM room on newly received balance proofs.
"""
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._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
transport.start(
raiden_service,
raiden_service.message_handler,
None,
)
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)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = make_balance_proof(signer=LocalSigner(HOP1_KEY), amount=1)
update_monitoring_service_from_balance_proof(
raiden_service,
balance_proof,
)
gevent.idle()
assert ms_room.send_text.call_count == 1
transport.stop()
transport.get()
def test_matrix_discovery_room_offline_server(local_matrix_servers,
retries_before_backoff,
retry_interval, private_rooms,
global_rooms):
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], "https://localhost:1"],
"private_rooms":
private_rooms,
})
transport.start(MockRaidenService(None), MessageHandler(set()), "")
discovery_room_name = make_room_alias(transport.chain_id, "discovery")
with gevent.Timeout(1):
while not isinstance(transport._global_rooms.get(discovery_room_name),
Room):
gevent.sleep(0.1)
transport.stop()
transport.get()
def test_matrix_discovery_room_offline_server(
local_matrix_servers,
retries_before_backoff,
retry_interval,
private_rooms,
):
transport = MatrixTransport({
'global_rooms': ['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': [local_matrix_servers[0], 'https://localhost:1'],
'private_rooms':
private_rooms,
})
transport.start(MockRaidenService(None), MessageHandler(set()), '')
gevent.sleep(.2)
discovery_room_name = make_room_alias(transport.network_id, 'discovery')
assert isinstance(transport._global_rooms.get(discovery_room_name), Room)
transport.stop()
transport.get()
def wait_for_room_with_address(transport: MatrixTransport,
address: Address,
timeout: int = 10):
with Timeout(timeout):
while True:
room = transport._get_room_for_address(address)
if room is not None:
break
gevent.sleep(0.1)
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 test_matrix_broadcast(local_matrix_servers, retries_before_backoff,
retry_interval, broadcast_rooms):
transport = MatrixTransport({
"broadcast_rooms": broadcast_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]],
})
transport.start(MockRaidenService(None), [], "")
gevent.idle()
ms_room_name = make_room_alias(transport.chain_id,
MONITORING_BROADCASTING_ROOM)
ms_room = transport._broadcast_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, signature=EMPTY_SIGNATURE)
transport._raiden_service.sign(message)
transport.broadcast(MONITORING_BROADCASTING_ROOM, message)
transport._schedule_new_greenlet(transport._broadcast_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.greenlet.get()
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 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 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(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
):
transport0 = MatrixTransport({
'global_rooms': ['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({
'global_rooms': ['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_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,
)
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(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)
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({
'global_rooms': ['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)
transport._raiden_service.sign(message)
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_pfs_global_messages(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
monkeypatch,
):
"""
Test that RaidenService sends UpdatePFS messages to global
PATH_FINDING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport({
'global_rooms': ['discovery', PATH_FINDING_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._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
transport.start(
raiden_service,
raiden_service.message_handler,
None,
)
pfs_room_name = make_room_alias(transport.network_id,
PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._global_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = make_balance_proof(signer=LocalSigner(HOP1_KEY), amount=1)
channel_state = make_channel_state()
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
'get_channelstate_by_canonical_identifier',
lambda *a, **kw: channel_state,
)
update_path_finding_service_from_balance_proof(
raiden=raiden_service,
chain_state=None,
new_balance_proof=balance_proof,
)
gevent.idle()
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 1:
gevent.idle()
assert pfs_room.send_text.call_count == 1
transport.stop()
transport.get()
def test_matrix_message_retry(local_matrix_servers, retry_interval,
retries_before_backoff, broadcast_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({
"broadcast_rooms": broadcast_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]],
})
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
transport.start(raiden_service, [], None)
transport.log = MagicMock()
# Receiver is online
transport._address_mgr._address_to_reachability[
partner_address] = AddressReachability.REACHABLE
queueid = QueueIdentifier(
recipient=partner_address,
canonical_identifier=CANONICAL_IDENTIFIER_UNORDERED_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, signature=EMPTY_SIGNATURE)
transport._raiden_service.sign(message)
chain_state.queueids_to_queues[queueid] = [message]
retry_queue.enqueue_unordered(message)
gevent.idle()
assert transport._send_raw.call_count == 1
# Receiver goes offline
transport._address_mgr._address_to_reachability[
partner_address] = AddressReachability.UNREACHABLE
with gevent.Timeout(retry_interval + 2):
wait_assert(
transport.log.debug.assert_called_with,
"Partner not reachable. Skipping.",
partner=to_checksum_address(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
# Retrier should send the message again
with gevent.Timeout(retry_interval + 2):
while transport._send_raw.call_count != 2:
gevent.sleep(0.1)
transport.stop()
transport.greenlet.get()
def test_monitoring_broadcast_messages(local_matrix_servers, retry_interval,
retries_before_backoff, monkeypatch,
broadcast_rooms):
"""
Test that RaidenService broadcast RequestMonitoring messages to
MONITORING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport({
"broadcast_rooms":
broadcast_rooms + [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]],
})
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
transport.start(raiden_service, [], None)
ms_room_name = make_room_alias(transport.chain_id,
MONITORING_BROADCASTING_ROOM)
ms_room = transport._broadcast_rooms.get(ms_room_name)
assert isinstance(ms_room, Room)
ms_room.send_text = MagicMock(spec=ms_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = factories.create(HOP1_BALANCE_PROOF)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
"get_channelstate_by_canonical_identifier",
lambda *a, **kw: channel_state,
)
monkeypatch.setattr(raiden.transfer.channel, "get_balance",
lambda *a, **kw: 123)
raiden_service.user_deposit.effective_balance.return_value = MONITORING_REWARD
update_monitoring_service_from_balance_proof(
raiden=raiden_service,
chain_state=None,
new_balance_proof=balance_proof,
non_closing_participant=HOP1,
)
gevent.idle()
with gevent.Timeout(2):
while ms_room.send_text.call_count < 1:
gevent.idle()
assert ms_room.send_text.call_count == 1
transport.stop()
transport.greenlet.get()
def test_pfs_broadcast_messages(
local_matrix_servers,
retry_interval,
retries_before_backoff,
monkeypatch,
broadcast_rooms,
route_mode,
):
"""
Test that RaidenService broadcasts PFSCapacityUpdate messages to
PATH_FINDING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport({
"broadcast_rooms": broadcast_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]],
})
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
raiden_service.routing_mode = route_mode
transport.start(raiden_service, [], None)
pfs_room_name = make_room_alias(transport.chain_id,
PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._broadcast_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
# send PFSCapacityUpdate
balance_proof = factories.create(HOP1_BALANCE_PROOF)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
"get_channelstate_by_canonical_identifier",
lambda *a, **kw: channel_state,
)
send_pfs_update(raiden=raiden_service,
canonical_identifier=balance_proof.canonical_identifier)
gevent.idle()
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 1:
gevent.idle()
assert pfs_room.send_text.call_count == 1
# send PFSFeeUpdate
channel_state = factories.create(factories.NettingChannelStateProperties())
fee_update = PFSFeeUpdate.from_channel_state(channel_state)
fee_update.sign(raiden_service.signer)
raiden_service.transport.broadcast(PATH_FINDING_BROADCASTING_ROOM,
fee_update)
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 2:
gevent.idle()
assert pfs_room.send_text.call_count == 2
msg_data = json.loads(pfs_room.send_text.call_args[0][0])
assert msg_data["type"] == "PFSFeeUpdate"
transport.stop()
transport.greenlet.get()