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 _start_client(self) -> None:
try:
if self.user_manager:
self.user_manager.start()
login_or_register(
self.client, signer=LocalSigner(private_key=decode_hex(self.private_key))
)
except (MatrixRequestError, ValueError):
raise ConnectionError("Could not login/register to matrix.")
try:
self.join_global_rooms(client=self.client, available_servers=self.available_servers)
except (MatrixRequestError, TransportError):
raise ConnectionError("Could not join monitoring broadcasting room.")
# Add listener for global rooms
for broadcast_room in self.broadcast_rooms:
broadcast_room.add_listener(self._handle_message, "m.room.message")
# Signal that startup is finished
self.startup_finished.set()
def _start_client(self) -> None:
try:
login_or_register(
self.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,
self.service_room_suffix)
self.broadcast_room = join_global_room(
client=self.client,
name=room_name,
servers=self.available_servers)
except (MatrixRequestError, TransportError):
raise ConnectionError(
"Could not join monitoring broadcasting room.")
self.broadcast_room.add_listener(self._handle_message,
"m.room.message")
# Signal that startup is finished
self.startup_finished.set()
def test_login_or_register_default_user():
ownserver = 'https://ownserver.com'
api = Mock()
api.base_url = ownserver
server_name = urlparse(ownserver).netloc
client = Mock()
client.api = api
# login will assert user is hex-encoded address and pw is server_name signed with that address
def mock_login(user, pw, sync=True):
recovered = recover(data=server_name.encode(),
signature=decode_hex(pw))
if recovered != to_canonical_address(user):
raise MatrixRequestError(403)
client.user_id = f'@{user}:{server_name}'
client.login = Mock(side_effect=mock_login)
MockUser = create_autospec(User)
client.get_user = Mock(side_effect=lambda user_id: MockUser(api, user_id))
signer = make_signer()
user = login_or_register(
client=client,
signer=signer,
)
# client.user_id will be set by login
assert client.user_id.startswith(
f'@{to_normalized_address(signer.address)}')
# login_or_register returns our own user object
assert isinstance(user, User)
# get_user must have been called once to generate above user
client.get_user.assert_called_once_with(client.user_id)
# assert set_display_name was called once on ourselves
assert user.set_display_name.call_count == 1
# assert the user.set_display_name was called with the signature of the user_id
assert recover(
data=client.user_id.encode(),
signature=decode_hex(user.set_display_name.call_args[0][0]),
) == signer.address
