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 test_matrix_invite_private_room_unhappy_case_2(matrix_transports,
expected_join_rule0,
expected_join_rule1):
raiden_service0 = MockRaidenService(None)
raiden_service1 = MockRaidenService(None)
transport0, transport1 = matrix_transports
transport0.start(raiden_service0, raiden_service0.message_handler, None)
transport1.start(raiden_service1, raiden_service1.message_handler, None)
transport0.start_health_check(raiden_service1.address)
transport1.start_health_check(raiden_service0.address)
assert is_reachable(transport1, raiden_service0.address)
assert is_reachable(transport0, raiden_service1.address)
print(transport1._client.user_id)
transport1.stop()
wait_for_peer_unreachable(transport0, raiden_service1.address)
assert not is_reachable(transport0, raiden_service1.address)
room_id = transport0._get_room_for_address(raiden_service1.address).room_id
transport1.start(raiden_service1, raiden_service1.message_handler, None)
transport1.start_health_check(raiden_service0.address)
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state0 = transport0._client.api.get_room_state(room_id)
break
except MatrixRequestError:
gevent.sleep(0.1)
join_rule0 = [
event["content"].get("join_rule") for event in room_state0
if event["type"] == "m.room.join_rules"
][0]
assert join_rule0 == expected_join_rule0
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state1 = transport1._client.api.get_room_state(room_id)
break
except MatrixRequestError as ex:
print(ex, transport0._client.user_id,
transport1._client.user_id)
gevent.sleep(0.5)
join_rule1 = [
event["content"].get("join_rule") for event in room_state1
if event["type"] == "m.room.join_rules"
][0]
assert join_rule1 == expected_join_rule1
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_matrix_cross_server_with_load_balance(matrix_transports):
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, [], "")
transport1.start(raiden_service1, [], "")
transport2.start(raiden_service2, [], "")
transport0.immediate_health_check_for(raiden_service1.address)
transport0.immediate_health_check_for(raiden_service2.address)
transport1.immediate_health_check_for(raiden_service0.address)
transport1.immediate_health_check_for(raiden_service2.address)
transport2.immediate_health_check_for(raiden_service0.address)
transport2.immediate_health_check_for(raiden_service1.address)
assert ping_pong_message_success(transport0, transport1)
assert ping_pong_message_success(transport0, transport2)
assert ping_pong_message_success(transport1, transport0)
assert ping_pong_message_success(transport1, transport2)
assert ping_pong_message_success(transport2, transport0)
assert ping_pong_message_success(transport2, transport1)
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, [], "")
transport1.start(raiden_service1, [], "")
transport0.start_health_check(raiden_service1.address)
transport1.start_health_check(raiden_service0.address)
message = Processed(message_identifier=1, signature=EMPTY_SIGNATURE)
transport0._raiden_service.sign(message)
transport0.send_to_device(raiden_service1.address, message)
transport1._receive_to_device.assert_not_called()
message = ToDevice(message_identifier=1, signature=EMPTY_SIGNATURE)
transport0._raiden_service.sign(message)
transport0.send_to_device(raiden_service1.address, message)
with gevent.Timeout(2):
wait_assert(transport1._receive_to_device.assert_called)
def test_matrix_invite_private_room_happy_case(matrix_transports):
""" Test that a room has been created between two communicating nodes."""
# initialize transport
raiden_service0 = MockRaidenService(None)
raiden_service1 = MockRaidenService(None)
transport0, transport1 = matrix_transports
transport0.start(raiden_service0, [], None)
transport1.start(raiden_service1, [], None)
# start health check to create private room
transport0.immediate_health_check_for(transport1._raiden_service.address)
transport1.immediate_health_check_for(transport0._raiden_service.address)
# wait for room synchronization of transports
# due to asynchronous room creation
wait_for_room_with_address(transport0, raiden_service1.address)
wait_for_room_with_address(transport1, raiden_service0.address)
# check that there exist a room state by server
# meaning that both user are members of the room
room = transport0._get_room_for_address(raiden_service1.address)
assert room is not None
room_id = room.room_id
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state0 = transport0._client.api.get_room_state(room_id)
room_state1 = transport1._client.api.get_room_state(room_id)
break
except MatrixRequestError:
gevent.sleep(0.1)
assert room_state0 is not None
assert room_state1 is not None
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 test_matrix_invitee_receives_invite_on_restart(matrix_transports):
raiden_service0 = MockRaidenService(None)
raiden_service1 = MockRaidenService(None)
transport0, transport1 = matrix_transports
room_creator_address = my_place_or_yours(raiden_service0.address,
raiden_service1.address)
if room_creator_address == raiden_service0.address:
inviter_service = raiden_service0
invitee_service = raiden_service1
inviter_transport = transport0
invitee_transport = transport1
else:
inviter_service = raiden_service1
invitee_service = raiden_service0
inviter_transport = transport1
invitee_transport = transport0
inviter_transport.start(inviter_service, [], None)
invitee_transport.start(invitee_service, [], None)
inviter_transport.start_health_check(invitee_service.address)
invitee_transport.start_health_check(inviter_service.address)
wait_for_peer_reachable(inviter_transport, invitee_service.address)
wait_for_peer_reachable(invitee_transport, inviter_service.address)
assert is_reachable(invitee_transport, inviter_service.address)
assert is_reachable(inviter_transport, invitee_service.address)
invitee_transport.stop()
wait_for_peer_unreachable(inviter_transport, invitee_service.address)
assert not is_reachable(inviter_transport, invitee_service.address)
room_id = inviter_transport._get_room_for_address(
invitee_service.address).room_id
invitee_transport.start(invitee_service, [], None)
invitee_transport.start_health_check(inviter_service.address)
inviter_transport.stop()
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state1 = invitee_transport._client.api.get_room_state(
room_id)
break
except MatrixRequestError:
gevent.sleep(0.1)
assert room_state1 is not None
def test_matrix_user_roaming(matrix_transports):
transport0, transport1, transport2 = 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, '')
transport0.start_health_check(raiden_service1.address)
transport1.start_health_check(raiden_service0.address)
assert ping_pong_message_success(transport0, transport1)
transport0.stop()
with Timeout(40):
while not transport1._address_to_presence[
raiden_service0.address].value == 'offline':
gevent.sleep(.1)
assert transport1._address_to_presence[
raiden_service0.address].value == 'offline'
transport2.start(raiden_service0, message_handler0, '')
transport2.start_health_check(raiden_service1.address)
assert ping_pong_message_success(transport2, transport1)
transport2.stop()
with Timeout(40):
while not transport1._address_to_presence[
raiden_service0.address].value == 'offline':
gevent.sleep(.1)
assert transport1._address_to_presence[
raiden_service0.address].value == 'offline'
transport0.start(raiden_service0, message_handler0, '')
with Timeout(40):
while not transport1._address_to_presence[
raiden_service0.address].value == 'online':
gevent.sleep(.1)
assert transport1._address_to_presence[
raiden_service0.address].value == 'online'
assert ping_pong_message_success(transport0, transport1)
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_invitee_receives_invite_on_restart(
matrix_transports: List[MatrixTransport]) -> None:
"""The invitee should receive the invite, even if the inviter is offline."""
raiden_service0: RaidenService = cast(RaidenService,
MockRaidenService(None))
raiden_service1: RaidenService = cast(RaidenService,
MockRaidenService(None))
transport0, transport1 = matrix_transports
room_creator_address = my_place_or_yours(raiden_service0.address,
raiden_service1.address)
if room_creator_address == raiden_service0.address:
inviter_service = raiden_service0
invitee_service = raiden_service1
inviter_transport = transport0
invitee_transport = transport1
else:
inviter_service = raiden_service1
invitee_service = raiden_service0
inviter_transport = transport1
invitee_transport = transport0
# Initialize the invitee and stop it before the invite happens
invitee_transport.start(invitee_service, [], None)
invitee_transport.stop()
inviter_transport.start(inviter_service, [], None)
inviter_transport.immediate_health_check_for(invitee_service.address)
room = inviter_transport._get_room_for_address(invitee_service.address)
assert room, "The inviter should have created the room, even if the invitee is offline."
# Now stop the inviter and check the invitee received the invite
inviter_transport.stop()
invitee_transport.start(invitee_service, [], None)
invitee_transport.immediate_health_check_for(inviter_service.address)
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state1 = invitee_transport._client.api.get_room_state(
room.room_id)
break
except MatrixRequestError:
gevent.sleep(0.1)
assert room_state1 is not None
def test_matrix_user_roaming(matrix_transports, roaming_peer):
transport0, transport1, transport2 = matrix_transports
received_messages0 = set()
received_messages1 = set()
message_handler0 = MessageHandler(received_messages0)
message_handler1 = MessageHandler(received_messages1)
reverse_privkey_order = roaming_peer == "low"
privkey0, privkey1 = make_privkeys_ordered(count=2,
reverse=reverse_privkey_order)
raiden_service0 = MockRaidenService(message_handler0, private_key=privkey0)
raiden_service1 = MockRaidenService(message_handler1, private_key=privkey1)
transport0.start(raiden_service0, [], "")
transport1.start(raiden_service1, [], "")
transport0.immediate_health_check_for(raiden_service1.address)
transport1.immediate_health_check_for(raiden_service0.address)
assert ping_pong_message_success(transport0, transport1)
transport0.stop()
wait_for_peer_unreachable(transport1, raiden_service0.address)
assert not is_reachable(transport1, raiden_service0.address)
transport2.start(raiden_service0, [], "")
transport2.immediate_health_check_for(raiden_service1.address)
assert ping_pong_message_success(transport2, transport1)
transport2.stop()
wait_for_peer_unreachable(transport1, raiden_service0.address)
assert not is_reachable(transport1, raiden_service0.address)
transport0.start(raiden_service0, [], "")
transport0.immediate_health_check_for(raiden_service1.address)
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while not is_reachable(transport1, raiden_service0.address):
gevent.sleep(0.1)
assert is_reachable(transport1, raiden_service0.address)
assert ping_pong_message_success(transport0, transport1)
def test_upgrade_v21_to_v22(tmp_path):
address = to_canonical_address(
"0x87A749D9b9c0c91AC009AeeBd74313D1a736A24C")
with patch("raiden.utils.upgrades.latest_db_file") as latest_db_file:
old_db_filename = tmp_path / Path(f"v{SOURCE_VERSION}_log.db")
latest_db_file.return_value = str(old_db_filename)
storage = setup_storage(str(old_db_filename))
with patch("raiden.storage.sqlite.RAIDEN_DB_VERSION",
new=SOURCE_VERSION):
storage.update_version()
storage.conn.close()
raiden_service_mock = MockRaidenService()
raiden_service_mock.address = address
db_path = tmp_path / Path(f"v{TARGET_VERSION}_log.db")
manager = UpgradeManager(db_filename=str(db_path),
raiden=raiden_service_mock)
with patch(
"raiden.utils.upgrades.UPGRADES_LIST",
new=[
UpgradeRecord(from_version=SOURCE_VERSION,
function=upgrade_v21_to_v22)
],
):
manager.run()
storage = SQLiteStorage(str(db_path))
for batch in storage.batch_query_event_records(batch_size=500):
for event in batch:
walk_dicts(
event,
constraint_has_canonical_identifier_or_values_removed)
for batch in storage.batch_query_state_changes(batch_size=500):
for state_change in batch:
walk_dicts(
state_change,
constraint_has_canonical_identifier_or_values_removed)
for snapshot in storage.get_snapshots():
walk_dicts(snapshot,
constraint_has_canonical_identifier_or_values_removed)
assert os.path.isfile(str(db_path))
assert os.path.isfile(str(old_db_filename))
os.unlink(str(db_path))
os.unlink(str(old_db_filename))
assert not os.path.exists(str(db_path))
assert not os.path.exists(str(old_db_filename))
def test_matrix_discovery_room_offline_server(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], "https://localhost:1"],
})
transport.start(MockRaidenService(None), [], "")
discovery_room_name = make_room_alias(transport.chain_id, "discovery")
with gevent.Timeout(1):
while not isinstance(
transport._broadcast_rooms.get(discovery_room_name), Room):
gevent.sleep(0.1)
transport.stop()
transport.greenlet.get()
def test_matrix_discovery_room_offline_server(
local_matrix_servers,
retries_before_backoff,
retry_interval,
private_rooms,
):
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': [local_matrix_servers[0], 'https://localhost:1'],
'private_rooms':
private_rooms,
})
transport.start(MockRaidenService(None), MessageHandler(set()), '')
gevent.sleep(.2)
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 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 test_matrix_discovery_room_offline_server(
local_matrix_servers,
retries_before_backoff,
retry_interval_initial,
retry_interval_max,
broadcast_rooms,
):
transport = MatrixTransport(
config=MatrixTransportConfig(
broadcast_rooms=broadcast_rooms,
retries_before_backoff=retries_before_backoff,
retry_interval_initial=retry_interval_initial,
retry_interval_max=retry_interval_max,
server=local_matrix_servers[0],
available_servers=[local_matrix_servers[0], "https://localhost:1"],
),
environment=Environment.DEVELOPMENT,
)
transport.start(MockRaidenService(None), [], "")
discovery_room_name = make_room_alias(transport.chain_id, "discovery")
with gevent.Timeout(1):
while not isinstance(transport._broadcast_rooms.get(discovery_room_name), Room):
gevent.sleep(0.1)
transport.stop()
transport.greenlet.get()
def test_join_invalid_discovery(
local_matrix_servers,
retry_interval_initial,
retry_interval_max,
retries_before_backoff,
broadcast_rooms,
):
"""join_broadcast_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(
config=MatrixTransportConfig(
broadcast_rooms=broadcast_rooms,
retries_before_backoff=retries_before_backoff,
retry_interval_initial=retry_interval_initial,
retry_interval_max=retry_interval_max,
server=local_matrix_servers[0],
available_servers=["http://invalid.server"],
),
environment=Environment.DEVELOPMENT,
)
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
transport.start(raiden_service, [], None)
transport.log = MagicMock()
discovery_room_name = make_room_alias(transport.chain_id, "discovery")
assert isinstance(transport._broadcast_rooms.get(discovery_room_name), Room)
transport.stop()
transport.greenlet.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_handle_contract_send_channelunlock_already_unlocked():
"""This is a test for the scenario where the onchain unlock has
already happened when we get to handle our own send unlock
transaction.
Regression test for https://github.com/raiden-network/raiden/issues/3152
"""
channel_identifier = 1
token_network_identifier = make_address()
token_address = make_address()
participant = make_address()
raiden = MockRaidenService()
def detail_participants(participant1, participant2, block_identifier,
channel_identifier):
transferred_amount = 1
locked_amount = 1
locksroot = make_32bytes()
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
our_details = ParticipantDetails(
address=raiden.address,
deposit=5,
withdrawn=0,
is_closer=False,
balance_hash=balance_hash,
nonce=1,
locksroot=locksroot,
locked_amount=locked_amount,
)
transferred_amount = 1
locked_amount = 1
# Let's mock here that partner locksroot is 0x0
locksroot = EMPTY_HASH
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
partner_details = ParticipantDetails(
address=participant,
deposit=5,
withdrawn=0,
is_closer=True,
balance_hash=balance_hash,
nonce=1,
locksroot=locksroot,
locked_amount=locked_amount,
)
return ParticipantsDetails(our_details, partner_details)
# make sure detail_participants returns partner data with a locksroot of 0x0
raiden.chain.token_network.detail_participants = detail_participants
event = ContractSendChannelBatchUnlock(
token_address=token_address,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
participant=participant,
)
# This should not throw an unrecoverable error
RaidenEventHandler().on_raiden_event(raiden=raiden, event=event)
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()), "")
gevent.sleep(0.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 mock_udp(
raiden_udp_ports,
throttle_capacity,
throttle_fill_rate,
retry_interval,
retries_before_backoff,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
):
throttle_policy = TokenBucket(throttle_capacity, throttle_fill_rate)
host = "127.0.0.1"
port = raiden_udp_ports[0]
address = make_address()
config = dict(
retry_interval=retry_interval,
retries_before_backoff=retries_before_backoff,
nat_invitation_timeout=nat_invitation_timeout,
nat_keepalive_retries=nat_keepalive_retries,
nat_keepalive_timeout=nat_keepalive_timeout,
)
transport = UDPTransport(
address,
MockDiscovery,
server._udp_socket((host, port)), # pylint: disable=protected-access
throttle_policy,
config,
)
transport.raiden = MockRaidenService(ADDR)
return transport
def test_matrix_invite_private_room_unhappy_case_3(
matrix_transports,
expected_join_rule,
):
raiden_service0 = MockRaidenService(None)
raiden_service1 = MockRaidenService(None)
transport0, transport1 = matrix_transports
transport0.start(raiden_service0, raiden_service0.message_handler, None)
transport1.start(raiden_service1, raiden_service1.message_handler, None)
transport0.start_health_check(raiden_service1.address)
transport1.start_health_check(raiden_service0.address)
assert transport1._address_to_presence[
raiden_service0.address].value == 'online'
assert transport0._address_to_presence[
raiden_service1.address].value == 'online'
transport1.stop()
with Timeout(40):
while not transport0._address_to_presence[
raiden_service1.address].value == 'offline':
gevent.sleep(.1)
assert transport0._address_to_presence[
raiden_service1.address].value == 'offline'
room_id = transport0._get_room_for_address(raiden_service1.address).room_id
transport1.start(raiden_service1, raiden_service1.message_handler, None)
transport0.stop()
with Timeout(40):
while True:
try:
room_state1 = transport1._client.api.get_room_state(room_id)
break
except MatrixRequestError:
gevent.sleep(.1)
join_rule1 = [
event['content'].get('join_rule') for event in room_state1
if event['type'] == 'm.room.join_rules'
][0]
assert join_rule1 == expected_join_rule
def test_matrix_user_roaming(matrix_transports):
transport0, transport1, transport2 = 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, "")
transport0.start_health_check(raiden_service1.address)
transport1.start_health_check(raiden_service0.address)
assert ping_pong_message_success(transport0, transport1)
transport0.stop()
with Timeout(40):
while is_reachable(transport1, raiden_service0.address):
gevent.sleep(0.1)
assert not is_reachable(transport1, raiden_service0.address)
transport2.start(raiden_service0, message_handler0, "")
transport2.start_health_check(raiden_service1.address)
assert ping_pong_message_success(transport2, transport1)
transport2.stop()
with Timeout(40):
while is_reachable(transport1, raiden_service0.address):
gevent.sleep(0.1)
assert not is_reachable(transport1, raiden_service0.address)
transport0.start(raiden_service0, message_handler0, "")
with Timeout(40):
while not is_reachable(transport1, raiden_service0.address):
gevent.sleep(0.1)
assert is_reachable(transport1, raiden_service0.address)
assert ping_pong_message_success(transport0, transport1)
def test_reproduce_handle_invite_send_race_issue_3588(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)
transport0.start(raiden_service0, [], "")
transport1.start(raiden_service1, [], "")
transport0.immediate_health_check_for(raiden_service1.address)
transport1.immediate_health_check_for(raiden_service0.address)
assert ping_pong_message_success(transport0, transport1)
def test_web_rtc_message_sync(matrix_transports):
transport0, transport1 = matrix_transports
transport1_messages = set()
raiden_service0 = MockRaidenService()
raiden_service1 = MockRaidenService()
def mock_handle_web_rtc_messages(message_data, partner_address):
messages = validate_and_parse_message(message_data, partner_address)
transport1_messages.update(messages)
# set mock function to make sure messages are sent via web rtc
transport1._web_rtc_manager._handle_message_callback = mock_handle_web_rtc_messages
transport0.start(raiden_service0, [], None)
transport1.start(raiden_service1, [], None)
transport0.immediate_health_check_for(transport1._raiden_service.address)
transport1.immediate_health_check_for(transport0._raiden_service.address)
with Timeout(TIMEOUT_WEB_RTC_CONNECTION):
# wait until web rtc connection is ready
while not transport0._web_rtc_manager.has_ready_channel(raiden_service1.address):
gevent.sleep(1)
while not transport1._web_rtc_manager.has_ready_channel(raiden_service0.address):
gevent.sleep(1)
queue_identifier = QueueIdentifier(
recipient=transport1._raiden_service.address,
canonical_identifier=factories.UNIT_CANONICAL_ID,
)
raiden0_queues = views.get_all_messagequeues(views.state_from_raiden(raiden_service0))
raiden0_queues[queue_identifier] = []
for i in range(5):
message = Processed(message_identifier=MessageID(i), signature=EMPTY_SIGNATURE)
raiden0_queues[queue_identifier].append(message)
transport0._raiden_service.sign(message)
transport0.send_async([MessagesQueue(queue_identifier, [message])])
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while not len(transport1_messages) == 5:
gevent.sleep(0.1)
def test_matrix_invite_private_room_happy_case(
matrix_transports,
expected_join_rule,
):
raiden_service0 = MockRaidenService(None)
raiden_service1 = MockRaidenService(None)
transport0, transport1 = matrix_transports
transport0.start(raiden_service0, raiden_service0.message_handler, None)
transport1.start(raiden_service1, raiden_service1.message_handler, None)
transport0.start_health_check(transport1._raiden_service.address)
transport1.start_health_check(transport0._raiden_service.address)
room_id = transport0._get_room_for_address(raiden_service1.address).room_id
with Timeout(40):
while True:
try:
room_state0 = transport0._client.api.get_room_state(room_id)
break
except MatrixRequestError:
gevent.sleep(.1)
join_rule0 = [
event['content'].get('join_rule') for event in room_state0
if event['type'] == 'm.room.join_rules'
][0]
assert join_rule0 == expected_join_rule
with Timeout(40):
while True:
try:
room_state1 = transport1._client.api.get_room_state(room_id)
break
except MatrixRequestError:
gevent.sleep(.1)
join_rule1 = [
event['content'].get('join_rule') for event in room_state1
if event['type'] == 'm.room.join_rules'
][0]
assert join_rule1 == expected_join_rule
def test_assumption_receive_all_state_events_upon_first_sync_after_join(
matrix_transports, number_of_transports, monkeypatch
):
"""
Test that independently of the number of timeline events in the room
the first sync after the join always contains all room state events
more explicitly all member joins. This means the user always knows
all members of a room at the first sync after the joining the room.
(Some state events are placed in the timeline history. That does not
change the logic but it must be given that no state events are filtered
due to limitation of the timeline limit filter)
"""
transports: List[MatrixTransport] = list()
# it is necessary to monkeypatch leave_unexpected_rooms
# otherwise rooms would be left automatically when members > 2
monkeypatch.setattr(
MatrixTransport, "_leave_unexpected_rooms", lambda self, rooms_to_leave, reason: None
)
# start all transports
for transport in matrix_transports:
raiden_service = MockRaidenService()
transport.start(raiden_service, [], None)
transports.append(transport)
transport0 = transports[0]
transport1 = transports[1]
room0 = transport0._client.create_room()
# invite every user but transport[1]
for transport in transports[2:]:
room0.invite_user(transport._user_id)
transport0._client.synced.wait()
# wait for every user to be joined
while len(room0.get_joined_members()) < number_of_transports - 1:
transport0._client.synced.wait()
# start filling timeline events by sending messages
for i in range(1, 100):
room0.send_text(f"ping{i}")
gevent.sleep(0.05)
# finally invite transport[1]
room0.invite_user(transport1._user_id)
# wait for the first sync after join
while room0.room_id not in transport1._client.rooms:
transport1._client.synced.wait()
transport1._client.synced.wait()
# check that all information about existing members are received
assert (
len(transport1._client.rooms[room0.room_id].get_joined_members()) == number_of_transports
)
def test_matrix_invite_private_room_happy_case(matrix_transports):
""" Test that a room has been created between two communicating nodes."""
raiden_service0 = MockRaidenService(None)
raiden_service1 = MockRaidenService(None)
transport0, transport1 = matrix_transports
transport0.start(raiden_service0, [], None)
transport1.start(raiden_service1, [], None)
transport0.start_health_check(transport1._raiden_service.address)
transport1.start_health_check(transport0._raiden_service.address)
room = transport0._get_room_for_address(raiden_service1.address)
# Transport0 is on the higher end of the lexical order of the addresses.
# It did not create the room and therefore we check that the other
# node creates it.
if room is None:
room = transport1._maybe_create_room_for_address(
raiden_service0.address)
room_id = room.room_id
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state0 = transport0._client.api.get_room_state(room_id)
break
except MatrixRequestError:
gevent.sleep(0.1)
assert room_state0 is not None
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state1 = transport1._client.api.get_room_state(room_id)
break
except MatrixRequestError:
gevent.sleep(0.1)
assert room_state1 is not None
