def create_logged_in_client(server: str) -> Tuple[GMatrixClient, Signer]: client = make_client([server]) signer = factories.make_signer() login(client, signer) return client, signer
def create_logged_in_client(server: str) -> Tuple[GMatrixClient, Signer]: client = make_client(ignore_messages, ignore_member_join, [server]) signer = factories.make_signer() login(client, signer) return client, signer
def setup_matrix(self, service_room_suffix: str) -> Tuple[GMatrixClient, Room]: available_servers_url = DEFAULT_MATRIX_KNOWN_SERVERS[Environment.DEVELOPMENT] available_servers = get_matrix_servers(available_servers_url) def _http_retry_delay() -> Iterable[float]: # below constants are defined in raiden.app.App.DEFAULT_CONFIG return udp_utils.timeout_exponential_backoff( DEFAULT_TRANSPORT_RETRIES_BEFORE_BACKOFF, int(DEFAULT_TRANSPORT_MATRIX_RETRY_INTERVAL / 5), int(DEFAULT_TRANSPORT_MATRIX_RETRY_INTERVAL), ) client = make_client( servers=available_servers, http_pool_maxsize=4, http_retry_timeout=40, http_retry_delay=_http_retry_delay, ) try: login_or_register(client, signer=LocalSigner(private_key=decode_hex(self.private_key))) except (MatrixRequestError, ValueError): raise ConnectionError("Could not login/register to matrix.") try: room_name = make_room_alias(self.chain_id, service_room_suffix) monitoring_room = join_global_room( client=client, name=room_name, servers=available_servers ) except (MatrixRequestError, TransportError): raise ConnectionError("Could not join monitoring broadcasting room.") return client, monitoring_room
def test_make_client(monkeypatch): # invalid server url (ftp not supported) with pytest.raises(TransportError): make_client(["ftp://server1.com", "http://server2.com"]) # no valid server url with pytest.raises(TransportError): make_client([]) # valid but unreachable servers with pytest.raises(TransportError), monkeypatch.context() as m: mock_get_http_rtt = Mock( spec=raiden.network.transport.matrix.utils.get_http_rtt, side_effect=lambda url: None ) m.setattr(raiden.network.transport.matrix.utils, "get_http_rtt", mock_get_http_rtt) make_client([f"http://server{i}.xyz" for i in range(3)]) mock_send = Mock(side_effect=lambda method, path, *args, **kwargs: True) # successful server contact with single (no-auto) server with monkeypatch.context() as m: m.setattr(raiden.network.transport.matrix.client.GMatrixHttpApi, "_send", mock_send) url = "https://server1.xyz" client = make_client([url]) assert isinstance(client, raiden.network.transport.matrix.client.GMatrixClient) assert client.api.base_url == url
def __init__( self, available_servers: Optional[List[str]], device_id: DeviceIDs, broadcast_room_alias_prefix: str, chain_id: ChainID, private_key: bytes, handle_matrix_sync: Callable[[MatrixSyncMessages], bool], ): self.user_manager: Optional[MultiClientUserAddressManager] = None self.local_signer = LocalSigner(private_key=private_key) self.broadcast_room_alias_prefix = broadcast_room_alias_prefix self.device_id = device_id self.broadcast_room_id: Optional[RoomID] = None self.broadcast_room: Optional[Room] = None self.chain_id = chain_id self.startup_finished = AsyncResult() self.stop_event = Event() self.stop_event.set() try: self.known_servers = (get_matrix_servers( DEFAULT_MATRIX_KNOWN_SERVERS[Environment. PRODUCTION] if chain_id == 1 else DEFAULT_MATRIX_KNOWN_SERVERS[Environment.DEVELOPMENT]) if chain_id in [ Networks.MAINNET.value, Networks.ROPSTEN.value, Networks.RINKEBY.value, Networks.GOERLI.value, Networks.KOVAN.value, ] else []) except RuntimeError: if available_servers is None: raise self.known_servers = [] if available_servers: self.available_servers = available_servers else: self.available_servers = self.known_servers self.main_client = make_client( handle_messages_callback=handle_matrix_sync, handle_member_join_callback=lambda room: None, servers=self.available_servers, http_pool_maxsize=4, http_retry_timeout=40, http_retry_delay=matrix_http_retry_delay, ) self.server_url_to_other_clients: Dict[str, GMatrixClient] = {} self.connect_client_workers: Set[Greenlet] = set()
def __init__( self, private_key: str, chain_id: ChainID, service_room_suffix: str, message_received_callback: Callable[[Message], None], address_reachability_changed_callback: Callable[ [Address, AddressReachability], None] = None, servers: List[str] = None, ) -> None: super().__init__() self.private_key = private_key self.chain_id = chain_id self.service_room_suffix = service_room_suffix self.message_received_callback = message_received_callback if servers: self.available_servers = servers else: self.available_servers = get_matrix_servers( DEFAULT_MATRIX_KNOWN_SERVERS[Environment. PRODUCTION] if chain_id == 1 else DEFAULT_MATRIX_KNOWN_SERVERS[Environment.DEVELOPMENT]) self.client = make_client( servers=self.available_servers, http_pool_maxsize=4, http_retry_timeout=40, http_retry_delay=matrix_http_retry_delay, ) self.broadcast_rooms: List[Room] = [] self._displayname_cache = DisplayNameCache() self._user_manager: Optional[UserAddressManager] = None if address_reachability_changed_callback is not None: self._user_manager = UserAddressManager( client=self.client, displayname_cache=self._displayname_cache, address_reachability_changed_callback= address_reachability_changed_callback, ) self.startup_finished = Event() self.rate_limiter = RateLimiter( allowed_bytes=MATRIX_RATE_LIMIT_ALLOWED_BYTES, reset_interval=MATRIX_RATE_LIMIT_RESET_INTERVAL, )
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 _start_client(self, server_url: str) -> GMatrixClient: assert self.user_manager if self.stop_event.is_set(): raise TransportError() if server_url == self.main_client.api.base_url: client = self.main_client else: # Also handle messages on the other clients, # since to-device communication to the PFS only happens via the local user # on each homeserver client = make_client( handle_messages_callback=self.main_client. handle_messages_callback, servers=[server_url], http_pool_maxsize=4, http_retry_timeout=40, http_retry_delay=matrix_http_retry_delay, ) self.server_url_to_other_clients[server_url] = client log.debug("Created client for other server", server_url=server_url) try: login(client, signer=self.local_signer, device_id=self.device_id) log.debug("Matrix login successful", server_url=server_url) except (MatrixRequestError, ValueError): raise ConnectionError("Could not login/register to matrix.") client.start_listener_thread( DEFAULT_TRANSPORT_MATRIX_SYNC_TIMEOUT, DEFAULT_TRANSPORT_MATRIX_SYNC_LATENCY, ) # main client is already added upon MultiClientUserAddressManager.start() if server_url != self.main_client.api.base_url: self.user_manager.add_client(client) return client
def __init__( self, private_key: str, chain_id: ChainID, service_room_suffix: str, message_received_callback: Callable[[Message], None], address_reachability_changed_callback: Callable[ [Address, AddressReachability], None] = None, ) -> None: super().__init__() self.private_key = private_key self.chain_id = chain_id self.service_room_suffix = service_room_suffix self.message_received_callback = message_received_callback self.available_servers = get_matrix_servers( DEFAULT_MATRIX_KNOWN_SERVERS[Environment.DEVELOPMENT]) self.client = make_client( servers=self.available_servers, http_pool_maxsize=4, http_retry_timeout=40, http_retry_delay=matrix_http_retry_delay, ) self.broadcast_room: Optional[Room] = None self.user_manager: Optional[UserAddressManager] = None if address_reachability_changed_callback is not None: self.user_manager = UserAddressManager( client=self.client, get_user_callable=self._get_user, address_reachability_changed_callback= address_reachability_changed_callback, ) self.startup_finished = Event()