def make_client(
handle_messages_callback: Callable[[MatrixSyncMessages], bool],
servers: List[str],
*args: Any,
**kwargs: Any,
) -> GMatrixClient:
"""Given a list of possible servers, chooses the closest available and create a GMatrixClient
Params:
servers: list of servers urls, with scheme (http or https)
Rest of args and kwargs are forwarded to GMatrixClient constructor
Returns:
GMatrixClient instance for one of the available servers
"""
if len(servers) > 1:
sorted_servers = sort_servers_closest(servers)
log.debug("Selecting best matrix server",
sorted_servers=sorted_servers)
elif len(servers) == 1:
sorted_servers = {servers[0]: 0}
else:
raise TransportError("No valid servers list given")
last_ex = None
for server_url, rtt in sorted_servers.items():
client = GMatrixClient(handle_messages_callback, server_url, *args,
**kwargs)
retries = 3
while retries:
retries -= 1
try:
client.api._send("GET",
"/versions",
api_path="/_matrix/client")
except MatrixRequestError as ex:
log.warning(
"Matrix server returned an error, retrying",
server_url=server_url,
_exception=ex,
)
last_ex = ex
except MatrixError as ex:
log.warning("Selected server not usable",
server_url=server_url,
_exception=ex)
last_ex = ex
retries = 0
else:
log.info(
"Using Matrix server",
server_url=server_url,
server_ident=client.api.server_ident,
average_rtt=rtt,
)
return client
raise TransportError(
"Unable to find a reachable Matrix server. Please check your network connectivity."
) from last_ex
def make_client_monkey(
handle_messages_callback, handle_member_join_callback, servers, *args, **kwargs
): # pylint: disable=unused-argument
return GMatrixClient(
handle_messages_callback=handle_messages_callback,
handle_member_join_callback=handle_member_join_callback,
base_url=servers[0],
)
def new_user(matrix_server_url: str) -> LoggedUser:
client = GMatrixClient(time_messages, ignore_member_join, matrix_server_url)
signer = factories.make_signer()
with logtime(USER) as details:
user = login(client, signer)
details["user_id"] = user.user_id
return LoggedUser(client, signer, user)
def new_client(server: "ParsedURL") -> GMatrixClient:
server_name = server.netloc
signer = make_signer()
username = str(to_normalized_address(signer.address))
password = encode_hex(signer.sign(server_name.encode()))
client = GMatrixClient(server)
client.login(username, password, sync=False)
return client
def mock_matrix(monkeypatch, retry_interval, retries_before_backoff):
from raiden.network.transport.matrix.client import User
from raiden.network.transport.matrix import transport as transport_module
monkeypatch.setattr(User, "get_display_name",
lambda _: "random_display_name")
monkeypatch.setattr(transport_module, "make_client",
lambda url, *a, **kw: GMatrixClient(url[0]))
def mock_get_user(klass, user: Union[User, str]) -> User: # pylint: disable=unused-argument
return User(None, USERID1)
def mock_get_room_ids_for_address( # pylint: disable=unused-argument
klass,
address: Address,
filter_private: bool = None) -> List[str]:
return ["!roomID:server"]
def mock_set_room_id_for_address( # pylint: disable=unused-argument
self, address: Address, room_id: Optional[str]):
pass
def mock_receive_message(klass, message): # pylint: disable=unused-argument
# We are just unit testing the matrix transport receive so do nothing
assert message
assert message.sender
config = dict(
retry_interval=retry_interval,
retries_before_backoff=retries_before_backoff,
server="http://none",
server_name="none",
available_servers=[],
global_rooms=[],
private_rooms=False,
)
transport = MatrixTransport(config)
transport._raiden_service = MockRaidenService()
transport._stop_event.clear()
transport._address_mgr.add_userid_for_address(factories.HOP1, USERID1)
transport._client.user_id = USERID0
monkeypatch.setattr(MatrixTransport, "_get_user", mock_get_user)
monkeypatch.setattr(MatrixTransport, "_get_room_ids_for_address",
mock_get_room_ids_for_address)
monkeypatch.setattr(MatrixTransport, "_set_room_id_for_address",
mock_set_room_id_for_address)
monkeypatch.setattr(MatrixTransport, "_receive_message",
mock_receive_message)
return transport
def new_client(handle_messages_callback: Callable[[MatrixSyncMessages], bool],
server: "ParsedURL") -> GMatrixClient:
server_name = server.netloc
signer = make_signer()
username = str(to_normalized_address(signer.address))
password = encode_hex(signer.sign(server_name.encode()))
client = GMatrixClient(handle_messages_callback, server)
client.login(username, password, sync=False)
return client
def main():
host = sys.argv[1]
client = GMatrixClient(host, user_id=USER_ID, token=ACCESS_TOKEN)
client.join_room(ROOM_ALIAS)
current_presence = "offline"
while True:
if current_presence == "offline":
client.set_presence_state(UserPresence.ONLINE.value)
else:
client.set_presence_state(UserPresence.OFFLINE.value)
# Confirm user presence
current_presence = client.get_user_presence(USER_ID)
print("Change status to: ", current_presence)
gevent.sleep(5)
def make_client(servers: Sequence[str], *args, **kwargs) -> GMatrixClient:
"""Given a list of possible servers, chooses the closest available and create a GMatrixClient
Params:
servers: list of servers urls, with scheme (http or https)
Rest of args and kwargs are forwarded to GMatrixClient constructor
Returns:
GMatrixClient instance for one of the available servers
"""
if len(servers) > 1:
sorted_servers = [
server_url for (server_url, _) in sort_servers_closest(servers)
]
log.info(
'Automatically selecting matrix homeserver based on RTT',
sorted_servers=sorted_servers,
)
elif len(servers) == 1:
sorted_servers = servers
else:
raise TransportError('No valid servers list given')
last_ex = None
for server_url in sorted_servers:
server_url: str = server_url
client = GMatrixClient(server_url, *args, **kwargs)
try:
client.api._send('GET', '/versions', api_path='/_matrix/client')
except MatrixError as ex:
log.warning('Selected server not usable',
server_url=server_url,
_exception=ex)
last_ex = ex
else:
break
else:
raise TransportError(
'Unable to find a reachable Matrix server. Please check your network connectivity.',
) from last_ex
return client
def main(keystore_file: str, password: str, host: str, room_id: str, other_user_id: str):
private_key = get_private_key(keystore_file, password)
client = GMatrixClient(host)
user = login(client=client, signer=LocalSigner(private_key=decode_hex(private_key)))
log.info("Logged in", user=user, server=host, room_id=room_id)
# print("TKN: \n" + client.token)
client.add_presence_listener(callback)
client.start_listener_thread()
# try:
client.join_room(room_id)
# except MatrixRequestError:
# client.create_room(alias="raiden_goerli_discovery", is_public=True)
while True:
current_presence = client.get_user_presence(other_user_id)
log.warning("User presence", other_user=other_user_id, presence=current_presence)
gevent.sleep(1)
def test_admin_is_allowed_to_kick(matrix_transports, local_matrix_servers):
server_name = local_matrix_servers[0].netloc
admin_credentials = get_admin_credentials(server_name)
broadcast_room_name = make_room_alias(UNIT_CHAIN_ID, "discovery")
broadcast_room_alias = f"#{broadcast_room_name}:{server_name}"
transport0, transport1, transport2 = matrix_transports
raiden_service0 = MockRaidenService()
raiden_service1 = MockRaidenService()
# start transports to join broadcast rooms as normal users
transport0.start(raiden_service0, [], None)
transport1.start(raiden_service1, [], None)
# admin login using raiden.tests.utils.transport.AdminAuthProvider
admin_client = GMatrixClient(ignore_messages, ignore_member_join,
local_matrix_servers[0])
admin_client.login(admin_credentials["username"],
admin_credentials["password"],
sync=False)
room_id = admin_client.join_room(broadcast_room_alias).room_id
# get members of room and filter not kickable users (power level 100)
def _get_joined_room_members():
membership_events = admin_client.api.get_room_members(room_id)["chunk"]
member_ids = [
event["state_key"] for event in membership_events
if event["content"]["membership"] == "join"
]
return set(member_ids)
members = _get_joined_room_members()
power_levels_event = admin_client.api.get_power_levels(room_id)
admin_user_ids = [
key for key, value in power_levels_event["users"].items()
if value >= 50
]
non_admin_user_ids = [
member for member in members if member not in admin_user_ids
]
# transport0 and transport1 should still be in non_admin_user_ids
assert len(non_admin_user_ids) > 1
kick_user_id = non_admin_user_ids[0]
# kick one user
admin_client.api.kick_user(room_id, kick_user_id)
# Assert missing member
members_after_kick = _get_joined_room_members()
assert len(members_after_kick) == len(members) - 1
members_after_kick.add(kick_user_id)
assert members_after_kick == members
# check assumption that new user does not receive presence
raiden_service2 = MockRaidenService()
def local_presence_listener(event, event_id): # pylint: disable=unused-argument
assert event["sender"] != kick_user_id
transport2._client.add_presence_listener(local_presence_listener)
transport2.start(raiden_service2, [], None)
transport2.stop()
# rejoin and assert that normal user cannot kick
kicked_transport = transport0 if transport0._user_id == kick_user_id else transport1
kicked_transport._client.join_room(broadcast_room_alias)
with pytest.raises(MatrixRequestError):
kicked_transport._client.api.kick_user(room_id, non_admin_user_ids[1])
def make_client_monkey(
handle_messages_callback, servers, *args, **kwargs
): # pylint: disable=unused-argument
return GMatrixClient(handle_messages_callback, servers[0])