async def _discover(cls, domain: str,
session: ClientSession) -> Optional[URL]:
well_known = URL.build(scheme="https",
host=domain,
path="/.well-known/matrix/client")
async with session.get(well_known) as resp:
if resp.status == 404:
return None
elif resp.status != 200:
raise WellKnownUnexpectedStatus(resp.status)
try:
data = await resp.json(content_type=None)
except (json.JSONDecodeError, ContentTypeError) as e:
raise WellKnownNotJSON() from e
try:
homeserver_url = data["m.homeserver"]["base_url"]
except KeyError as e:
raise WellKnownMissingHomeserver() from e
parsed_url = URL(homeserver_url)
if not parsed_url.is_absolute():
raise WellKnownNotURL()
elif parsed_url.scheme not in ("http", "https"):
raise WellKnownUnsupportedScheme(parsed_url.scheme)
try:
async with session.get(parsed_url /
"_matrix/client/versions") as resp:
data = VersionsResponse.deserialize(await resp.json())
assert len(data.versions) > 0
except (ClientError, json.JSONDecodeError, SerializerError,
AssertionError) as e:
raise WellKnownInvalidVersionsResponse() from e
return parsed_url
def __init__(
self,
command_processor: cmd.CommandProcessor | None = None,
bridge: br.Bridge | None = None,
) -> None:
self.az = bridge.az
self.config = bridge.config
self.bridge = bridge
self.commands = command_processor or cmd.CommandProcessor(bridge=bridge)
self.media_config = MediaRepoConfig(upload_size=50 * 1024 * 1024)
self.versions = VersionsResponse.deserialize({"versions": ["v1.3"]})
self.az.matrix_event_handler(self.int_handle_event)
self.e2ee = None
if self.config["bridge.encryption.allow"]:
if not EncryptionManager:
self.log.fatal(
"Encryption enabled in config, but dependencies not installed.",
exc_info=encryption_import_error,
)
sys.exit(31)
if not encrypt_attachment:
self.log.fatal(
"Encryption enabled in config, but media encryption dependencies "
"not installed.",
exc_info=media_encrypt_import_error,
)
sys.exit(31)
self.e2ee = EncryptionManager(
bridge=bridge,
user_id_prefix=self.user_id_prefix,
user_id_suffix=self.user_id_suffix,
homeserver_address=self.config["homeserver.address"],
db_url=self.config["appservice.database"],
key_sharing_config=self.config["bridge.encryption.key_sharing"],
)
self.management_room_text = self.config.get(
"bridge.management_room_text",
{
"welcome": "Hello, I'm a bridge bot.",
"welcome_connected": "Use `help` for help.",
"welcome_unconnected": "Use `help` for help on how to log in.",
},
)
self.management_room_multiple_messages = self.config.get(
"bridge.management_room_multiple_messages",
False,
)
async def versions(self, no_cache: bool = False) -> VersionsResponse:
"""
Get client-server spec versions supported by the server.
Args:
no_cache: If true, the versions will always be fetched from the server
rather than using cached results when availab.e.
Returns:
The supported Matrix spec versions and unstable features.
"""
if no_cache or not self.versions_cache:
resp = await self.api.request(Method.GET, Path.versions)
self.versions_cache = VersionsResponse.deserialize(resp)
return self.versions_cache
async def versions(self) -> VersionsResponse:
"""Get client-server spec versions supported by the server."""
resp = await self.api.request(Method.GET, "_matrix/client/versions")
return VersionsResponse.deserialize(resp)