def test_assumption_search_user_directory_returns_federated_users(chain_id, local_matrix_servers):
"""The search_user_directory should return federated users.
This assumption test was added because of issue #5285. The
path-finding-service was not functioning properly because the call to
`search_user_directory` did not return federated users, only local users.
Becaused of that the PFS assumed the users were offline and didn't find any
valid routes for the payments.
"""
original_server_url = urlsplit(local_matrix_servers[0]).netloc
room_alias = make_room_alias(chain_id, "broadcast_test")
room_name_full = f"#{room_alias}:{original_server_url}"
user_room_creator, _ = create_logged_in_client(local_matrix_servers[0])
user_room_creator.create_room(room_alias, is_public=True)
user_federated, _ = create_logged_in_client(local_matrix_servers[1])
join_broadcast_room(user_federated, room_name_full)
addresses = list()
for _ in range(1000):
user, signer = create_logged_in_client(local_matrix_servers[0])
join_broadcast_room(user, room_name_full)
# Make sure to close the session instance, otherwise there will be too
# many file descriptors opened by the underlying urllib3 connection
# pool.
user.api.session.close()
del user
addresses.append(signer.address)
for address in addresses:
assert user_federated.search_user_directory(to_hex_address(address))
def _setup_client(self, matrix_client: GMatrixClient) -> None:
exception_str = "Could not login/register to matrix."
try:
login(matrix_client,
signer=self.local_signer,
device_id=self.device_id)
exception_str = "Could not join broadcasting room."
server = urlparse(matrix_client.api.base_url).netloc
room_alias = f"#{self.broadcast_room_alias_prefix}:{server}"
broadcast_room = join_broadcast_room(
client=matrix_client, broadcast_room_alias=room_alias)
broadcast_room_id = broadcast_room.room_id
if matrix_client == self.main_client:
self.broadcast_room = broadcast_room
self.broadcast_room_id = broadcast_room_id
# Don't listen for messages on the discovery room on all clients
sync_filter_id = matrix_client.create_sync_filter(
not_rooms=[broadcast_room])
matrix_client.set_sync_filter_id(sync_filter_id)
except (MatrixRequestError, ValueError):
raise ConnectionError(exception_str)
def monitor_server_presence(server: str, signer: Signer,
network_names: List[str], stop_event: Event):
server_name = urlparse(server).netloc
client = make_client(lambda x: False, lambda x: None, [server])
login(client=client, signer=signer)
client.add_presence_listener(partial(log_presence, server))
client.start_listener_thread(30_000, 1_000)
for network_name in network_names:
discovery_room_alias = make_room_alias(CHAINNAME_TO_ID[network_name],
DISCOVERY_DEFAULT_ROOM)
discovery_room = join_broadcast_room(
client, f"#{discovery_room_alias}:{server_name}")
log.info("Monitoring started", server=server)
stop_event.wait()
client.stop()
def test_assumption_federation_works_after_original_server_goes_down(
chain_id, local_matrix_servers_with_executor):
""" Check that a federated broadcast room keeps working after the original server goes down.
This creates a federation of three matrix servers and a client for each.
It then checks that all nodes receive messages from the broadcast room.
Then the first matrix server is shut down and a second message send to
the broadcast room, which should arrive at both remaining clients.
"""
original_server_url = urlsplit(
local_matrix_servers_with_executor[0][0]).netloc
room_alias = make_room_alias(chain_id, "broadcast_test")
room_name_full = f"#{room_alias}:{original_server_url}"
user_room_creator, _ = create_logged_in_client(
local_matrix_servers_with_executor[0][0])
original_room: Room = user_room_creator.create_room(room_alias,
is_public=True)
user_room_creator.start_listener_thread(
timeout_ms=DEFAULT_TRANSPORT_MATRIX_SYNC_TIMEOUT,
latency_ms=DEFAULT_TRANSPORT_MATRIX_SYNC_LATENCY,
)
user_federated_1, _ = create_logged_in_client(
local_matrix_servers_with_executor[1][0])
room_server1 = join_broadcast_room(user_federated_1, room_name_full)
user_federated_1.rooms[room_server1.room_id] = room_server1
user_federated_1.start_listener_thread(
timeout_ms=DEFAULT_TRANSPORT_MATRIX_SYNC_TIMEOUT,
latency_ms=DEFAULT_TRANSPORT_MATRIX_SYNC_LATENCY,
)
user_federated_2, _ = create_logged_in_client(
local_matrix_servers_with_executor[2][0])
room_server2 = join_broadcast_room(user_federated_2, room_name_full)
user_federated_2.rooms[room_server2.room_id] = room_server2
user_federated_2.start_listener_thread(
timeout_ms=DEFAULT_TRANSPORT_MATRIX_SYNC_TIMEOUT,
latency_ms=DEFAULT_TRANSPORT_MATRIX_SYNC_LATENCY,
)
received = {}
def handle_message(node_id: int, _room: Room, event: Dict[str, Any]):
nonlocal received
received[node_id] = event["content"]["body"]
original_room.add_listener(partial(handle_message, 0), "m.room.message")
room_server1.add_listener(partial(handle_message, 1), "m.room.message")
room_server2.add_listener(partial(handle_message, 2), "m.room.message")
# Full federation, send a message to check it works
original_room.send_text("Message1")
while not len(received) == 3:
gevent.sleep(0.1)
assert sorted(received.keys()) == [0, 1, 2]
assert all("Message1" == m for m in received.values())
# Shut down the room_creator before we stop the server
user_room_creator.stop_listener_thread()
# Shutdown server 0, the original creator of the room
server: HTTPExecutor = local_matrix_servers_with_executor[0][1]
server.stop()
# Send message from client 1, check that client 2 receives it
received = {}
room_server1.send_text("Message2")
while not len(received) == 2:
gevent.sleep(0.1)
assert sorted(received.keys()) == [1, 2]
assert all("Message2" == m for m in received.values())
# Shut down longrunning threads
user_federated_1.stop_listener_thread()
user_federated_2.stop_listener_thread()
