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()