async def incoming_device_list_update(self, origin: str, edu_content: JsonDict) -> None: """Called on incoming device list update from federation. Responsible for parsing the EDU and adding to pending updates list. """ set_tag("origin", origin) set_tag("edu_content", edu_content) user_id = edu_content.pop("user_id") device_id = edu_content.pop("device_id") stream_id = str(edu_content.pop("stream_id")) # They may come as ints prev_ids = edu_content.pop("prev_id", []) if not isinstance(prev_ids, list): raise SynapseError( 400, "Device list update had an invalid 'prev_ids' field") prev_ids = [str(p) for p in prev_ids] # They may come as ints if get_domain_from_id(user_id) != origin: # TODO: Raise? logger.warning( "Got device list update edu for %r/%r from %r", user_id, device_id, origin, ) set_tag("error", True) log_kv({ "message": "Got a device list update edu from a user and " "device which does not match the origin of the request.", "user_id": user_id, "device_id": device_id, }) return room_ids = await self.store.get_rooms_for_user(user_id) if not room_ids: # We don't share any rooms with this user. Ignore update, as we # probably won't get any further updates. set_tag("error", True) log_kv({ "message": "Got an update from a user for which " "we don't share any rooms", "other user_id": user_id, }) logger.warning( "Got device list update edu for %r/%r, but don't share a room", user_id, device_id, ) return logger.debug("Received device list update for %r/%r", user_id, device_id) self._pending_updates.setdefault(user_id, []).append( (device_id, stream_id, prev_ids, edu_content)) await self._handle_device_updates(user_id)
def format_event_for_client_v2(d: JsonDict) -> JsonDict: drop_keys = ( "auth_events", "prev_events", "hashes", "signatures", "depth", "origin", "prev_state", ) for key in drop_keys: d.pop(key, None) return d
async def _precache_image_url(self, user: UserID, media_info: MediaInfo, og: JsonDict) -> None: """ Pre-cache the image (if one exists) for posterity Args: user: The user requesting the preview. media_info: The media being previewed. og: The Open Graph dictionary. This is modified with image information. """ # If there's no image or it is blank, there's nothing to do. if "og:image" not in og: return # Remove the raw image URL, this will be replaced with an MXC URL, if successful. image_url = og.pop("og:image") if not image_url: return # The image URL from the HTML might be relative to the previewed page, # convert it to an URL which can be requested directly. url_parts = urlparse(image_url) if url_parts.scheme != "data": image_url = urljoin(media_info.uri, image_url) # FIXME: it might be cleaner to use the same flow as the main /preview_url # request itself and benefit from the same caching etc. But for now we # just rely on the caching on the master request to speed things up. try: image_info = await self._handle_url(image_url, user, allow_data_urls=True) except Exception as e: # Pre-caching the image failed, don't block the entire URL preview. logger.warning( "Pre-caching image failed during URL preview: %s errored with %s", image_url, e, ) return if _is_media(image_info.media_type): # TODO: make sure we don't choke on white-on-transparent images file_id = image_info.filesystem_id dims = await self.media_repo._generate_thumbnails( None, file_id, file_id, image_info.media_type, url_cache=True) if dims: og["og:image:width"] = dims["width"] og["og:image:height"] = dims["height"] else: logger.warning("Couldn't get dims for %s", image_url) og["og:image"] = f"mxc://{self.server_name}/{image_info.filesystem_id}" og["og:image:type"] = image_info.media_type og["matrix:image:size"] = image_info.media_length
def __init__( self, event_dict: JsonDict, room_version: RoomVersion, internal_metadata_dict: Optional[JsonDict] = None, rejected_reason: Optional[str] = None, ): internal_metadata_dict = internal_metadata_dict or {} event_dict = dict(event_dict) # Signatures is a dict of dicts, and this is faster than doing a # copy.deepcopy signatures = { name: {sig_id: sig for sig_id, sig in sigs.items()} for name, sigs in event_dict.pop("signatures", {}).items() } assert "event_id" not in event_dict unsigned = dict(event_dict.pop("unsigned", {})) # We intern these strings because they turn up a lot (especially when # caching). event_dict = intern_dict(event_dict) if USE_FROZEN_DICTS: frozen_dict = freeze(event_dict) else: frozen_dict = event_dict self._event_id = None super().__init__( frozen_dict, room_version=room_version, signatures=signatures, unsigned=unsigned, internal_metadata_dict=internal_metadata_dict, rejected_reason=rejected_reason, )
def format_event_for_client_v2_without_room_id(d: JsonDict) -> JsonDict: d = format_event_for_client_v2(d) d.pop("room_id", None) return d