2014-12-02 08:09:51 -07:00
|
|
|
# -*- coding: utf-8 -*-
|
2016-01-06 21:26:29 -07:00
|
|
|
# Copyright 2014-2016 OpenMarket Ltd
|
2018-01-12 04:15:31 -07:00
|
|
|
# Copyright 2018 New Vector Ltd
|
2014-12-02 08:09:51 -07:00
|
|
|
#
|
|
|
|
# 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.
|
2017-03-14 07:36:06 -06:00
|
|
|
|
2018-07-09 00:09:20 -06:00
|
|
|
import errno
|
|
|
|
import logging
|
|
|
|
import os
|
|
|
|
import shutil
|
2020-07-27 12:40:11 -06:00
|
|
|
from typing import IO, Dict, Optional, Tuple
|
2018-07-09 00:09:20 -06:00
|
|
|
|
2017-03-13 07:50:16 -06:00
|
|
|
import twisted.internet.error
|
2017-03-14 07:36:06 -06:00
|
|
|
import twisted.web.http
|
2020-07-27 12:40:11 -06:00
|
|
|
from twisted.web.http import Request
|
2017-03-14 07:36:06 -06:00
|
|
|
from twisted.web.resource import Resource
|
2014-12-02 08:09:51 -07:00
|
|
|
|
2018-01-22 11:11:18 -07:00
|
|
|
from synapse.api.errors import (
|
2018-07-09 00:09:20 -06:00
|
|
|
FederationDeniedError,
|
|
|
|
HttpResponseException,
|
|
|
|
NotFoundError,
|
2019-01-08 04:04:28 -07:00
|
|
|
RequestSendFailed,
|
2018-07-09 00:09:20 -06:00
|
|
|
SynapseError,
|
2018-01-22 11:11:18 -07:00
|
|
|
)
|
2019-08-13 05:49:28 -06:00
|
|
|
from synapse.config._base import ConfigError
|
2019-07-03 08:07:04 -06:00
|
|
|
from synapse.logging.context import defer_to_thread
|
2018-07-25 02:41:12 -06:00
|
|
|
from synapse.metrics.background_process_metrics import run_as_background_process
|
2018-08-10 07:50:21 -06:00
|
|
|
from synapse.util.async_helpers import Linearizer
|
2017-05-15 08:42:18 -06:00
|
|
|
from synapse.util.retryutils import NotRetryingDestination
|
2018-11-15 14:55:58 -07:00
|
|
|
from synapse.util.stringutils import random_string
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2018-11-15 14:55:58 -07:00
|
|
|
from ._base import (
|
|
|
|
FileInfo,
|
2020-07-27 12:40:11 -06:00
|
|
|
Responder,
|
2018-11-15 14:55:58 -07:00
|
|
|
get_filename_from_headers,
|
|
|
|
respond_404,
|
|
|
|
respond_with_responder,
|
|
|
|
)
|
2018-08-16 07:23:38 -06:00
|
|
|
from .config_resource import MediaConfigResource
|
2018-07-09 00:09:20 -06:00
|
|
|
from .download_resource import DownloadResource
|
|
|
|
from .filepath import MediaFilePaths
|
|
|
|
from .media_storage import MediaStorage
|
|
|
|
from .preview_url_resource import PreviewUrlResource
|
|
|
|
from .storage_provider import StorageProviderWrapper
|
|
|
|
from .thumbnail_resource import ThumbnailResource
|
2020-09-09 10:59:41 -06:00
|
|
|
from .thumbnailer import Thumbnailer, ThumbnailError
|
2018-07-09 00:09:20 -06:00
|
|
|
from .upload_resource import UploadResource
|
2014-12-02 08:09:51 -07:00
|
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
2018-01-12 09:42:43 -07:00
|
|
|
UPDATE_RECENTLY_ACCESSED_TS = 60 * 1000
|
2016-06-29 04:41:20 -06:00
|
|
|
|
|
|
|
|
2020-09-04 04:54:56 -06:00
|
|
|
class MediaRepository:
|
2016-06-29 07:57:59 -06:00
|
|
|
def __init__(self, hs):
|
2018-06-22 02:37:10 -06:00
|
|
|
self.hs = hs
|
2016-04-19 04:31:43 -06:00
|
|
|
self.auth = hs.get_auth()
|
2018-11-15 14:55:58 -07:00
|
|
|
self.client = hs.get_http_client()
|
2016-04-19 04:31:43 -06:00
|
|
|
self.clock = hs.get_clock()
|
|
|
|
self.server_name = hs.hostname
|
|
|
|
self.store = hs.get_datastore()
|
|
|
|
self.max_upload_size = hs.config.max_upload_size
|
|
|
|
self.max_image_pixels = hs.config.max_image_pixels
|
2017-10-12 08:20:59 -06:00
|
|
|
|
2017-10-12 10:31:24 -06:00
|
|
|
self.primary_base_path = hs.config.media_store_path
|
|
|
|
self.filepaths = MediaFilePaths(self.primary_base_path)
|
|
|
|
|
2016-04-19 04:31:43 -06:00
|
|
|
self.dynamic_thumbnails = hs.config.dynamic_thumbnails
|
|
|
|
self.thumbnail_requirements = hs.config.thumbnail_requirements
|
|
|
|
|
2017-01-09 10:17:10 -07:00
|
|
|
self.remote_media_linearizer = Linearizer(name="media_remote")
|
2016-06-29 07:57:59 -06:00
|
|
|
|
2016-06-29 04:41:20 -06:00
|
|
|
self.recently_accessed_remotes = set()
|
2018-01-12 09:42:43 -07:00
|
|
|
self.recently_accessed_locals = set()
|
2016-06-29 04:41:20 -06:00
|
|
|
|
2018-01-22 11:11:18 -07:00
|
|
|
self.federation_domain_whitelist = hs.config.federation_domain_whitelist
|
|
|
|
|
2018-01-12 04:15:31 -07:00
|
|
|
# List of StorageProviders where we should search for media and
|
2018-01-08 10:19:55 -07:00
|
|
|
# potentially upload to.
|
2018-01-12 04:23:54 -07:00
|
|
|
storage_providers = []
|
2018-01-08 10:19:55 -07:00
|
|
|
|
2018-01-16 08:44:08 -07:00
|
|
|
for clz, provider_config, wrapper_config in hs.config.media_storage_providers:
|
|
|
|
backend = clz(hs, provider_config)
|
2018-01-08 10:19:55 -07:00
|
|
|
provider = StorageProviderWrapper(
|
|
|
|
backend,
|
2018-01-16 08:44:08 -07:00
|
|
|
store_local=wrapper_config.store_local,
|
|
|
|
store_remote=wrapper_config.store_remote,
|
|
|
|
store_synchronous=wrapper_config.store_synchronous,
|
2018-01-08 10:19:55 -07:00
|
|
|
)
|
2018-01-12 04:23:54 -07:00
|
|
|
storage_providers.append(provider)
|
2018-01-08 10:19:55 -07:00
|
|
|
|
|
|
|
self.media_storage = MediaStorage(
|
2019-06-20 03:32:02 -06:00
|
|
|
self.hs, self.primary_base_path, self.filepaths, storage_providers
|
2018-01-08 10:19:55 -07:00
|
|
|
)
|
2018-01-08 10:45:11 -07:00
|
|
|
|
2016-06-29 04:41:20 -06:00
|
|
|
self.clock.looping_call(
|
2019-06-20 03:32:02 -06:00
|
|
|
self._start_update_recently_accessed, UPDATE_RECENTLY_ACCESSED_TS
|
2016-06-29 04:41:20 -06:00
|
|
|
)
|
|
|
|
|
2018-07-25 02:41:12 -06:00
|
|
|
def _start_update_recently_accessed(self):
|
2018-07-26 04:44:26 -06:00
|
|
|
return run_as_background_process(
|
2019-06-20 03:32:02 -06:00
|
|
|
"update_recently_accessed_media", self._update_recently_accessed
|
2018-07-25 02:41:12 -06:00
|
|
|
)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
async def _update_recently_accessed(self):
|
2018-01-12 09:42:43 -07:00
|
|
|
remote_media = self.recently_accessed_remotes
|
2016-06-29 04:41:20 -06:00
|
|
|
self.recently_accessed_remotes = set()
|
|
|
|
|
2018-01-12 09:42:43 -07:00
|
|
|
local_media = self.recently_accessed_locals
|
|
|
|
self.recently_accessed_locals = set()
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
await self.store.update_cached_last_access_time(
|
2018-01-12 09:42:43 -07:00
|
|
|
local_media, remote_media, self.clock.time_msec()
|
2016-06-29 04:41:20 -06:00
|
|
|
)
|
|
|
|
|
2018-01-12 09:42:43 -07:00
|
|
|
def mark_recently_accessed(self, server_name, media_id):
|
|
|
|
"""Mark the given media as recently accessed.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
server_name (str|None): Origin server of media, or None if local
|
|
|
|
media_id (str): The media ID of the content
|
|
|
|
"""
|
|
|
|
if server_name:
|
|
|
|
self.recently_accessed_remotes.add((server_name, media_id))
|
|
|
|
else:
|
|
|
|
self.recently_accessed_locals.add(media_id)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
async def create_content(
|
2020-07-27 12:40:11 -06:00
|
|
|
self,
|
|
|
|
media_type: str,
|
|
|
|
upload_name: str,
|
|
|
|
content: IO,
|
|
|
|
content_length: int,
|
|
|
|
auth_user: str,
|
|
|
|
) -> str:
|
2017-10-13 03:39:32 -06:00
|
|
|
"""Store uploaded content for a local user and return the mxc URL
|
|
|
|
|
|
|
|
Args:
|
2020-07-27 12:40:11 -06:00
|
|
|
media_type: The content type of the file
|
|
|
|
upload_name: The name of the file
|
2017-10-13 03:39:32 -06:00
|
|
|
content: A file like object that is the content to store
|
2020-07-27 12:40:11 -06:00
|
|
|
content_length: The length of the content
|
|
|
|
auth_user: The user_id of the uploader
|
2017-10-13 03:39:32 -06:00
|
|
|
|
|
|
|
Returns:
|
2020-07-27 12:40:11 -06:00
|
|
|
The mxc url of the stored content
|
2017-10-13 03:39:32 -06:00
|
|
|
"""
|
2016-04-19 04:31:43 -06:00
|
|
|
media_id = random_string(24)
|
|
|
|
|
2019-06-20 03:32:02 -06:00
|
|
|
file_info = FileInfo(server_name=None, file_id=media_id)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
fname = await self.media_storage.store_file(content, file_info)
|
2018-01-08 10:45:11 -07:00
|
|
|
|
2017-01-10 07:19:50 -07:00
|
|
|
logger.info("Stored local media in file %r", fname)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
await self.store.store_local_media(
|
2016-04-19 04:31:43 -06:00
|
|
|
media_id=media_id,
|
|
|
|
media_type=media_type,
|
|
|
|
time_now_ms=self.clock.time_msec(),
|
|
|
|
upload_name=upload_name,
|
|
|
|
media_length=content_length,
|
|
|
|
user_id=auth_user,
|
|
|
|
)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
await self._generate_thumbnails(None, media_id, media_id, media_type)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2019-07-23 07:00:55 -06:00
|
|
|
return "mxc://%s/%s" % (self.server_name, media_id)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-07-27 12:40:11 -06:00
|
|
|
async def get_local_media(
|
|
|
|
self, request: Request, media_id: str, name: Optional[str]
|
|
|
|
) -> None:
|
2018-01-08 10:45:11 -07:00
|
|
|
"""Responds to reqests for local media, if exists, or returns 404.
|
2018-01-12 04:15:31 -07:00
|
|
|
|
|
|
|
Args:
|
2020-07-27 12:40:11 -06:00
|
|
|
request: The incoming request.
|
|
|
|
media_id: The media ID of the content. (This is the same as
|
2018-01-12 08:02:46 -07:00
|
|
|
the file_id for local content.)
|
2020-07-27 12:40:11 -06:00
|
|
|
name: Optional name that, if specified, will be used as
|
2018-01-12 04:15:31 -07:00
|
|
|
the filename in the Content-Disposition header of the response.
|
|
|
|
|
2018-01-12 08:02:46 -07:00
|
|
|
Returns:
|
2020-07-27 12:40:11 -06:00
|
|
|
Resolves once a response has successfully been written to request
|
2018-01-08 10:45:11 -07:00
|
|
|
"""
|
2020-03-20 05:20:02 -06:00
|
|
|
media_info = await self.store.get_local_media(media_id)
|
2018-01-08 10:45:11 -07:00
|
|
|
if not media_info or media_info["quarantined_by"]:
|
|
|
|
respond_404(request)
|
|
|
|
return
|
|
|
|
|
2018-01-12 09:42:43 -07:00
|
|
|
self.mark_recently_accessed(None, media_id)
|
|
|
|
|
2018-01-08 10:45:11 -07:00
|
|
|
media_type = media_info["media_type"]
|
|
|
|
media_length = media_info["media_length"]
|
|
|
|
upload_name = name if name else media_info["upload_name"]
|
|
|
|
url_cache = media_info["url_cache"]
|
|
|
|
|
2019-06-20 03:32:02 -06:00
|
|
|
file_info = FileInfo(None, media_id, url_cache=url_cache)
|
2018-01-08 10:45:11 -07:00
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
responder = await self.media_storage.fetch_media(file_info)
|
|
|
|
await respond_with_responder(
|
2019-06-20 03:32:02 -06:00
|
|
|
request, responder, media_type, media_length, upload_name
|
2018-01-08 10:45:11 -07:00
|
|
|
)
|
|
|
|
|
2020-07-27 12:40:11 -06:00
|
|
|
async def get_remote_media(
|
|
|
|
self, request: Request, server_name: str, media_id: str, name: Optional[str]
|
|
|
|
) -> None:
|
2018-01-08 10:52:06 -07:00
|
|
|
"""Respond to requests for remote media.
|
2018-01-12 04:15:31 -07:00
|
|
|
|
|
|
|
Args:
|
2020-07-27 12:40:11 -06:00
|
|
|
request: The incoming request.
|
|
|
|
server_name: Remote server_name where the media originated.
|
|
|
|
media_id: The media ID of the content (as defined by the remote server).
|
|
|
|
name: Optional name that, if specified, will be used as
|
2018-01-12 04:15:31 -07:00
|
|
|
the filename in the Content-Disposition header of the response.
|
|
|
|
|
2018-01-12 08:02:46 -07:00
|
|
|
Returns:
|
2020-07-27 12:40:11 -06:00
|
|
|
Resolves once a response has successfully been written to request
|
2018-01-08 10:52:06 -07:00
|
|
|
"""
|
2018-01-22 11:11:18 -07:00
|
|
|
if (
|
2019-06-20 03:32:02 -06:00
|
|
|
self.federation_domain_whitelist is not None
|
|
|
|
and server_name not in self.federation_domain_whitelist
|
2018-01-22 11:11:18 -07:00
|
|
|
):
|
|
|
|
raise FederationDeniedError(server_name)
|
|
|
|
|
2018-01-12 09:42:43 -07:00
|
|
|
self.mark_recently_accessed(server_name, media_id)
|
2018-01-08 10:52:06 -07:00
|
|
|
|
|
|
|
# We linearize here to ensure that we don't try and download remote
|
2018-01-12 04:15:31 -07:00
|
|
|
# media multiple times concurrently
|
2016-04-19 04:31:43 -06:00
|
|
|
key = (server_name, media_id)
|
2020-03-20 05:20:02 -06:00
|
|
|
with (await self.remote_media_linearizer.queue(key)):
|
|
|
|
responder, media_info = await self._get_remote_media_impl(
|
2019-06-20 03:32:02 -06:00
|
|
|
server_name, media_id
|
2018-01-08 10:52:06 -07:00
|
|
|
)
|
|
|
|
|
2018-01-12 04:15:31 -07:00
|
|
|
# We deliberately stream the file outside the lock
|
2018-01-08 10:52:06 -07:00
|
|
|
if responder:
|
|
|
|
media_type = media_info["media_type"]
|
|
|
|
media_length = media_info["media_length"]
|
|
|
|
upload_name = name if name else media_info["upload_name"]
|
2020-03-20 05:20:02 -06:00
|
|
|
await respond_with_responder(
|
2019-06-20 03:32:02 -06:00
|
|
|
request, responder, media_type, media_length, upload_name
|
2018-01-08 10:52:06 -07:00
|
|
|
)
|
|
|
|
else:
|
|
|
|
respond_404(request)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-07-27 12:40:11 -06:00
|
|
|
async def get_remote_media_info(self, server_name: str, media_id: str) -> dict:
|
2018-01-16 04:06:42 -07:00
|
|
|
"""Gets the media info associated with the remote file, downloading
|
|
|
|
if necessary.
|
|
|
|
|
|
|
|
Args:
|
2020-07-27 12:40:11 -06:00
|
|
|
server_name: Remote server_name where the media originated.
|
|
|
|
media_id: The media ID of the content (as defined by the remote server).
|
2018-01-16 04:06:42 -07:00
|
|
|
|
|
|
|
Returns:
|
2020-07-27 12:40:11 -06:00
|
|
|
The media info of the file
|
2018-01-16 04:06:42 -07:00
|
|
|
"""
|
2018-01-22 11:11:18 -07:00
|
|
|
if (
|
2019-06-20 03:32:02 -06:00
|
|
|
self.federation_domain_whitelist is not None
|
|
|
|
and server_name not in self.federation_domain_whitelist
|
2018-01-22 11:11:18 -07:00
|
|
|
):
|
|
|
|
raise FederationDeniedError(server_name)
|
|
|
|
|
2018-01-16 04:06:42 -07:00
|
|
|
# We linearize here to ensure that we don't try and download remote
|
|
|
|
# media multiple times concurrently
|
|
|
|
key = (server_name, media_id)
|
2020-03-20 05:20:02 -06:00
|
|
|
with (await self.remote_media_linearizer.queue(key)):
|
|
|
|
responder, media_info = await self._get_remote_media_impl(
|
2019-06-20 03:32:02 -06:00
|
|
|
server_name, media_id
|
2018-01-16 04:06:42 -07:00
|
|
|
)
|
|
|
|
|
|
|
|
# Ensure we actually use the responder so that it releases resources
|
|
|
|
if responder:
|
|
|
|
with responder:
|
|
|
|
pass
|
|
|
|
|
2019-07-23 07:00:55 -06:00
|
|
|
return media_info
|
2018-01-16 04:06:42 -07:00
|
|
|
|
2020-07-27 12:40:11 -06:00
|
|
|
async def _get_remote_media_impl(
|
|
|
|
self, server_name: str, media_id: str
|
|
|
|
) -> Tuple[Optional[Responder], dict]:
|
2018-01-08 10:52:06 -07:00
|
|
|
"""Looks for media in local cache, if not there then attempt to
|
|
|
|
download from remote server.
|
|
|
|
|
2018-01-12 08:02:46 -07:00
|
|
|
Args:
|
|
|
|
server_name (str): Remote server_name where the media originated.
|
|
|
|
media_id (str): The media ID of the content (as defined by the
|
|
|
|
remote server).
|
|
|
|
|
2018-01-08 10:52:06 -07:00
|
|
|
Returns:
|
2020-07-27 12:40:11 -06:00
|
|
|
A tuple of responder and the media info of the file.
|
2018-01-08 10:52:06 -07:00
|
|
|
"""
|
2020-03-20 05:20:02 -06:00
|
|
|
media_info = await self.store.get_cached_remote_media(server_name, media_id)
|
2018-01-08 10:52:06 -07:00
|
|
|
|
|
|
|
# file_id is the ID we use to track the file locally. If we've already
|
|
|
|
# seen the file then reuse the existing ID, otherwise genereate a new
|
|
|
|
# one.
|
|
|
|
if media_info:
|
|
|
|
file_id = media_info["filesystem_id"]
|
2016-06-29 04:41:20 -06:00
|
|
|
else:
|
2018-01-08 10:52:06 -07:00
|
|
|
file_id = random_string(24)
|
|
|
|
|
|
|
|
file_info = FileInfo(server_name, file_id)
|
|
|
|
|
|
|
|
# If we have an entry in the DB, try and look for it
|
|
|
|
if media_info:
|
|
|
|
if media_info["quarantined_by"]:
|
2018-01-16 06:53:43 -07:00
|
|
|
logger.info("Media is quarantined")
|
2018-01-08 10:52:06 -07:00
|
|
|
raise NotFoundError()
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
responder = await self.media_storage.fetch_media(file_info)
|
2018-01-08 10:52:06 -07:00
|
|
|
if responder:
|
2019-08-30 09:28:26 -06:00
|
|
|
return responder, media_info
|
2018-01-08 10:52:06 -07:00
|
|
|
|
|
|
|
# Failed to find the file anywhere, lets download it.
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
media_info = await self._download_remote_file(server_name, media_id, file_id)
|
2018-01-08 10:52:06 -07:00
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
responder = await self.media_storage.fetch_media(file_info)
|
2019-08-30 09:28:26 -06:00
|
|
|
return responder, media_info
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-07-27 12:40:11 -06:00
|
|
|
async def _download_remote_file(
|
|
|
|
self, server_name: str, media_id: str, file_id: str
|
|
|
|
) -> dict:
|
2018-01-08 10:52:06 -07:00
|
|
|
"""Attempt to download the remote file from the given server name,
|
|
|
|
using the given file_id as the local id.
|
2018-01-12 04:15:31 -07:00
|
|
|
|
|
|
|
Args:
|
2020-07-27 12:40:11 -06:00
|
|
|
server_name: Originating server
|
|
|
|
media_id: The media ID of the content (as defined by the
|
2018-01-12 08:02:46 -07:00
|
|
|
remote server). This is different than the file_id, which is
|
|
|
|
locally generated.
|
2020-07-27 12:40:11 -06:00
|
|
|
file_id: Local file ID
|
2018-01-12 04:15:31 -07:00
|
|
|
|
|
|
|
Returns:
|
2020-07-27 12:40:11 -06:00
|
|
|
The media info of the file.
|
2018-01-08 10:52:06 -07:00
|
|
|
"""
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2019-06-20 03:32:02 -06:00
|
|
|
file_info = FileInfo(server_name=server_name, file_id=file_id)
|
2018-01-08 10:52:06 -07:00
|
|
|
|
|
|
|
with self.media_storage.store_into_file(file_info) as (f, fname, finish):
|
2019-06-20 03:32:02 -06:00
|
|
|
request_path = "/".join(
|
2020-06-17 06:36:46 -06:00
|
|
|
("/_matrix/media/r0/download", server_name, media_id)
|
2019-06-20 03:32:02 -06:00
|
|
|
)
|
2018-01-08 10:52:06 -07:00
|
|
|
try:
|
2020-03-20 05:20:02 -06:00
|
|
|
length, headers = await self.client.get_file(
|
2019-06-20 03:32:02 -06:00
|
|
|
server_name,
|
|
|
|
request_path,
|
|
|
|
output_stream=f,
|
|
|
|
max_size=self.max_upload_size,
|
|
|
|
args={
|
2018-01-08 10:52:06 -07:00
|
|
|
# tell the remote server to 404 if it doesn't
|
|
|
|
# recognise the server_name, to make sure we don't
|
|
|
|
# end up with a routing loop.
|
2019-06-20 03:32:02 -06:00
|
|
|
"allow_remote": "false"
|
|
|
|
},
|
2018-01-08 10:52:06 -07:00
|
|
|
)
|
2019-01-08 04:04:28 -07:00
|
|
|
except RequestSendFailed as e:
|
2019-10-31 04:23:24 -06:00
|
|
|
logger.warning(
|
2019-06-20 03:32:02 -06:00
|
|
|
"Request failed fetching remote media %s/%s: %r",
|
|
|
|
server_name,
|
|
|
|
media_id,
|
|
|
|
e,
|
|
|
|
)
|
2019-01-08 04:04:28 -07:00
|
|
|
raise SynapseError(502, "Failed to fetch remote media")
|
2018-01-08 10:52:06 -07:00
|
|
|
|
|
|
|
except HttpResponseException as e:
|
2019-10-31 04:23:24 -06:00
|
|
|
logger.warning(
|
2019-06-20 03:32:02 -06:00
|
|
|
"HTTP error fetching remote media %s/%s: %s",
|
|
|
|
server_name,
|
|
|
|
media_id,
|
|
|
|
e.response,
|
|
|
|
)
|
2018-01-08 10:52:06 -07:00
|
|
|
if e.code == twisted.web.http.NOT_FOUND:
|
2018-08-01 07:58:16 -06:00
|
|
|
raise e.to_synapse_error()
|
2018-01-08 10:52:06 -07:00
|
|
|
raise SynapseError(502, "Failed to fetch remote media")
|
|
|
|
|
|
|
|
except SynapseError:
|
2019-10-31 04:23:24 -06:00
|
|
|
logger.warning(
|
|
|
|
"Failed to fetch remote media %s/%s", server_name, media_id
|
|
|
|
)
|
2018-01-08 10:52:06 -07:00
|
|
|
raise
|
|
|
|
except NotRetryingDestination:
|
2019-10-31 04:23:24 -06:00
|
|
|
logger.warning("Not retrying destination %r", server_name)
|
2018-01-08 10:52:06 -07:00
|
|
|
raise SynapseError(502, "Failed to fetch remote media")
|
|
|
|
except Exception:
|
2019-06-20 03:32:02 -06:00
|
|
|
logger.exception(
|
|
|
|
"Failed to fetch remote media %s/%s", server_name, media_id
|
|
|
|
)
|
2018-01-08 10:52:06 -07:00
|
|
|
raise SynapseError(502, "Failed to fetch remote media")
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
await finish()
|
2018-01-08 10:52:06 -07:00
|
|
|
|
2019-06-20 03:32:02 -06:00
|
|
|
media_type = headers[b"Content-Type"][0].decode("ascii")
|
2018-11-15 14:55:58 -07:00
|
|
|
upload_name = get_filename_from_headers(headers)
|
2018-01-08 10:52:06 -07:00
|
|
|
time_now_ms = self.clock.time_msec()
|
|
|
|
|
|
|
|
logger.info("Stored remote media in file %r", fname)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
await self.store.store_cached_remote_media(
|
2018-01-08 10:52:06 -07:00
|
|
|
origin=server_name,
|
|
|
|
media_id=media_id,
|
|
|
|
media_type=media_type,
|
|
|
|
time_now_ms=self.clock.time_msec(),
|
|
|
|
upload_name=upload_name,
|
|
|
|
media_length=length,
|
|
|
|
filesystem_id=file_id,
|
|
|
|
)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
|
|
|
media_info = {
|
|
|
|
"media_type": media_type,
|
|
|
|
"media_length": length,
|
|
|
|
"upload_name": upload_name,
|
|
|
|
"created_ts": time_now_ms,
|
|
|
|
"filesystem_id": file_id,
|
|
|
|
}
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
await self._generate_thumbnails(server_name, media_id, file_id, media_type)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2019-07-23 07:00:55 -06:00
|
|
|
return media_info
|
2016-04-19 04:31:43 -06:00
|
|
|
|
|
|
|
def _get_thumbnail_requirements(self, media_type):
|
|
|
|
return self.thumbnail_requirements.get(media_type, ())
|
|
|
|
|
2019-06-20 03:32:02 -06:00
|
|
|
def _generate_thumbnail(self, thumbnailer, t_width, t_height, t_method, t_type):
|
2016-04-19 04:31:43 -06:00
|
|
|
m_width = thumbnailer.width
|
|
|
|
m_height = thumbnailer.height
|
|
|
|
|
|
|
|
if m_width * m_height >= self.max_image_pixels:
|
|
|
|
logger.info(
|
|
|
|
"Image too large to thumbnail %r x %r > %r",
|
2019-06-20 03:32:02 -06:00
|
|
|
m_width,
|
|
|
|
m_height,
|
|
|
|
self.max_image_pixels,
|
2016-04-19 04:31:43 -06:00
|
|
|
)
|
|
|
|
return
|
|
|
|
|
2019-05-16 12:04:26 -06:00
|
|
|
if thumbnailer.transpose_method is not None:
|
|
|
|
m_width, m_height = thumbnailer.transpose()
|
|
|
|
|
2016-04-19 04:31:43 -06:00
|
|
|
if t_method == "crop":
|
2017-10-12 08:20:59 -06:00
|
|
|
t_byte_source = thumbnailer.crop(t_width, t_height, t_type)
|
2016-04-19 04:31:43 -06:00
|
|
|
elif t_method == "scale":
|
2017-02-24 14:42:38 -07:00
|
|
|
t_width, t_height = thumbnailer.aspect(t_width, t_height)
|
|
|
|
t_width = min(m_width, t_width)
|
|
|
|
t_height = min(m_height, t_height)
|
2017-10-12 08:20:59 -06:00
|
|
|
t_byte_source = thumbnailer.scale(t_width, t_height, t_type)
|
2016-04-19 04:31:43 -06:00
|
|
|
else:
|
2017-10-12 08:20:59 -06:00
|
|
|
t_byte_source = None
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2017-10-12 08:20:59 -06:00
|
|
|
return t_byte_source
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
async def generate_local_exact_thumbnail(
|
2020-09-09 10:59:41 -06:00
|
|
|
self,
|
|
|
|
media_id: str,
|
|
|
|
t_width: int,
|
|
|
|
t_height: int,
|
|
|
|
t_method: str,
|
|
|
|
t_type: str,
|
|
|
|
url_cache: str,
|
|
|
|
) -> Optional[str]:
|
2020-03-20 05:20:02 -06:00
|
|
|
input_path = await self.media_storage.ensure_media_is_in_local_cache(
|
2019-06-20 03:32:02 -06:00
|
|
|
FileInfo(None, media_id, url_cache=url_cache)
|
|
|
|
)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-09-09 10:59:41 -06:00
|
|
|
try:
|
|
|
|
thumbnailer = Thumbnailer(input_path)
|
|
|
|
except ThumbnailError as e:
|
|
|
|
logger.warning(
|
|
|
|
"Unable to generate a thumbnail for local media %s using a method of %s and type of %s: %s",
|
|
|
|
media_id,
|
|
|
|
t_method,
|
|
|
|
t_type,
|
|
|
|
e,
|
|
|
|
)
|
|
|
|
return None
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
t_byte_source = await defer_to_thread(
|
2018-10-23 06:12:32 -06:00
|
|
|
self.hs.get_reactor(),
|
2016-04-19 04:31:43 -06:00
|
|
|
self._generate_thumbnail,
|
2019-06-20 03:32:02 -06:00
|
|
|
thumbnailer,
|
|
|
|
t_width,
|
|
|
|
t_height,
|
|
|
|
t_method,
|
|
|
|
t_type,
|
2018-10-23 06:12:32 -06:00
|
|
|
)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2017-10-12 08:20:59 -06:00
|
|
|
if t_byte_source:
|
2017-10-13 08:34:08 -06:00
|
|
|
try:
|
2018-01-08 10:45:11 -07:00
|
|
|
file_info = FileInfo(
|
|
|
|
server_name=None,
|
|
|
|
file_id=media_id,
|
2018-01-16 03:52:32 -07:00
|
|
|
url_cache=url_cache,
|
2018-01-08 10:45:11 -07:00
|
|
|
thumbnail=True,
|
|
|
|
thumbnail_width=t_width,
|
|
|
|
thumbnail_height=t_height,
|
|
|
|
thumbnail_method=t_method,
|
|
|
|
thumbnail_type=t_type,
|
|
|
|
)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
output_path = await self.media_storage.store_file(
|
2019-06-20 03:32:02 -06:00
|
|
|
t_byte_source, file_info
|
2017-10-12 08:20:59 -06:00
|
|
|
)
|
2017-10-13 08:34:08 -06:00
|
|
|
finally:
|
|
|
|
t_byte_source.close()
|
|
|
|
|
2017-10-12 08:20:59 -06:00
|
|
|
logger.info("Stored thumbnail in file %r", output_path)
|
|
|
|
|
2017-10-12 10:52:30 -06:00
|
|
|
t_len = os.path.getsize(output_path)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
await self.store.store_local_thumbnail(
|
2017-10-12 10:39:23 -06:00
|
|
|
media_id, t_width, t_height, t_type, t_method, t_len
|
2016-04-19 04:31:43 -06:00
|
|
|
)
|
|
|
|
|
2019-07-23 07:00:55 -06:00
|
|
|
return output_path
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-09-09 10:59:41 -06:00
|
|
|
# Could not generate thumbnail.
|
|
|
|
return None
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
async def generate_remote_exact_thumbnail(
|
2020-09-09 10:59:41 -06:00
|
|
|
self,
|
|
|
|
server_name: str,
|
|
|
|
file_id: str,
|
|
|
|
media_id: str,
|
|
|
|
t_width: int,
|
|
|
|
t_height: int,
|
|
|
|
t_method: str,
|
|
|
|
t_type: str,
|
|
|
|
) -> Optional[str]:
|
2020-03-20 05:20:02 -06:00
|
|
|
input_path = await self.media_storage.ensure_media_is_in_local_cache(
|
2019-06-20 03:32:02 -06:00
|
|
|
FileInfo(server_name, file_id, url_cache=False)
|
|
|
|
)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-09-09 10:59:41 -06:00
|
|
|
try:
|
|
|
|
thumbnailer = Thumbnailer(input_path)
|
|
|
|
except ThumbnailError as e:
|
|
|
|
logger.warning(
|
|
|
|
"Unable to generate a thumbnail for remote media %s from %s using a method of %s and type of %s: %s",
|
|
|
|
media_id,
|
|
|
|
server_name,
|
|
|
|
t_method,
|
|
|
|
t_type,
|
|
|
|
e,
|
|
|
|
)
|
|
|
|
return None
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
t_byte_source = await defer_to_thread(
|
2018-10-23 06:12:32 -06:00
|
|
|
self.hs.get_reactor(),
|
2016-04-19 04:31:43 -06:00
|
|
|
self._generate_thumbnail,
|
2019-06-20 03:32:02 -06:00
|
|
|
thumbnailer,
|
|
|
|
t_width,
|
|
|
|
t_height,
|
|
|
|
t_method,
|
|
|
|
t_type,
|
2018-10-23 06:12:32 -06:00
|
|
|
)
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2017-10-12 08:20:59 -06:00
|
|
|
if t_byte_source:
|
2017-10-13 08:34:08 -06:00
|
|
|
try:
|
2018-01-08 10:45:11 -07:00
|
|
|
file_info = FileInfo(
|
|
|
|
server_name=server_name,
|
2019-09-02 05:18:41 -06:00
|
|
|
file_id=file_id,
|
2018-01-08 10:45:11 -07:00
|
|
|
thumbnail=True,
|
|
|
|
thumbnail_width=t_width,
|
|
|
|
thumbnail_height=t_height,
|
|
|
|
thumbnail_method=t_method,
|
|
|
|
thumbnail_type=t_type,
|
|
|
|
)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
output_path = await self.media_storage.store_file(
|
2019-06-20 03:32:02 -06:00
|
|
|
t_byte_source, file_info
|
2017-10-12 08:20:59 -06:00
|
|
|
)
|
2017-10-13 08:34:08 -06:00
|
|
|
finally:
|
|
|
|
t_byte_source.close()
|
|
|
|
|
2017-10-12 08:20:59 -06:00
|
|
|
logger.info("Stored thumbnail in file %r", output_path)
|
|
|
|
|
2017-10-12 10:52:30 -06:00
|
|
|
t_len = os.path.getsize(output_path)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
await self.store.store_remote_media_thumbnail(
|
2019-06-20 03:32:02 -06:00
|
|
|
server_name,
|
|
|
|
media_id,
|
|
|
|
file_id,
|
|
|
|
t_width,
|
|
|
|
t_height,
|
|
|
|
t_type,
|
|
|
|
t_method,
|
|
|
|
t_len,
|
2016-04-19 04:31:43 -06:00
|
|
|
)
|
|
|
|
|
2019-07-23 07:00:55 -06:00
|
|
|
return output_path
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-09-09 10:59:41 -06:00
|
|
|
# Could not generate thumbnail.
|
|
|
|
return None
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
async def _generate_thumbnails(
|
2020-07-27 12:40:11 -06:00
|
|
|
self,
|
|
|
|
server_name: Optional[str],
|
|
|
|
media_id: str,
|
|
|
|
file_id: str,
|
|
|
|
media_type: str,
|
|
|
|
url_cache: bool = False,
|
|
|
|
) -> Optional[dict]:
|
2017-10-13 04:23:53 -06:00
|
|
|
"""Generate and store thumbnails for an image.
|
|
|
|
|
|
|
|
Args:
|
2020-07-27 12:40:11 -06:00
|
|
|
server_name: The server name if remote media, else None if local
|
|
|
|
media_id: The media ID of the content. (This is the same as
|
2018-01-16 09:03:05 -07:00
|
|
|
the file_id for local content)
|
2020-07-27 12:40:11 -06:00
|
|
|
file_id: Local file ID
|
|
|
|
media_type: The content type of the file
|
|
|
|
url_cache: If we are thumbnailing images downloaded for the URL cache,
|
2017-10-13 04:23:53 -06:00
|
|
|
used exclusively by the url previewer
|
|
|
|
|
|
|
|
Returns:
|
2020-07-27 12:40:11 -06:00
|
|
|
Dict with "width" and "height" keys of original image or None if the
|
|
|
|
media cannot be thumbnailed.
|
2017-10-13 04:23:53 -06:00
|
|
|
"""
|
2016-04-19 04:31:43 -06:00
|
|
|
requirements = self._get_thumbnail_requirements(media_type)
|
|
|
|
if not requirements:
|
2020-07-27 12:40:11 -06:00
|
|
|
return None
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
input_path = await self.media_storage.ensure_media_is_in_local_cache(
|
2019-06-20 03:32:02 -06:00
|
|
|
FileInfo(server_name, file_id, url_cache=url_cache)
|
|
|
|
)
|
2017-06-23 04:14:11 -06:00
|
|
|
|
2020-09-09 10:59:41 -06:00
|
|
|
try:
|
|
|
|
thumbnailer = Thumbnailer(input_path)
|
|
|
|
except ThumbnailError as e:
|
|
|
|
logger.warning(
|
|
|
|
"Unable to generate thumbnails for remote media %s from %s using a method of %s and type of %s: %s",
|
|
|
|
media_id,
|
|
|
|
server_name,
|
|
|
|
media_type,
|
|
|
|
e,
|
|
|
|
)
|
|
|
|
return None
|
|
|
|
|
2016-04-19 04:31:43 -06:00
|
|
|
m_width = thumbnailer.width
|
|
|
|
m_height = thumbnailer.height
|
|
|
|
|
|
|
|
if m_width * m_height >= self.max_image_pixels:
|
|
|
|
logger.info(
|
|
|
|
"Image too large to thumbnail %r x %r > %r",
|
2019-06-20 03:32:02 -06:00
|
|
|
m_width,
|
|
|
|
m_height,
|
|
|
|
self.max_image_pixels,
|
2016-04-19 04:31:43 -06:00
|
|
|
)
|
2020-07-27 12:40:11 -06:00
|
|
|
return None
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2019-05-16 12:04:26 -06:00
|
|
|
if thumbnailer.transpose_method is not None:
|
2020-03-20 05:20:02 -06:00
|
|
|
m_width, m_height = await defer_to_thread(
|
2019-06-20 03:32:02 -06:00
|
|
|
self.hs.get_reactor(), thumbnailer.transpose
|
2019-05-16 12:04:26 -06:00
|
|
|
)
|
|
|
|
|
2017-10-13 04:23:53 -06:00
|
|
|
# We deduplicate the thumbnail sizes by ignoring the cropped versions if
|
|
|
|
# they have the same dimensions of a scaled one.
|
2020-01-20 10:38:21 -07:00
|
|
|
thumbnails = {} # type: Dict[Tuple[int, int, str], str]
|
2017-10-13 04:23:53 -06:00
|
|
|
for r_width, r_height, r_method, r_type in requirements:
|
|
|
|
if r_method == "crop":
|
2017-10-13 06:58:57 -06:00
|
|
|
thumbnails.setdefault((r_width, r_height, r_type), r_method)
|
2017-10-13 04:23:53 -06:00
|
|
|
elif r_method == "scale":
|
2017-10-13 04:33:49 -06:00
|
|
|
t_width, t_height = thumbnailer.aspect(r_width, r_height)
|
2017-10-13 04:23:53 -06:00
|
|
|
t_width = min(m_width, t_width)
|
|
|
|
t_height = min(m_height, t_height)
|
2017-10-13 06:47:38 -06:00
|
|
|
thumbnails[(t_width, t_height, r_type)] = r_method
|
2017-10-13 04:23:53 -06:00
|
|
|
|
|
|
|
# Now we generate the thumbnails for each dimension, store it
|
2020-06-15 05:03:36 -06:00
|
|
|
for (t_width, t_height, t_type), t_method in thumbnails.items():
|
2017-10-13 08:34:08 -06:00
|
|
|
# Generate the thumbnail
|
2017-10-19 03:27:18 -06:00
|
|
|
if t_method == "crop":
|
2020-03-20 05:20:02 -06:00
|
|
|
t_byte_source = await defer_to_thread(
|
2019-06-20 03:32:02 -06:00
|
|
|
self.hs.get_reactor(), thumbnailer.crop, t_width, t_height, t_type
|
2018-10-23 06:12:32 -06:00
|
|
|
)
|
2017-10-19 03:27:18 -06:00
|
|
|
elif t_method == "scale":
|
2020-03-20 05:20:02 -06:00
|
|
|
t_byte_source = await defer_to_thread(
|
2019-06-20 03:32:02 -06:00
|
|
|
self.hs.get_reactor(), thumbnailer.scale, t_width, t_height, t_type
|
2018-10-23 06:12:32 -06:00
|
|
|
)
|
2017-10-19 03:27:18 -06:00
|
|
|
else:
|
|
|
|
logger.error("Unrecognized method: %r", t_method)
|
|
|
|
continue
|
2017-10-13 08:34:08 -06:00
|
|
|
|
|
|
|
if not t_byte_source:
|
|
|
|
continue
|
|
|
|
|
|
|
|
try:
|
2018-01-08 10:45:11 -07:00
|
|
|
file_info = FileInfo(
|
|
|
|
server_name=server_name,
|
2018-01-16 05:02:06 -07:00
|
|
|
file_id=file_id,
|
2018-01-08 10:45:11 -07:00
|
|
|
thumbnail=True,
|
|
|
|
thumbnail_width=t_width,
|
|
|
|
thumbnail_height=t_height,
|
|
|
|
thumbnail_method=t_method,
|
|
|
|
thumbnail_type=t_type,
|
|
|
|
url_cache=url_cache,
|
|
|
|
)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
output_path = await self.media_storage.store_file(
|
2019-06-20 03:32:02 -06:00
|
|
|
t_byte_source, file_info
|
2017-10-13 08:34:08 -06:00
|
|
|
)
|
|
|
|
finally:
|
|
|
|
t_byte_source.close()
|
|
|
|
|
2017-10-12 10:52:30 -06:00
|
|
|
t_len = os.path.getsize(output_path)
|
2017-10-12 08:20:59 -06:00
|
|
|
|
2017-10-13 04:33:49 -06:00
|
|
|
# Write to database
|
2017-10-13 04:23:53 -06:00
|
|
|
if server_name:
|
2020-03-20 05:20:02 -06:00
|
|
|
await self.store.store_remote_media_thumbnail(
|
2019-06-20 03:32:02 -06:00
|
|
|
server_name,
|
|
|
|
media_id,
|
|
|
|
file_id,
|
|
|
|
t_width,
|
|
|
|
t_height,
|
|
|
|
t_type,
|
|
|
|
t_method,
|
|
|
|
t_len,
|
2017-10-13 04:33:49 -06:00
|
|
|
)
|
2017-10-13 04:23:53 -06:00
|
|
|
else:
|
2020-03-20 05:20:02 -06:00
|
|
|
await self.store.store_local_thumbnail(
|
2017-10-13 04:23:53 -06:00
|
|
|
media_id, t_width, t_height, t_type, t_method, t_len
|
|
|
|
)
|
2017-10-12 08:20:59 -06:00
|
|
|
|
2019-07-23 07:00:55 -06:00
|
|
|
return {"width": m_width, "height": m_height}
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
async def delete_old_remote_media(self, before_ts):
|
|
|
|
old_media = await self.store.get_remote_media_before(before_ts)
|
2016-06-29 07:57:59 -06:00
|
|
|
|
|
|
|
deleted = 0
|
|
|
|
|
|
|
|
for media in old_media:
|
|
|
|
origin = media["media_origin"]
|
|
|
|
media_id = media["media_id"]
|
|
|
|
file_id = media["filesystem_id"]
|
|
|
|
key = (origin, media_id)
|
|
|
|
|
|
|
|
logger.info("Deleting: %r", key)
|
|
|
|
|
2017-10-12 10:31:24 -06:00
|
|
|
# TODO: Should we delete from the backup store
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
with (await self.remote_media_linearizer.queue(key)):
|
2016-06-29 07:57:59 -06:00
|
|
|
full_path = self.filepaths.remote_media_filepath(origin, file_id)
|
|
|
|
try:
|
|
|
|
os.remove(full_path)
|
|
|
|
except OSError as e:
|
2019-10-31 04:23:24 -06:00
|
|
|
logger.warning("Failed to remove file: %r", full_path)
|
2016-06-29 07:57:59 -06:00
|
|
|
if e.errno == errno.ENOENT:
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
continue
|
|
|
|
|
|
|
|
thumbnail_dir = self.filepaths.remote_media_thumbnail_dir(
|
|
|
|
origin, file_id
|
|
|
|
)
|
|
|
|
shutil.rmtree(thumbnail_dir, ignore_errors=True)
|
|
|
|
|
2020-03-20 05:20:02 -06:00
|
|
|
await self.store.delete_remote_media(origin, media_id)
|
2016-06-29 07:57:59 -06:00
|
|
|
deleted += 1
|
|
|
|
|
2019-07-23 07:00:55 -06:00
|
|
|
return {"deleted": deleted}
|
2016-06-29 07:57:59 -06:00
|
|
|
|
2016-04-19 04:31:43 -06:00
|
|
|
|
2014-12-02 12:51:47 -07:00
|
|
|
class MediaRepositoryResource(Resource):
|
2014-12-11 11:21:08 -07:00
|
|
|
"""File uploading and downloading.
|
2014-12-02 08:09:51 -07:00
|
|
|
|
|
|
|
Uploads are POSTed to a resource which returns a token which is used to GET
|
|
|
|
the download::
|
|
|
|
|
2020-06-17 06:36:46 -06:00
|
|
|
=> POST /_matrix/media/r0/upload HTTP/1.1
|
2014-12-02 08:09:51 -07:00
|
|
|
Content-Type: <media-type>
|
2015-02-07 05:56:21 -07:00
|
|
|
Content-Length: <content-length>
|
2014-12-02 08:09:51 -07:00
|
|
|
|
|
|
|
<media>
|
|
|
|
|
|
|
|
<= HTTP/1.1 200 OK
|
|
|
|
Content-Type: application/json
|
|
|
|
|
2014-12-15 09:57:53 -07:00
|
|
|
{ "content_uri": "mxc://<server-name>/<media-id>" }
|
2014-12-02 08:09:51 -07:00
|
|
|
|
2020-06-17 06:36:46 -06:00
|
|
|
=> GET /_matrix/media/r0/download/<server-name>/<media-id> HTTP/1.1
|
2014-12-02 08:09:51 -07:00
|
|
|
|
|
|
|
<= HTTP/1.1 200 OK
|
|
|
|
Content-Type: <media-type>
|
|
|
|
Content-Disposition: attachment;filename=<upload-filename>
|
|
|
|
|
|
|
|
<media>
|
|
|
|
|
2014-12-11 03:41:43 -07:00
|
|
|
Clients can get thumbnails by supplying a desired width and height and
|
|
|
|
thumbnailing method::
|
2014-12-02 08:09:51 -07:00
|
|
|
|
2020-06-17 06:36:46 -06:00
|
|
|
=> GET /_matrix/media/r0/thumbnail/<server_name>
|
2014-12-11 11:18:58 -07:00
|
|
|
/<media-id>?width=<w>&height=<h>&method=<m> HTTP/1.1
|
2014-12-02 08:09:51 -07:00
|
|
|
|
|
|
|
<= HTTP/1.1 200 OK
|
|
|
|
Content-Type: image/jpeg or image/png
|
|
|
|
|
|
|
|
<thumbnail>
|
2014-12-11 03:41:43 -07:00
|
|
|
|
|
|
|
The thumbnail methods are "crop" and "scale". "scale" trys to return an
|
|
|
|
image where either the width or the height is smaller than the requested
|
|
|
|
size. The client should then scale and letterbox the image if it needs to
|
|
|
|
fit within a given rectangle. "crop" trys to return an image where the
|
|
|
|
width and height are close to the requested size and the aspect matches
|
|
|
|
the requested size. The client should scale the image if it needs to fit
|
|
|
|
within a given rectangle.
|
2014-12-02 08:09:51 -07:00
|
|
|
"""
|
|
|
|
|
|
|
|
def __init__(self, hs):
|
2019-08-13 05:49:28 -06:00
|
|
|
# If we're not configured to use it, raise if we somehow got here.
|
|
|
|
if not hs.config.can_load_media_repo:
|
|
|
|
raise ConfigError("Synapse is not configured to use a media repo.")
|
2016-04-19 04:24:59 -06:00
|
|
|
|
2019-08-13 05:49:28 -06:00
|
|
|
super().__init__()
|
2016-06-29 07:57:59 -06:00
|
|
|
media_repo = hs.get_media_repository()
|
2018-09-12 04:41:31 -06:00
|
|
|
|
|
|
|
self.putChild(b"upload", UploadResource(hs, media_repo))
|
|
|
|
self.putChild(b"download", DownloadResource(hs, media_repo))
|
2019-06-20 03:32:02 -06:00
|
|
|
self.putChild(
|
|
|
|
b"thumbnail", ThumbnailResource(hs, media_repo, media_repo.media_storage)
|
|
|
|
)
|
2016-04-08 11:37:15 -06:00
|
|
|
if hs.config.url_preview_enabled:
|
2019-06-20 03:32:02 -06:00
|
|
|
self.putChild(
|
|
|
|
b"preview_url",
|
|
|
|
PreviewUrlResource(hs, media_repo, media_repo.media_storage),
|
|
|
|
)
|
2018-09-12 04:41:31 -06:00
|
|
|
self.putChild(b"config", MediaConfigResource(hs))
|