2015-01-23 09:16:28 -05:00
|
|
|
#
|
2023-11-21 15:29:58 -05:00
|
|
|
# This file is licensed under the Affero General Public License (AGPL) version 3.
|
|
|
|
#
|
|
|
|
# Copyright (C) 2023 New Vector, Ltd
|
|
|
|
#
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU Affero General Public License as
|
|
|
|
# published by the Free Software Foundation, either version 3 of the
|
|
|
|
# License, or (at your option) any later version.
|
|
|
|
#
|
|
|
|
# See the GNU Affero General Public License for more details:
|
|
|
|
# <https://www.gnu.org/licenses/agpl-3.0.html>.
|
|
|
|
#
|
|
|
|
# Originally licensed under the Apache License, Version 2.0:
|
|
|
|
# <http://www.apache.org/licenses/LICENSE-2.0>.
|
|
|
|
#
|
|
|
|
# [This file includes modifications made by New Vector Limited]
|
2015-01-23 09:16:28 -05:00
|
|
|
#
|
|
|
|
#
|
|
|
|
|
|
|
|
""" This module contains base REST classes for constructing REST servlets. """
|
2023-02-01 16:35:24 -05:00
|
|
|
import enum
|
2015-01-23 09:16:28 -05:00
|
|
|
import logging
|
2021-12-09 06:58:25 -05:00
|
|
|
from http import HTTPStatus
|
2021-08-16 10:49:12 -04:00
|
|
|
from typing import (
|
|
|
|
TYPE_CHECKING,
|
|
|
|
List,
|
|
|
|
Mapping,
|
|
|
|
Optional,
|
|
|
|
Sequence,
|
|
|
|
Tuple,
|
2022-08-15 15:05:57 -04:00
|
|
|
Type,
|
|
|
|
TypeVar,
|
2021-08-16 10:49:12 -04:00
|
|
|
overload,
|
|
|
|
)
|
2021-05-28 09:19:06 -04:00
|
|
|
|
2023-09-25 11:19:08 -04:00
|
|
|
from synapse._pydantic_compat import HAS_PYDANTIC_V2
|
|
|
|
|
|
|
|
if TYPE_CHECKING or HAS_PYDANTIC_V2:
|
|
|
|
from pydantic.v1 import BaseModel, MissingError, PydanticValueError, ValidationError
|
|
|
|
from pydantic.v1.error_wrappers import ErrorWrapper
|
|
|
|
else:
|
|
|
|
from pydantic import BaseModel, MissingError, PydanticValueError, ValidationError
|
|
|
|
from pydantic.error_wrappers import ErrorWrapper
|
|
|
|
|
2021-05-28 09:19:06 -04:00
|
|
|
from typing_extensions import Literal
|
2018-06-28 09:49:57 -04:00
|
|
|
|
2021-06-08 08:30:48 -04:00
|
|
|
from twisted.web.server import Request
|
|
|
|
|
2018-07-09 02:09:20 -04:00
|
|
|
from synapse.api.errors import Codes, SynapseError
|
2022-10-07 12:39:45 -04:00
|
|
|
from synapse.http import redact_uri
|
2021-12-14 07:00:47 -05:00
|
|
|
from synapse.http.server import HttpServer
|
2023-09-13 07:57:19 -04:00
|
|
|
from synapse.types import JsonDict, RoomAlias, RoomID, StrCollection
|
2020-08-19 07:26:03 -04:00
|
|
|
from synapse.util import json_decoder
|
2015-01-23 09:16:28 -05:00
|
|
|
|
2021-08-16 10:49:12 -04:00
|
|
|
if TYPE_CHECKING:
|
|
|
|
from synapse.server import HomeServer
|
|
|
|
|
2015-01-23 09:16:28 -05:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
@overload
|
|
|
|
def parse_integer(request: Request, name: str, default: int) -> int:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_integer(request: Request, name: str, *, required: Literal[True]) -> int:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_integer(
|
|
|
|
request: Request, name: str, default: Optional[int] = None, required: bool = False
|
|
|
|
) -> Optional[int]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
def parse_integer(
|
|
|
|
request: Request, name: str, default: Optional[int] = None, required: bool = False
|
|
|
|
) -> Optional[int]:
|
2016-03-09 06:26:26 -05:00
|
|
|
"""Parse an integer parameter from the request string
|
|
|
|
|
2016-04-01 11:08:59 -04:00
|
|
|
Args:
|
|
|
|
request: the twisted HTTP request.
|
2021-07-21 14:12:22 -04:00
|
|
|
name: the name of the query parameter.
|
|
|
|
default: value to use if the parameter is absent, defaults to None.
|
|
|
|
required: whether to raise a 400 SynapseError if the parameter is absent,
|
|
|
|
defaults to False.
|
2016-04-01 11:08:59 -04:00
|
|
|
|
|
|
|
Returns:
|
2021-07-21 14:12:22 -04:00
|
|
|
An int value or the default.
|
2016-04-01 11:08:59 -04:00
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError: if the parameter is absent and required, or if the
|
2016-03-09 06:26:26 -05:00
|
|
|
parameter is present and not an integer.
|
|
|
|
"""
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]] = request.args # type: ignore
|
|
|
|
return parse_integer_from_args(args, name, default, required)
|
2016-09-15 05:36:19 -04:00
|
|
|
|
|
|
|
|
2021-12-02 02:02:20 -05:00
|
|
|
@overload
|
|
|
|
def parse_integer_from_args(
|
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
|
|
|
name: str,
|
|
|
|
default: Optional[int] = None,
|
|
|
|
) -> Optional[int]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_integer_from_args(
|
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
|
|
|
name: str,
|
|
|
|
*,
|
|
|
|
required: Literal[True],
|
|
|
|
) -> int:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_integer_from_args(
|
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
|
|
|
name: str,
|
|
|
|
default: Optional[int] = None,
|
|
|
|
required: bool = False,
|
|
|
|
) -> Optional[int]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
def parse_integer_from_args(
|
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
|
|
|
name: str,
|
|
|
|
default: Optional[int] = None,
|
|
|
|
required: bool = False,
|
|
|
|
) -> Optional[int]:
|
|
|
|
"""Parse an integer parameter from the request string
|
|
|
|
|
|
|
|
Args:
|
|
|
|
args: A mapping of request args as bytes to a list of bytes (e.g. request.args).
|
|
|
|
name: the name of the query parameter.
|
|
|
|
default: value to use if the parameter is absent, defaults to None.
|
|
|
|
required: whether to raise a 400 SynapseError if the parameter is absent,
|
|
|
|
defaults to False.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
An int value or the default.
|
2018-08-20 09:54:49 -04:00
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
Raises:
|
|
|
|
SynapseError: if the parameter is absent and required, or if the
|
|
|
|
parameter is present and not an integer.
|
|
|
|
"""
|
|
|
|
name_bytes = name.encode("ascii")
|
2018-08-20 09:54:49 -04:00
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
if name_bytes in args:
|
2015-04-21 11:35:53 -04:00
|
|
|
try:
|
2021-07-21 14:12:22 -04:00
|
|
|
return int(args[name_bytes][0])
|
2017-10-23 10:52:32 -04:00
|
|
|
except Exception:
|
2015-04-21 11:35:53 -04:00
|
|
|
message = "Query parameter %r must be an integer" % (name,)
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(
|
|
|
|
HTTPStatus.BAD_REQUEST, message, errcode=Codes.INVALID_PARAM
|
|
|
|
)
|
2015-04-21 11:35:53 -04:00
|
|
|
else:
|
|
|
|
if required:
|
|
|
|
message = "Missing integer query parameter %r" % (name,)
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(
|
|
|
|
HTTPStatus.BAD_REQUEST, message, errcode=Codes.MISSING_PARAM
|
|
|
|
)
|
2015-04-21 11:35:53 -04:00
|
|
|
else:
|
|
|
|
return default
|
|
|
|
|
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
@overload
|
|
|
|
def parse_boolean(request: Request, name: str, default: bool) -> bool:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_boolean(request: Request, name: str, *, required: Literal[True]) -> bool:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_boolean(
|
|
|
|
request: Request, name: str, default: Optional[bool] = None, required: bool = False
|
|
|
|
) -> Optional[bool]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
def parse_boolean(
|
|
|
|
request: Request, name: str, default: Optional[bool] = None, required: bool = False
|
|
|
|
) -> Optional[bool]:
|
2016-03-09 06:26:26 -05:00
|
|
|
"""Parse a boolean parameter from the request query string
|
|
|
|
|
2016-04-01 11:08:59 -04:00
|
|
|
Args:
|
|
|
|
request: the twisted HTTP request.
|
2021-07-21 14:12:22 -04:00
|
|
|
name: the name of the query parameter.
|
|
|
|
default: value to use if the parameter is absent, defaults to None.
|
|
|
|
required: whether to raise a 400 SynapseError if the parameter is absent,
|
|
|
|
defaults to False.
|
2016-04-01 11:08:59 -04:00
|
|
|
|
|
|
|
Returns:
|
2021-07-21 14:12:22 -04:00
|
|
|
A bool value or the default.
|
2016-04-01 11:08:59 -04:00
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError: if the parameter is absent and required, or if the
|
2016-03-09 06:26:26 -05:00
|
|
|
parameter is present and not one of "true" or "false".
|
|
|
|
"""
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]] = request.args # type: ignore
|
|
|
|
return parse_boolean_from_args(args, name, default, required)
|
2016-03-09 06:26:26 -05:00
|
|
|
|
2016-12-06 05:43:48 -05:00
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
@overload
|
|
|
|
def parse_boolean_from_args(
|
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
|
|
|
name: str,
|
|
|
|
default: bool,
|
|
|
|
) -> bool:
|
|
|
|
...
|
2016-12-06 05:43:48 -05:00
|
|
|
|
2018-08-20 09:54:49 -04:00
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
@overload
|
|
|
|
def parse_boolean_from_args(
|
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
|
|
|
name: str,
|
|
|
|
*,
|
|
|
|
required: Literal[True],
|
|
|
|
) -> bool:
|
|
|
|
...
|
|
|
|
|
2018-08-20 09:54:49 -04:00
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
@overload
|
|
|
|
def parse_boolean_from_args(
|
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
|
|
|
name: str,
|
|
|
|
default: Optional[bool] = None,
|
|
|
|
required: bool = False,
|
|
|
|
) -> Optional[bool]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
def parse_boolean_from_args(
|
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
|
|
|
name: str,
|
|
|
|
default: Optional[bool] = None,
|
|
|
|
required: bool = False,
|
|
|
|
) -> Optional[bool]:
|
|
|
|
"""Parse a boolean parameter from the request query string
|
|
|
|
|
|
|
|
Args:
|
|
|
|
args: A mapping of request args as bytes to a list of bytes (e.g. request.args).
|
|
|
|
name: the name of the query parameter.
|
|
|
|
default: value to use if the parameter is absent, defaults to None.
|
|
|
|
required: whether to raise a 400 SynapseError if the parameter is absent,
|
|
|
|
defaults to False.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
A bool value or the default.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError: if the parameter is absent and required, or if the
|
|
|
|
parameter is present and not one of "true" or "false".
|
|
|
|
"""
|
|
|
|
name_bytes = name.encode("ascii")
|
|
|
|
|
|
|
|
if name_bytes in args:
|
2015-04-21 11:35:53 -04:00
|
|
|
try:
|
2021-07-21 14:12:22 -04:00
|
|
|
return {b"true": True, b"false": False}[args[name_bytes][0]]
|
2017-10-23 10:52:32 -04:00
|
|
|
except Exception:
|
2015-04-21 11:35:53 -04:00
|
|
|
message = (
|
2019-11-21 07:00:14 -05:00
|
|
|
"Boolean query parameter %r must be one of ['true', 'false']"
|
2015-04-21 11:35:53 -04:00
|
|
|
) % (name,)
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(
|
|
|
|
HTTPStatus.BAD_REQUEST, message, errcode=Codes.INVALID_PARAM
|
|
|
|
)
|
2015-04-21 11:35:53 -04:00
|
|
|
else:
|
|
|
|
if required:
|
|
|
|
message = "Missing boolean query parameter %r" % (name,)
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(
|
|
|
|
HTTPStatus.BAD_REQUEST, message, errcode=Codes.MISSING_PARAM
|
|
|
|
)
|
2015-04-21 11:35:53 -04:00
|
|
|
else:
|
|
|
|
return default
|
|
|
|
|
|
|
|
|
2021-06-28 07:36:41 -04:00
|
|
|
@overload
|
|
|
|
def parse_bytes_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-28 07:36:41 -04:00
|
|
|
name: str,
|
|
|
|
default: Optional[bytes] = None,
|
|
|
|
) -> Optional[bytes]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
2021-06-08 08:30:48 -04:00
|
|
|
@overload
|
|
|
|
def parse_bytes_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-08 08:30:48 -04:00
|
|
|
name: str,
|
|
|
|
default: Literal[None] = None,
|
2021-06-28 07:36:41 -04:00
|
|
|
*,
|
|
|
|
required: Literal[True],
|
2021-06-08 08:30:48 -04:00
|
|
|
) -> bytes:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_bytes_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-08 08:30:48 -04:00
|
|
|
name: str,
|
|
|
|
default: Optional[bytes] = None,
|
|
|
|
required: bool = False,
|
|
|
|
) -> Optional[bytes]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
def parse_bytes_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-08 08:30:48 -04:00
|
|
|
name: str,
|
|
|
|
default: Optional[bytes] = None,
|
|
|
|
required: bool = False,
|
|
|
|
) -> Optional[bytes]:
|
|
|
|
"""
|
|
|
|
Parse a string parameter as bytes from the request query string.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
args: A mapping of request args as bytes to a list of bytes (e.g. request.args).
|
|
|
|
name: the name of the query parameter.
|
|
|
|
default: value to use if the parameter is absent,
|
|
|
|
defaults to None. Must be bytes if encoding is None.
|
|
|
|
required: whether to raise a 400 SynapseError if the
|
|
|
|
parameter is absent, defaults to False.
|
|
|
|
Returns:
|
|
|
|
Bytes or the default value.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError if the parameter is absent and required.
|
|
|
|
"""
|
|
|
|
name_bytes = name.encode("ascii")
|
|
|
|
|
|
|
|
if name_bytes in args:
|
|
|
|
return args[name_bytes][0]
|
|
|
|
elif required:
|
|
|
|
message = "Missing string query parameter %s" % (name,)
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(HTTPStatus.BAD_REQUEST, message, errcode=Codes.MISSING_PARAM)
|
2021-06-08 08:30:48 -04:00
|
|
|
|
|
|
|
return default
|
|
|
|
|
|
|
|
|
2021-07-21 09:47:56 -04:00
|
|
|
@overload
|
|
|
|
def parse_string(
|
|
|
|
request: Request,
|
|
|
|
name: str,
|
|
|
|
default: str,
|
|
|
|
*,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-07-21 09:47:56 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> str:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_string(
|
|
|
|
request: Request,
|
|
|
|
name: str,
|
|
|
|
*,
|
|
|
|
required: Literal[True],
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-07-21 09:47:56 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> str:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_string(
|
|
|
|
request: Request,
|
|
|
|
name: str,
|
|
|
|
*,
|
2023-02-01 16:35:24 -05:00
|
|
|
default: Optional[str] = None,
|
2021-07-21 09:47:56 -04:00
|
|
|
required: bool = False,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-07-21 09:47:56 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> Optional[str]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
2015-04-21 11:35:53 -04:00
|
|
|
def parse_string(
|
2021-06-08 08:30:48 -04:00
|
|
|
request: Request,
|
|
|
|
name: str,
|
2021-05-28 09:19:06 -04:00
|
|
|
default: Optional[str] = None,
|
|
|
|
required: bool = False,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-06-08 08:30:48 -04:00
|
|
|
encoding: str = "ascii",
|
2021-07-21 09:47:56 -04:00
|
|
|
) -> Optional[str]:
|
2018-08-20 09:54:49 -04:00
|
|
|
"""
|
|
|
|
Parse a string parameter from the request query string.
|
|
|
|
|
|
|
|
If encoding is not None, the content of the query param will be
|
|
|
|
decoded to Unicode using the encoding, otherwise it will be encoded
|
2016-03-09 06:26:26 -05:00
|
|
|
|
2016-04-01 11:08:59 -04:00
|
|
|
Args:
|
|
|
|
request: the twisted HTTP request.
|
2021-05-28 09:19:06 -04:00
|
|
|
name: the name of the query parameter.
|
2021-06-08 08:30:48 -04:00
|
|
|
default: value to use if the parameter is absent, defaults to None.
|
2021-05-28 09:19:06 -04:00
|
|
|
required: whether to raise a 400 SynapseError if the
|
2016-04-01 11:08:59 -04:00
|
|
|
parameter is absent, defaults to False.
|
2021-05-28 09:19:06 -04:00
|
|
|
allowed_values: List of allowed values for the
|
2018-08-20 09:54:49 -04:00
|
|
|
string, or None if any value is allowed, defaults to None. Must be
|
|
|
|
the same type as name, if given.
|
2021-06-08 08:30:48 -04:00
|
|
|
encoding: The encoding to decode the string content with.
|
|
|
|
|
2016-04-01 11:08:59 -04:00
|
|
|
Returns:
|
2021-06-08 08:30:48 -04:00
|
|
|
A string value or the default.
|
2016-04-01 11:08:59 -04:00
|
|
|
|
|
|
|
Raises:
|
2016-03-09 06:26:26 -05:00
|
|
|
SynapseError if the parameter is absent and required, or if the
|
|
|
|
parameter is present, must be one of a list of allowed values and
|
|
|
|
is not one of those allowed values.
|
|
|
|
"""
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]] = request.args # type: ignore
|
2016-09-15 05:36:19 -04:00
|
|
|
return parse_string_from_args(
|
2021-06-28 07:36:41 -04:00
|
|
|
args,
|
|
|
|
name,
|
|
|
|
default,
|
|
|
|
required=required,
|
|
|
|
allowed_values=allowed_values,
|
|
|
|
encoding=encoding,
|
2016-09-15 05:36:19 -04:00
|
|
|
)
|
2016-03-09 06:26:26 -05:00
|
|
|
|
2016-09-15 05:36:19 -04:00
|
|
|
|
2023-02-01 16:35:24 -05:00
|
|
|
EnumT = TypeVar("EnumT", bound=enum.Enum)
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_enum(
|
|
|
|
request: Request,
|
|
|
|
name: str,
|
|
|
|
E: Type[EnumT],
|
|
|
|
default: EnumT,
|
|
|
|
) -> EnumT:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_enum(
|
|
|
|
request: Request,
|
|
|
|
name: str,
|
|
|
|
E: Type[EnumT],
|
|
|
|
*,
|
|
|
|
required: Literal[True],
|
|
|
|
) -> EnumT:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
def parse_enum(
|
|
|
|
request: Request,
|
|
|
|
name: str,
|
|
|
|
E: Type[EnumT],
|
|
|
|
default: Optional[EnumT] = None,
|
|
|
|
required: bool = False,
|
|
|
|
) -> Optional[EnumT]:
|
|
|
|
"""
|
|
|
|
Parse an enum parameter from the request query string.
|
|
|
|
|
|
|
|
Note that the enum *must only have string values*.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
request: the twisted HTTP request.
|
|
|
|
name: the name of the query parameter.
|
|
|
|
E: the enum which represents valid values
|
|
|
|
default: enum value to use if the parameter is absent, defaults to None.
|
|
|
|
required: whether to raise a 400 SynapseError if the
|
|
|
|
parameter is absent, defaults to False.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
An enum value.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError if the parameter is absent and required, or if the
|
|
|
|
parameter is present, must be one of a list of allowed values and
|
|
|
|
is not one of those allowed values.
|
|
|
|
"""
|
|
|
|
# Assert the enum values are strings.
|
|
|
|
assert all(
|
|
|
|
isinstance(e.value, str) for e in E
|
|
|
|
), "parse_enum only works with string values"
|
|
|
|
str_value = parse_string(
|
|
|
|
request,
|
|
|
|
name,
|
|
|
|
default=default.value if default is not None else None,
|
|
|
|
required=required,
|
|
|
|
allowed_values=[e.value for e in E],
|
|
|
|
)
|
|
|
|
if str_value is None:
|
|
|
|
return None
|
|
|
|
return E(str_value)
|
|
|
|
|
|
|
|
|
2021-05-28 09:19:06 -04:00
|
|
|
def _parse_string_value(
|
2021-06-08 08:30:48 -04:00
|
|
|
value: bytes,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection],
|
2021-05-28 09:19:06 -04:00
|
|
|
name: str,
|
2021-06-08 08:30:48 -04:00
|
|
|
encoding: str,
|
|
|
|
) -> str:
|
|
|
|
try:
|
|
|
|
value_str = value.decode(encoding)
|
|
|
|
except ValueError:
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(
|
|
|
|
HTTPStatus.BAD_REQUEST, "Query parameter %r must be %s" % (name, encoding)
|
|
|
|
)
|
2021-05-28 09:19:06 -04:00
|
|
|
|
2021-06-08 08:30:48 -04:00
|
|
|
if allowed_values is not None and value_str not in allowed_values:
|
2021-05-28 09:19:06 -04:00
|
|
|
message = "Query parameter %r must be one of [%s]" % (
|
|
|
|
name,
|
|
|
|
", ".join(repr(v) for v in allowed_values),
|
|
|
|
)
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(HTTPStatus.BAD_REQUEST, message, errcode=Codes.INVALID_PARAM)
|
2021-05-28 09:19:06 -04:00
|
|
|
else:
|
2021-06-08 08:30:48 -04:00
|
|
|
return value_str
|
2021-05-28 09:19:06 -04:00
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_strings_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-08 08:30:48 -04:00
|
|
|
name: str,
|
2021-06-28 07:36:41 -04:00
|
|
|
*,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-06-28 07:36:41 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> Optional[List[str]]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_strings_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
|
|
|
name: str,
|
|
|
|
default: List[str],
|
|
|
|
*,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-07-21 14:12:22 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> List[str]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_strings_from_args(
|
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-28 07:36:41 -04:00
|
|
|
name: str,
|
|
|
|
*,
|
|
|
|
required: Literal[True],
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-06-08 08:30:48 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> List[str]:
|
2021-05-28 09:19:06 -04:00
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_strings_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-08 08:30:48 -04:00
|
|
|
name: str,
|
2021-05-28 09:19:06 -04:00
|
|
|
default: Optional[List[str]] = None,
|
2021-06-28 07:36:41 -04:00
|
|
|
*,
|
2021-05-28 09:19:06 -04:00
|
|
|
required: bool = False,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-05-28 09:19:06 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> Optional[List[str]]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
def parse_strings_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-08 08:30:48 -04:00
|
|
|
name: str,
|
2021-05-28 09:19:06 -04:00
|
|
|
default: Optional[List[str]] = None,
|
|
|
|
required: bool = False,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-06-08 08:30:48 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> Optional[List[str]]:
|
2021-05-28 09:19:06 -04:00
|
|
|
"""
|
|
|
|
Parse a string parameter from the request query string list.
|
|
|
|
|
2021-06-08 08:30:48 -04:00
|
|
|
The content of the query param will be decoded to Unicode using the encoding.
|
2021-05-28 09:19:06 -04:00
|
|
|
|
|
|
|
Args:
|
2021-06-08 08:30:48 -04:00
|
|
|
args: A mapping of request args as bytes to a list of bytes (e.g. request.args).
|
2021-05-28 09:19:06 -04:00
|
|
|
name: the name of the query parameter.
|
2021-06-08 08:30:48 -04:00
|
|
|
default: value to use if the parameter is absent, defaults to None.
|
|
|
|
required: whether to raise a 400 SynapseError if the
|
2021-05-28 09:19:06 -04:00
|
|
|
parameter is absent, defaults to False.
|
2021-06-08 08:30:48 -04:00
|
|
|
allowed_values: List of allowed values for the
|
|
|
|
string, or None if any value is allowed, defaults to None.
|
2021-05-28 09:19:06 -04:00
|
|
|
encoding: The encoding to decode the string content with.
|
|
|
|
|
|
|
|
Returns:
|
2021-06-08 08:30:48 -04:00
|
|
|
A string value or the default.
|
2021-05-28 09:19:06 -04:00
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError if the parameter is absent and required, or if the
|
|
|
|
parameter is present, must be one of a list of allowed values and
|
|
|
|
is not one of those allowed values.
|
|
|
|
"""
|
2021-06-08 08:30:48 -04:00
|
|
|
name_bytes = name.encode("ascii")
|
2018-08-20 09:54:49 -04:00
|
|
|
|
2021-06-08 08:30:48 -04:00
|
|
|
if name_bytes in args:
|
|
|
|
values = args[name_bytes]
|
2021-05-28 09:19:06 -04:00
|
|
|
|
|
|
|
return [
|
|
|
|
_parse_string_value(value, allowed_values, name=name, encoding=encoding)
|
|
|
|
for value in values
|
|
|
|
]
|
2015-04-21 11:35:53 -04:00
|
|
|
else:
|
|
|
|
if required:
|
2021-06-08 08:30:48 -04:00
|
|
|
message = "Missing string query parameter %r" % (name,)
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(
|
|
|
|
HTTPStatus.BAD_REQUEST, message, errcode=Codes.MISSING_PARAM
|
|
|
|
)
|
2018-08-20 09:54:49 -04:00
|
|
|
|
2021-06-08 08:30:48 -04:00
|
|
|
return default
|
2015-04-21 11:35:53 -04:00
|
|
|
|
|
|
|
|
2021-06-08 11:19:25 -04:00
|
|
|
@overload
|
|
|
|
def parse_string_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-08 11:19:25 -04:00
|
|
|
name: str,
|
|
|
|
default: Optional[str] = None,
|
2021-06-28 07:36:41 -04:00
|
|
|
*,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-06-28 07:36:41 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> Optional[str]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_string_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-28 07:36:41 -04:00
|
|
|
name: str,
|
|
|
|
default: Optional[str] = None,
|
|
|
|
*,
|
|
|
|
required: Literal[True],
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-06-08 11:19:25 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> str:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_string_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-08 11:19:25 -04:00
|
|
|
name: str,
|
|
|
|
default: Optional[str] = None,
|
|
|
|
required: bool = False,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-06-08 11:19:25 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> Optional[str]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
2021-05-28 09:19:06 -04:00
|
|
|
def parse_string_from_args(
|
2021-07-21 14:12:22 -04:00
|
|
|
args: Mapping[bytes, Sequence[bytes]],
|
2021-06-08 08:30:48 -04:00
|
|
|
name: str,
|
2021-05-28 09:19:06 -04:00
|
|
|
default: Optional[str] = None,
|
|
|
|
required: bool = False,
|
2023-09-13 07:57:19 -04:00
|
|
|
allowed_values: Optional[StrCollection] = None,
|
2021-06-08 08:30:48 -04:00
|
|
|
encoding: str = "ascii",
|
|
|
|
) -> Optional[str]:
|
2021-05-28 09:19:06 -04:00
|
|
|
"""
|
|
|
|
Parse the string parameter from the request query string list
|
|
|
|
and return the first result.
|
|
|
|
|
2021-06-08 08:30:48 -04:00
|
|
|
The content of the query param will be decoded to Unicode using the encoding.
|
2021-05-28 09:19:06 -04:00
|
|
|
|
|
|
|
Args:
|
2021-06-08 08:30:48 -04:00
|
|
|
args: A mapping of request args as bytes to a list of bytes (e.g. request.args).
|
2021-05-28 09:19:06 -04:00
|
|
|
name: the name of the query parameter.
|
2021-06-08 08:30:48 -04:00
|
|
|
default: value to use if the parameter is absent, defaults to None.
|
2021-05-28 09:19:06 -04:00
|
|
|
required: whether to raise a 400 SynapseError if the
|
|
|
|
parameter is absent, defaults to False.
|
|
|
|
allowed_values: List of allowed values for the
|
|
|
|
string, or None if any value is allowed, defaults to None. Must be
|
|
|
|
the same type as name, if given.
|
|
|
|
encoding: The encoding to decode the string content with.
|
|
|
|
|
|
|
|
Returns:
|
2021-06-08 08:30:48 -04:00
|
|
|
A string value or the default.
|
2021-05-28 09:19:06 -04:00
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError if the parameter is absent and required, or if the
|
|
|
|
parameter is present, must be one of a list of allowed values and
|
|
|
|
is not one of those allowed values.
|
|
|
|
"""
|
|
|
|
|
|
|
|
strings = parse_strings_from_args(
|
|
|
|
args,
|
|
|
|
name,
|
2021-06-08 08:30:48 -04:00
|
|
|
default=[default] if default is not None else None,
|
2021-05-28 09:19:06 -04:00
|
|
|
required=required,
|
|
|
|
allowed_values=allowed_values,
|
|
|
|
encoding=encoding,
|
|
|
|
)
|
|
|
|
|
2021-06-08 08:30:48 -04:00
|
|
|
if strings is None:
|
|
|
|
return None
|
|
|
|
|
2021-05-28 09:19:06 -04:00
|
|
|
return strings[0]
|
|
|
|
|
|
|
|
|
2021-09-03 09:22:22 -04:00
|
|
|
@overload
|
|
|
|
def parse_json_value_from_request(request: Request) -> JsonDict:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_json_value_from_request(
|
|
|
|
request: Request, allow_empty_body: Literal[False]
|
|
|
|
) -> JsonDict:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
|
|
|
@overload
|
|
|
|
def parse_json_value_from_request(
|
|
|
|
request: Request, allow_empty_body: bool = False
|
|
|
|
) -> Optional[JsonDict]:
|
|
|
|
...
|
|
|
|
|
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
def parse_json_value_from_request(
|
|
|
|
request: Request, allow_empty_body: bool = False
|
|
|
|
) -> Optional[JsonDict]:
|
2016-03-14 10:16:41 -04:00
|
|
|
"""Parse a JSON value from the body of a twisted HTTP request.
|
2016-03-09 06:26:26 -05:00
|
|
|
|
2016-04-01 11:08:59 -04:00
|
|
|
Args:
|
|
|
|
request: the twisted HTTP request.
|
2021-07-21 14:12:22 -04:00
|
|
|
allow_empty_body: if True, an empty body will be accepted and turned into None
|
2016-04-01 11:08:59 -04:00
|
|
|
|
|
|
|
Returns:
|
|
|
|
The JSON value.
|
|
|
|
|
|
|
|
Raises:
|
2016-03-14 10:16:41 -04:00
|
|
|
SynapseError if the request body couldn't be decoded as JSON.
|
2016-03-09 06:26:26 -05:00
|
|
|
"""
|
|
|
|
try:
|
2021-07-21 14:12:22 -04:00
|
|
|
content_bytes = request.content.read() # type: ignore
|
2017-10-23 10:52:32 -04:00
|
|
|
except Exception:
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(HTTPStatus.BAD_REQUEST, "Error reading JSON content.")
|
2016-03-11 11:41:03 -05:00
|
|
|
|
2018-02-08 13:44:52 -05:00
|
|
|
if not content_bytes and allow_empty_body:
|
|
|
|
return None
|
|
|
|
|
2018-08-01 10:54:06 -04:00
|
|
|
try:
|
2020-08-19 07:26:03 -04:00
|
|
|
content = json_decoder.decode(content_bytes.decode("utf-8"))
|
2017-11-10 04:15:39 -05:00
|
|
|
except Exception as e:
|
2022-10-07 12:39:45 -04:00
|
|
|
logger.warning(
|
|
|
|
"Unable to parse JSON from %s %s response: %s (%s)",
|
|
|
|
request.method.decode("ascii", errors="replace"),
|
|
|
|
redact_uri(request.uri.decode("ascii", errors="replace")),
|
|
|
|
e,
|
|
|
|
content_bytes,
|
|
|
|
)
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(
|
|
|
|
HTTPStatus.BAD_REQUEST, "Content not JSON.", errcode=Codes.NOT_JSON
|
|
|
|
)
|
2016-03-09 06:26:26 -05:00
|
|
|
|
2016-03-14 10:16:41 -04:00
|
|
|
return content
|
|
|
|
|
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
def parse_json_object_from_request(
|
|
|
|
request: Request, allow_empty_body: bool = False
|
|
|
|
) -> JsonDict:
|
2016-03-14 10:16:41 -04:00
|
|
|
"""Parse a JSON object from the body of a twisted HTTP request.
|
|
|
|
|
2016-04-01 11:08:59 -04:00
|
|
|
Args:
|
|
|
|
request: the twisted HTTP request.
|
2021-07-21 14:12:22 -04:00
|
|
|
allow_empty_body: if True, an empty body will be accepted and turned into
|
|
|
|
an empty dict.
|
2016-04-01 11:08:59 -04:00
|
|
|
|
|
|
|
Raises:
|
2016-03-14 10:16:41 -04:00
|
|
|
SynapseError if the request body couldn't be decoded as JSON or
|
|
|
|
if it wasn't a JSON object.
|
|
|
|
"""
|
2018-02-08 13:44:52 -05:00
|
|
|
content = parse_json_value_from_request(request, allow_empty_body=allow_empty_body)
|
|
|
|
|
|
|
|
if allow_empty_body and content is None:
|
|
|
|
return {}
|
2016-03-14 10:16:41 -04:00
|
|
|
|
2021-07-21 14:12:22 -04:00
|
|
|
if not isinstance(content, dict):
|
2016-03-11 11:41:03 -05:00
|
|
|
message = "Content must be a JSON object."
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(HTTPStatus.BAD_REQUEST, message, errcode=Codes.BAD_JSON)
|
2016-03-11 11:41:03 -05:00
|
|
|
|
|
|
|
return content
|
|
|
|
|
2016-03-09 06:26:26 -05:00
|
|
|
|
2022-08-15 15:05:57 -04:00
|
|
|
Model = TypeVar("Model", bound=BaseModel)
|
|
|
|
|
|
|
|
|
2023-03-24 08:31:14 -04:00
|
|
|
def validate_json_object(content: JsonDict, model_type: Type[Model]) -> Model:
|
|
|
|
"""Validate a deserialized JSON object using the given pydantic model.
|
2022-08-15 15:05:57 -04:00
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError if the request body couldn't be decoded as JSON or
|
|
|
|
if it wasn't a JSON object.
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
instance = model_type.parse_obj(content)
|
|
|
|
except ValidationError as e:
|
2022-09-07 07:16:10 -04:00
|
|
|
# Choose a matrix error code. The catch-all is BAD_JSON, but we try to find a
|
|
|
|
# more specific error if possible (which occasionally helps us to be spec-
|
|
|
|
# compliant) This is a bit awkward because the spec's error codes aren't very
|
|
|
|
# clear-cut: BAD_JSON arguably overlaps with MISSING_PARAM and INVALID_PARAM.
|
|
|
|
errcode = Codes.BAD_JSON
|
|
|
|
|
|
|
|
raw_errors = e.raw_errors
|
|
|
|
if len(raw_errors) == 1 and isinstance(raw_errors[0], ErrorWrapper):
|
|
|
|
raw_error = raw_errors[0].exc
|
|
|
|
if isinstance(raw_error, MissingError):
|
|
|
|
errcode = Codes.MISSING_PARAM
|
|
|
|
elif isinstance(raw_error, PydanticValueError):
|
|
|
|
errcode = Codes.INVALID_PARAM
|
|
|
|
|
|
|
|
raise SynapseError(HTTPStatus.BAD_REQUEST, str(e), errcode=errcode)
|
2022-08-15 15:05:57 -04:00
|
|
|
|
|
|
|
return instance
|
|
|
|
|
|
|
|
|
2023-03-24 08:31:14 -04:00
|
|
|
def parse_and_validate_json_object_from_request(
|
|
|
|
request: Request, model_type: Type[Model]
|
|
|
|
) -> Model:
|
|
|
|
"""Parse a JSON object from the body of a twisted HTTP request, then deserialise and
|
|
|
|
validate using the given pydantic model.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError if the request body couldn't be decoded as JSON or
|
|
|
|
if it wasn't a JSON object.
|
|
|
|
"""
|
|
|
|
content = parse_json_object_from_request(request, allow_empty_body=False)
|
|
|
|
return validate_json_object(content, model_type)
|
|
|
|
|
|
|
|
|
2023-09-13 07:57:19 -04:00
|
|
|
def assert_params_in_dict(body: JsonDict, required: StrCollection) -> None:
|
2017-03-13 13:27:51 -04:00
|
|
|
absent = []
|
|
|
|
for k in required:
|
|
|
|
if k not in body:
|
|
|
|
absent.append(k)
|
|
|
|
|
|
|
|
if len(absent) > 0:
|
2021-12-09 06:58:25 -05:00
|
|
|
raise SynapseError(
|
|
|
|
HTTPStatus.BAD_REQUEST, "Missing params: %r" % absent, Codes.MISSING_PARAM
|
|
|
|
)
|
2017-03-13 13:27:51 -04:00
|
|
|
|
|
|
|
|
2020-09-04 06:54:56 -04:00
|
|
|
class RestServlet:
|
2015-01-23 09:16:28 -05:00
|
|
|
|
|
|
|
"""A Synapse REST Servlet.
|
|
|
|
|
|
|
|
An implementing class can either provide its own custom 'register' method,
|
|
|
|
or use the automatic pattern handling provided by the base class.
|
|
|
|
|
|
|
|
To use this latter, the implementing class instead provides a `PATTERN`
|
|
|
|
class attribute containing a pre-compiled regular expression. The automatic
|
|
|
|
register method will then use this method to register any of the following
|
|
|
|
instance methods associated with the corresponding HTTP method:
|
|
|
|
|
|
|
|
on_GET
|
|
|
|
on_PUT
|
|
|
|
on_POST
|
|
|
|
on_DELETE
|
|
|
|
|
|
|
|
Automatically handles turning CodeMessageExceptions thrown by these methods
|
|
|
|
into the appropriate HTTP response.
|
|
|
|
"""
|
|
|
|
|
2021-12-14 07:00:47 -05:00
|
|
|
def register(self, http_server: HttpServer) -> None:
|
2021-06-17 10:20:06 -04:00
|
|
|
"""Register this servlet with the given HTTP server."""
|
2021-06-08 08:30:48 -04:00
|
|
|
patterns = getattr(self, "PATTERNS", None)
|
|
|
|
if patterns:
|
2020-10-22 08:35:55 -04:00
|
|
|
for method in ("GET", "PUT", "POST", "DELETE"):
|
2015-03-13 11:24:03 -04:00
|
|
|
if hasattr(self, "on_%s" % (method,)):
|
2019-07-24 08:07:35 -04:00
|
|
|
servlet_classname = self.__class__.__name__
|
2015-03-13 11:24:03 -04:00
|
|
|
method_handler = getattr(self, "on_%s" % (method,))
|
2019-07-11 05:36:03 -04:00
|
|
|
http_server.register_paths(
|
2019-09-05 09:46:04 -04:00
|
|
|
method, patterns, method_handler, servlet_classname
|
2019-07-11 05:36:03 -04:00
|
|
|
)
|
2015-12-01 12:34:32 -05:00
|
|
|
|
2015-01-23 09:16:28 -05:00
|
|
|
else:
|
|
|
|
raise NotImplementedError("RestServlet must register something.")
|
2021-08-16 10:49:12 -04:00
|
|
|
|
|
|
|
|
|
|
|
class ResolveRoomIdMixin:
|
|
|
|
def __init__(self, hs: "HomeServer"):
|
|
|
|
self.room_member_handler = hs.get_room_member_handler()
|
|
|
|
|
|
|
|
async def resolve_room_id(
|
|
|
|
self, room_identifier: str, remote_room_hosts: Optional[List[str]] = None
|
|
|
|
) -> Tuple[str, Optional[List[str]]]:
|
|
|
|
"""
|
|
|
|
Resolve a room identifier to a room ID, if necessary.
|
|
|
|
|
|
|
|
This also performanes checks to ensure the room ID is of the proper form.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
room_identifier: The room ID or alias.
|
|
|
|
remote_room_hosts: The potential remote room hosts to use.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The resolved room ID.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
SynapseError if the room ID is of the wrong form.
|
|
|
|
"""
|
|
|
|
if RoomID.is_valid(room_identifier):
|
|
|
|
resolved_room_id = room_identifier
|
|
|
|
elif RoomAlias.is_valid(room_identifier):
|
|
|
|
room_alias = RoomAlias.from_string(room_identifier)
|
|
|
|
(
|
|
|
|
room_id,
|
|
|
|
remote_room_hosts,
|
|
|
|
) = await self.room_member_handler.lookup_room_alias(room_alias)
|
|
|
|
resolved_room_id = room_id.to_string()
|
|
|
|
else:
|
|
|
|
raise SynapseError(
|
2021-12-09 06:58:25 -05:00
|
|
|
HTTPStatus.BAD_REQUEST,
|
|
|
|
"%s was not legal room ID or room alias" % (room_identifier,),
|
2021-08-16 10:49:12 -04:00
|
|
|
)
|
|
|
|
if not resolved_room_id:
|
|
|
|
raise SynapseError(
|
2021-12-09 06:58:25 -05:00
|
|
|
HTTPStatus.BAD_REQUEST,
|
|
|
|
"Unknown room ID or room alias %s" % room_identifier,
|
2021-08-16 10:49:12 -04:00
|
|
|
)
|
|
|
|
return resolved_room_id, remote_room_hosts
|