123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539 |
- # Copyright 2014 - 2016 OpenMarket Ltd
- #
- # Licensed under the Apache License, Version 2.0 (the "License");
- # you may not use this file except in compliance with the License.
- # You may obtain a copy of the License at
- #
- # http://www.apache.org/licenses/LICENSE-2.0
- #
- # Unless required by applicable law or agreed to in writing, software
- # distributed under the License is distributed on an "AS IS" BASIS,
- # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- # See the License for the specific language governing permissions and
- # limitations under the License.
- import logging
- from typing import TYPE_CHECKING, Any, Optional, Tuple
- import attr
- import msgpack
- from unpaddedbase64 import decode_base64, encode_base64
- from synapse.api.constants import (
- EventContentFields,
- EventTypes,
- GuestAccess,
- HistoryVisibility,
- JoinRules,
- PublicRoomsFilterFields,
- )
- from synapse.api.errors import (
- Codes,
- HttpResponseException,
- RequestSendFailed,
- SynapseError,
- )
- from synapse.types import JsonDict, ThirdPartyInstanceID
- from synapse.util.caches.descriptors import _CacheContext, cached
- from synapse.util.caches.response_cache import ResponseCache
- if TYPE_CHECKING:
- from synapse.server import HomeServer
- logger = logging.getLogger(__name__)
- REMOTE_ROOM_LIST_POLL_INTERVAL = 60 * 1000
- # This is used to indicate we should only return rooms published to the main list.
- EMPTY_THIRD_PARTY_ID = ThirdPartyInstanceID(None, None)
- class RoomListHandler:
- def __init__(self, hs: "HomeServer"):
- self.store = hs.get_datastores().main
- self._storage_controllers = hs.get_storage_controllers()
- self.hs = hs
- self.enable_room_list_search = hs.config.roomdirectory.enable_room_list_search
- self.response_cache: ResponseCache[
- Tuple[Optional[int], Optional[str], Optional[ThirdPartyInstanceID]]
- ] = ResponseCache(hs.get_clock(), "room_list")
- self.remote_response_cache: ResponseCache[
- Tuple[str, Optional[int], Optional[str], bool, Optional[str]]
- ] = ResponseCache(hs.get_clock(), "remote_room_list", timeout_ms=30 * 1000)
- async def get_local_public_room_list(
- self,
- limit: Optional[int] = None,
- since_token: Optional[str] = None,
- search_filter: Optional[dict] = None,
- network_tuple: Optional[ThirdPartyInstanceID] = EMPTY_THIRD_PARTY_ID,
- from_federation: bool = False,
- ) -> JsonDict:
- """Generate a local public room list.
- There are multiple different lists: the main one plus one per third
- party network. A client can ask for a specific list or to return all.
- Args:
- limit
- since_token
- search_filter
- network_tuple: Which public list to use.
- This can be (None, None) to indicate the main list, or a particular
- appservice and network id to use an appservice specific one.
- Setting to None returns all public rooms across all lists.
- from_federation: true iff the request comes from the federation API
- """
- if not self.enable_room_list_search:
- return {"chunk": [], "total_room_count_estimate": 0}
- logger.info(
- "Getting public room list: limit=%r, since=%r, search=%r, network=%r",
- limit,
- since_token,
- bool(search_filter),
- network_tuple,
- )
- if search_filter:
- # We explicitly don't bother caching searches or requests for
- # appservice specific lists.
- logger.info("Bypassing cache as search request.")
- return await self._get_public_room_list(
- limit,
- since_token,
- search_filter,
- network_tuple=network_tuple,
- from_federation=from_federation,
- )
- key = (limit, since_token, network_tuple)
- return await self.response_cache.wrap(
- key,
- self._get_public_room_list,
- limit,
- since_token,
- network_tuple=network_tuple,
- from_federation=from_federation,
- )
- async def _get_public_room_list(
- self,
- limit: Optional[int] = None,
- since_token: Optional[str] = None,
- search_filter: Optional[dict] = None,
- network_tuple: Optional[ThirdPartyInstanceID] = EMPTY_THIRD_PARTY_ID,
- from_federation: bool = False,
- ) -> JsonDict:
- """Generate a public room list.
- Args:
- limit: Maximum amount of rooms to return.
- since_token:
- search_filter: Dictionary to filter rooms by.
- network_tuple: Which public list to use.
- This can be (None, None) to indicate the main list, or a particular
- appservice and network id to use an appservice specific one.
- Setting to None returns all public rooms across all lists.
- from_federation: Whether this request originated from a
- federating server or a client. Used for room filtering.
- """
- # Pagination tokens work by storing the room ID sent in the last batch,
- # plus the direction (forwards or backwards). Next batch tokens always
- # go forwards, prev batch tokens always go backwards.
- if since_token:
- batch_token = RoomListNextBatch.from_token(since_token)
- bounds: Optional[Tuple[int, str]] = (
- batch_token.last_joined_members,
- batch_token.last_room_id,
- )
- forwards = batch_token.direction_is_forward
- has_batch_token = True
- else:
- bounds = None
- forwards = True
- has_batch_token = False
- # we request one more than wanted to see if there are more pages to come
- probing_limit = limit + 1 if limit is not None else None
- results = await self.store.get_largest_public_rooms(
- network_tuple,
- search_filter,
- probing_limit,
- bounds=bounds,
- forwards=forwards,
- ignore_non_federatable=from_federation,
- )
- def build_room_entry(room: JsonDict) -> JsonDict:
- entry = {
- "room_id": room["room_id"],
- "name": room["name"],
- "topic": room["topic"],
- "canonical_alias": room["canonical_alias"],
- "num_joined_members": room["joined_members"],
- "avatar_url": room["avatar"],
- "world_readable": room["history_visibility"]
- == HistoryVisibility.WORLD_READABLE,
- "guest_can_join": room["guest_access"] == "can_join",
- "join_rule": room["join_rules"],
- "room_type": room["room_type"],
- }
- # Filter out Nones – rather omit the field altogether
- return {k: v for k, v in entry.items() if v is not None}
- results = [build_room_entry(r) for r in results]
- response: JsonDict = {}
- num_results = len(results)
- if limit is not None:
- more_to_come = num_results == probing_limit
- # Depending on direction we trim either the front or back.
- if forwards:
- results = results[:limit]
- else:
- results = results[-limit:]
- else:
- more_to_come = False
- if num_results > 0:
- final_entry = results[-1]
- initial_entry = results[0]
- if forwards:
- if has_batch_token:
- # If there was a token given then we assume that there
- # must be previous results.
- response["prev_batch"] = RoomListNextBatch(
- last_joined_members=initial_entry["num_joined_members"],
- last_room_id=initial_entry["room_id"],
- direction_is_forward=False,
- ).to_token()
- if more_to_come:
- response["next_batch"] = RoomListNextBatch(
- last_joined_members=final_entry["num_joined_members"],
- last_room_id=final_entry["room_id"],
- direction_is_forward=True,
- ).to_token()
- else:
- if has_batch_token:
- response["next_batch"] = RoomListNextBatch(
- last_joined_members=final_entry["num_joined_members"],
- last_room_id=final_entry["room_id"],
- direction_is_forward=True,
- ).to_token()
- if more_to_come:
- response["prev_batch"] = RoomListNextBatch(
- last_joined_members=initial_entry["num_joined_members"],
- last_room_id=initial_entry["room_id"],
- direction_is_forward=False,
- ).to_token()
- response["chunk"] = results
- response["total_room_count_estimate"] = await self.store.count_public_rooms(
- network_tuple,
- ignore_non_federatable=from_federation,
- search_filter=search_filter,
- )
- return response
- @cached(num_args=1, cache_context=True)
- async def generate_room_entry(
- self,
- room_id: str,
- num_joined_users: int,
- cache_context: _CacheContext,
- with_alias: bool = True,
- allow_private: bool = False,
- ) -> Optional[JsonDict]:
- """Returns the entry for a room
- Args:
- room_id: The room's ID.
- num_joined_users: Number of users in the room.
- cache_context: Information for cached responses.
- with_alias: Whether to return the room's aliases in the result.
- allow_private: Whether invite-only rooms should be shown.
- Returns:
- Returns a room entry as a dictionary, or None if this
- room was determined not to be shown publicly.
- """
- result = {"room_id": room_id, "num_joined_members": num_joined_users}
- if with_alias:
- aliases = await self.store.get_aliases_for_room(
- room_id, on_invalidate=cache_context.invalidate
- )
- if aliases:
- result["aliases"] = aliases
- current_state_ids = await self._storage_controllers.state.get_current_state_ids(
- room_id, on_invalidate=cache_context.invalidate
- )
- if not current_state_ids:
- # We're not in the room, so may as well bail out here.
- return result
- event_map = await self.store.get_events(
- [
- event_id
- for key, event_id in current_state_ids.items()
- if key[0]
- in (
- EventTypes.Create,
- EventTypes.JoinRules,
- EventTypes.Name,
- EventTypes.Topic,
- EventTypes.CanonicalAlias,
- EventTypes.RoomHistoryVisibility,
- EventTypes.GuestAccess,
- "m.room.avatar",
- )
- ]
- )
- current_state = {(ev.type, ev.state_key): ev for ev in event_map.values()}
- # Double check that this is actually a public room.
- join_rules_event = current_state.get((EventTypes.JoinRules, ""))
- if join_rules_event:
- join_rule = join_rules_event.content.get("join_rule", None)
- if not allow_private and join_rule and join_rule != JoinRules.PUBLIC:
- return None
- # Return whether this room is open to federation users or not
- create_event = current_state[EventTypes.Create, ""]
- result["m.federate"] = create_event.content.get(
- EventContentFields.FEDERATE, True
- )
- name_event = current_state.get((EventTypes.Name, ""))
- if name_event:
- name = name_event.content.get("name", None)
- if name:
- result["name"] = name
- topic_event = current_state.get((EventTypes.Topic, ""))
- if topic_event:
- topic = topic_event.content.get("topic", None)
- if topic:
- result["topic"] = topic
- canonical_event = current_state.get((EventTypes.CanonicalAlias, ""))
- if canonical_event:
- canonical_alias = canonical_event.content.get("alias", None)
- if canonical_alias:
- result["canonical_alias"] = canonical_alias
- visibility_event = current_state.get((EventTypes.RoomHistoryVisibility, ""))
- visibility = None
- if visibility_event:
- visibility = visibility_event.content.get("history_visibility", None)
- result["world_readable"] = visibility == HistoryVisibility.WORLD_READABLE
- guest_event = current_state.get((EventTypes.GuestAccess, ""))
- guest = None
- if guest_event:
- guest = guest_event.content.get(EventContentFields.GUEST_ACCESS)
- result["guest_can_join"] = guest == GuestAccess.CAN_JOIN
- avatar_event = current_state.get(("m.room.avatar", ""))
- if avatar_event:
- avatar_url = avatar_event.content.get("url", None)
- if avatar_url:
- result["avatar_url"] = avatar_url
- return result
- async def get_remote_public_room_list(
- self,
- server_name: str,
- limit: Optional[int] = None,
- since_token: Optional[str] = None,
- search_filter: Optional[dict] = None,
- include_all_networks: bool = False,
- third_party_instance_id: Optional[str] = None,
- ) -> JsonDict:
- """Get the public room list from remote server
- Raises:
- SynapseError
- """
- if not self.enable_room_list_search:
- return {"chunk": [], "total_room_count_estimate": 0}
- if search_filter:
- # Searching across federation is defined in MSC2197.
- # However, the remote homeserver may or may not actually support it.
- # So we first try an MSC2197 remote-filtered search, then fall back
- # to a locally-filtered search if we must.
- try:
- res = await self._get_remote_list_cached(
- server_name,
- limit=limit,
- since_token=since_token,
- include_all_networks=include_all_networks,
- third_party_instance_id=third_party_instance_id,
- search_filter=search_filter,
- )
- return res
- except HttpResponseException as hre:
- syn_err = hre.to_synapse_error()
- if hre.code in (404, 405) or syn_err.errcode in (
- Codes.UNRECOGNIZED,
- Codes.NOT_FOUND,
- ):
- logger.debug("Falling back to locally-filtered /publicRooms")
- else:
- # Not an error that should trigger a fallback.
- raise SynapseError(502, "Failed to fetch room list")
- except RequestSendFailed:
- # Not an error that should trigger a fallback.
- raise SynapseError(502, "Failed to fetch room list")
- # if we reach this point, then we fall back to the situation where
- # we currently don't support searching across federation, so we have
- # to do it manually without pagination
- limit = None
- since_token = None
- try:
- res = await self._get_remote_list_cached(
- server_name,
- limit=limit,
- since_token=since_token,
- include_all_networks=include_all_networks,
- third_party_instance_id=third_party_instance_id,
- )
- except (RequestSendFailed, HttpResponseException):
- raise SynapseError(502, "Failed to fetch room list")
- if search_filter:
- res = {
- "chunk": [
- entry
- for entry in list(res.get("chunk", []))
- if _matches_room_entry(entry, search_filter)
- ]
- }
- return res
- async def _get_remote_list_cached(
- self,
- server_name: str,
- limit: Optional[int] = None,
- since_token: Optional[str] = None,
- search_filter: Optional[dict] = None,
- include_all_networks: bool = False,
- third_party_instance_id: Optional[str] = None,
- ) -> JsonDict:
- """Wrapper around FederationClient.get_public_rooms that caches the
- result.
- """
- repl_layer = self.hs.get_federation_client()
- if search_filter:
- # We can't cache when asking for search
- return await repl_layer.get_public_rooms(
- server_name,
- limit=limit,
- since_token=since_token,
- search_filter=search_filter,
- include_all_networks=include_all_networks,
- third_party_instance_id=third_party_instance_id,
- )
- key = (
- server_name,
- limit,
- since_token,
- include_all_networks,
- third_party_instance_id,
- )
- return await self.remote_response_cache.wrap(
- key,
- repl_layer.get_public_rooms,
- server_name,
- limit=limit,
- since_token=since_token,
- search_filter=search_filter,
- include_all_networks=include_all_networks,
- third_party_instance_id=third_party_instance_id,
- )
- @attr.s(slots=True, frozen=True, auto_attribs=True)
- class RoomListNextBatch:
- last_joined_members: int # The count to get rooms after/before
- last_room_id: str # The room_id to get rooms after/before
- direction_is_forward: bool # True if this is a next_batch, false if prev_batch
- KEY_DICT = {
- "last_joined_members": "m",
- "last_room_id": "r",
- "direction_is_forward": "d",
- }
- REVERSE_KEY_DICT = {v: k for k, v in KEY_DICT.items()}
- @classmethod
- def from_token(cls, token: str) -> "RoomListNextBatch":
- decoded = msgpack.loads(decode_base64(token), raw=False)
- return RoomListNextBatch(
- **{cls.REVERSE_KEY_DICT[key]: val for key, val in decoded.items()}
- )
- def to_token(self) -> str:
- return encode_base64(
- msgpack.dumps(
- {self.KEY_DICT[key]: val for key, val in attr.asdict(self).items()}
- )
- )
- def copy_and_replace(self, **kwds: Any) -> "RoomListNextBatch":
- return attr.evolve(self, **kwds)
- def _matches_room_entry(room_entry: JsonDict, search_filter: dict) -> bool:
- """Determines whether the given search filter matches a room entry returned over
- federation.
- Only used if the remote server does not support MSC2197 remote-filtered search, and
- hence does not support MSC3827 filtering of `/publicRooms` by room type either.
- In this case, we cannot apply the `room_type` filter since no `room_type` field is
- returned.
- """
- if search_filter and search_filter.get(
- PublicRoomsFilterFields.GENERIC_SEARCH_TERM, None
- ):
- generic_search_term = search_filter[
- PublicRoomsFilterFields.GENERIC_SEARCH_TERM
- ].upper()
- if generic_search_term in room_entry.get("name", "").upper():
- return True
- elif generic_search_term in room_entry.get("topic", "").upper():
- return True
- elif generic_search_term in room_entry.get("canonical_alias", "").upper():
- return True
- else:
- return True
- return False
|