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