def _setup_matrix(config):
if config['transport']['matrix'].get('available_servers') is None:
# fetch list of known servers from raiden-network/raiden-tranport repo
available_servers_url = DEFAULT_MATRIX_KNOWN_SERVERS[config['environment_type']]
available_servers = get_matrix_servers(available_servers_url)
log.debug('Fetching available matrix servers', available_servers=available_servers)
config['transport']['matrix']['available_servers'] = available_servers
try:
transport = MatrixTransport(config['transport']['matrix'])
except RaidenError as ex:
click.secho(f'FATAL: {ex}', fg='red')
sys.exit(1)
return transport
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 _setup_matrix(config):
if config['transport']['matrix'].get('available_servers') is None:
# fetch list of known servers from raiden-network/raiden-tranport repo
available_servers_url = DEFAULT_MATRIX_KNOWN_SERVERS[
config['environment_type']]
available_servers = get_matrix_servers(available_servers_url)
log.debug('Fetching available matrix servers',
available_servers=available_servers)
config['transport']['matrix']['available_servers'] = available_servers
try:
transport = MatrixTransport(config['transport']['matrix'])
except RaidenError as ex:
click.secho(f'FATAL: {ex}', fg='red')
sys.exit(1)
return transport
def _setup_matrix(config):
if config['transport']['matrix'].get('available_servers') is None:
# fetch list of known servers from raiden-network/raiden-tranport repo
available_servers_url = DEFAULT_MATRIX_KNOWN_SERVERS[config['environment_type']]
available_servers = get_matrix_servers(available_servers_url)
log.debug('Fetching available matrix servers', available_servers=available_servers)
config['transport']['matrix']['available_servers'] = available_servers
# Add monitoring service broadcast room if enabled
if config['services']['monitoring_enabled'] is True:
config['transport']['matrix']['global_rooms'].append(MONITORING_BROADCASTING_ROOM)
try:
transport = MatrixTransport(config['transport']['matrix'])
except RaidenError as ex:
click.secho(f'FATAL: {ex}', fg='red')
sys.exit(1)
return transport
def _load_environment(environment_file: IO) -> EnvironmentConfig:
"""Load the environment JSON file and process matrix server list
Nodes can be assigned to fixed matrix servers. To allow this, we must
download the list of matrix severs.
"""
environment = json.load(environment_file)
assert isinstance(environment, dict)
matrix_server_list = environment.pop(
"matrix_server_list",
DEFAULT_MATRIX_KNOWN_SERVERS[Environment(environment["environment_type"])],
)
matrix_servers: Sequence[URI] = get_matrix_servers(matrix_server_list) # type: ignore
if len(matrix_servers) < 4:
matrix_servers = list(islice(cycle(matrix_servers), 4))
return EnvironmentConfig(
matrix_servers=matrix_servers,
environment_file_name=environment_file.name,
**environment,
)
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 __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()
def __init__(
self,
username: str,
password: str,
own_server_name: str,
known_servers_url: Optional[str] = None,
):
self._username = username
self._password = password
self._own_server_name = own_server_name
if known_servers_url is None:
known_servers_url = DEFAULT_MATRIX_KNOWN_SERVERS[Environment.PRODUCTION]
self._known_servers: Dict[str, str] = {
urlparse(server_url).netloc: server_url
for server_url in get_matrix_servers(
known_servers_url, server_list_type=ServerListType.ALL_SERVERS
)
}
self._first_server_name = list(self._known_servers.keys())[0]
self._is_first_server = own_server_name == self._first_server_name
self._apis: Dict[str, GMatrixHttpApi] = self._connect_all()
if own_server_name not in self._apis:
RuntimeError(f"Could not connect to own matrix server.")
self._own_api = self._apis[own_server_name]
log.debug(
"Room ensurer initialized",
own_server_name=own_server_name,
known_servers=self._known_servers.keys(),
first_server_name=self._first_server_name,
is_first_server=self._is_first_server,
)