Add changelog

.circleci/config.yml

@@ -8,13 +8,6 @@ jobs:
       - run: docker login --username $DOCKER_HUB_USERNAME --password $DOCKER_HUB_PASSWORD
       - run: docker push matrixdotorg/synapse:${CIRCLE_TAG}
       - run: docker push matrixdotorg/synapse:${CIRCLE_TAG}-py3
-  dockerhubuploadreleaseshhs:
-    machine: true
-    steps:
-      - checkout
-      - run: docker build -f docker/Dockerfile --label gitsha1=${CIRCLE_SHA1} -t matrixdotorg/synapse:${CIRCLE_TAG} --build-arg PYTHON_VERSION=3.7 .
-      - run: docker login --username $DOCKER_HUB_USERNAME --password $DOCKER_HUB_PASSWORD
-      - run: docker push matrixdotorg/synapse:${CIRCLE_TAG}
   dockerhubuploadlatest:
     machine: true
     steps:
@@ -34,12 +27,6 @@ workflows:
               only: /v[0-9].[0-9]+.[0-9]+.*/
             branches:
               ignore: /.*/
-      - dockerhubuploadreleaseshhs:
-          filters:
-            tags:
-              only: /shhs-v[0-9]+.[0-9]+.*/
-            branches:
-              ignore: /.*/
       - dockerhubuploadlatest:
           filters:
             branches:

.gitignore

@@ -19,7 +19,6 @@ _trial_temp*/
 /*.signing.key
 /env/
 /homeserver*.yaml
-/logs
 /media_store/
 /uploads
 
@@ -38,3 +37,4 @@ _trial_temp*/
 /docs/build/
 /htmlcov
 /pip-wheel-metadata/
+

CHANGES.md

@@ -1,33 +1,3 @@
-Synapse 1.1.0 (2019-07-04)
-==========================
-
-As of v1.1.0, Synapse no longer supports Python 2, nor Postgres version 9.4.
-See the [upgrade notes](UPGRADE.rst#upgrading-to-v110) for more details.
-
-This release also deprecates the use of environment variables to configure the
-docker image. See the [docker README](https://github.com/matrix-org/synapse/blob/release-v1.1.0/docker/README.md#legacy-dynamic-configuration-file-support)
-for more details.
-
-No changes since 1.1.0rc2.
-
-
-Synapse 1.1.0rc2 (2019-07-03)
-=============================
-
-Bugfixes
---------
-
-- Fix regression in 1.1rc1 where OPTIONS requests to the media repo would fail. ([\#5593](https://github.com/matrix-org/synapse/issues/5593))
-- Removed the `SYNAPSE_SMTP_*` docker container environment variables. Using these environment variables prevented the docker container from starting in Synapse v1.0, even though they didn't actually allow any functionality anyway. ([\#5596](https://github.com/matrix-org/synapse/issues/5596))
-- Fix a number of "Starting txn from sentinel context" warnings. ([\#5605](https://github.com/matrix-org/synapse/issues/5605))
-
-
-Internal Changes
-----------------
-
-- Update github templates. ([\#5552](https://github.com/matrix-org/synapse/issues/5552))
-
-
 Synapse 1.1.0rc1 (2019-07-02)
 =============================
 

changelog.d/5072.feature

@@ -1 +0,0 @@
-Synapse can now be configured to not join remote rooms of a given "complexity" (currently, state events). This option can be used to prevent adverse performance on resource-constrained homeservers.

changelog.d/5099.misc

@@ -1 +0,0 @@
-Python 2 has been removed from the CI.

changelog.d/5552.misc

@@ -0,0 +1 @@
+Update github templates.

changelog.d/5596.bugfix

@@ -0,0 +1 @@
+Removed the `SYNAPSE_SMTP_*` docker container environment variables. Using these environment variables prevented the docker container from starting in Synapse v1.0, even though they didn't actually allow any functionality anyway. Users are advised to remove `SYNAPSE_SMTP_HOST`, `SYNAPSE_SMTP_PORT`, `SYNAPSE_SMTP_USER`, `SYNAPSE_SMTP_PASSWORD` and `SYNAPSE_SMTP_FROM` environment variables from their docker run commands.

debian/changelog

@@ -1,12 +1,9 @@
-matrix-synapse-py3 (1.1.0) stable; urgency=medium
+matrix-synapse-py3 (1.0.0+nmu1) UNRELEASED; urgency=medium
 
   [ Silke Hofstra ]
   * Include systemd-python to allow logging to the systemd journal.
 
-  [ Synapse Packaging team ]
-  * New synapse release 1.1.0.
-
- -- Synapse Packaging team <packages@matrix.org>  Thu, 04 Jul 2019 11:43:41 +0100
+ -- Silke Hofstra <silke@slxh.eu>  Wed, 29 May 2019 09:45:29 +0200
 
 matrix-synapse-py3 (1.0.0) stable; urgency=medium
 

docs/sample_config.yaml

@@ -278,17 +278,6 @@ listeners:
 # Used by phonehome stats to group together related servers.
 #server_context: context
 
-# Resource-constrained Homeserver Settings
-#
-# If limit_large_remote_room_joins is True, the room complexity will be
-# checked before a user joins a new remote room. If it is above
-# limit_large_remote_room_complexity, it will disallow joining or
-# instantly leave.
-#
-# Uncomment the below lines to enable:
-#limit_large_remote_room_joins: True
-#limit_large_remote_room_complexity: 1.0
-
 # Whether to require a user to be in the room to add an alias to it.
 # Defaults to 'true'.
 #

synapse/__init__.py

@@ -35,4 +35,4 @@ try:
 except ImportError:
     pass
 
-__version__ = "1.1.0"
+__version__ = "1.1.0rc1"

synapse/config/repository.py

@@ -87,18 +87,13 @@ def parse_thumbnail_requirements(thumbnail_sizes):
 
 class ContentRepositoryConfig(Config):
     def read_config(self, config, **kwargs):
-        self.enable_media_repo = config.get("enable_media_repo", True)
-
         self.max_upload_size = self.parse_size(config.get("max_upload_size", "10M"))
         self.max_image_pixels = self.parse_size(config.get("max_image_pixels", "32M"))
         self.max_spider_size = self.parse_size(config.get("max_spider_size", "10M"))
 
-        if self.enable_media_repo:
-            self.media_store_path = self.ensure_directory(config.get("media_store_path", "media_store"))
-            self.uploads_path = self.ensure_directory(config.get("uploads_path", "uploads"))
-        else:
-            self.media_store_path = None
-            self.uploads_path = None
+        self.media_store_path = self.ensure_directory(
+            config.get("media_store_path", "media_store")
+        )
 
         backup_media_store_path = config.get("backup_media_store_path")
 
@@ -155,6 +150,7 @@ class ContentRepositoryConfig(Config):
                 (provider_class, parsed_config, wrapper_config)
             )
 
+        self.uploads_path = self.ensure_directory(config.get("uploads_path", "uploads"))
         self.dynamic_thumbnails = config.get("dynamic_thumbnails", False)
         self.thumbnail_requirements = parse_thumbnail_requirements(
             config.get("thumbnail_sizes", DEFAULT_THUMBNAIL_SIZES)

synapse/config/server.py

@@ -247,12 +247,6 @@ class ServerConfig(Config):
 
         self.gc_thresholds = read_gc_thresholds(config.get("gc_thresholds", None))
 
-        # Resource-constrained Homeserver Configuration
-        self.limit_large_room_joins = config.get("limit_large_remote_room_joins", False)
-        self.limit_large_room_complexity = config.get(
-            "limit_large_remote_room_complexity", 1.0
-        )
-
         bind_port = config.get("bind_port")
         if bind_port:
             if config.get("no_tls", False):
@@ -623,17 +617,6 @@ class ServerConfig(Config):
         # Used by phonehome stats to group together related servers.
         #server_context: context
 
-        # Resource-constrained Homeserver Settings
-        #
-        # If limit_large_remote_room_joins is True, the room complexity will be
-        # checked before a user joins a new remote room. If it is above
-        # limit_large_remote_room_complexity, it will disallow joining or
-        # instantly leave.
-        #
-        # Uncomment the below lines to enable:
-        #limit_large_remote_room_joins: True
-        #limit_large_remote_room_complexity: 1.0
-
         # Whether to require a user to be in the room to add an alias to it.
         # Defaults to 'true'.
         #

synapse/federation/federation_client.py

@@ -995,39 +995,3 @@ class FederationClient(FederationBase):
                 )
 
         raise RuntimeError("Failed to send to any server.")
-
-    @defer.inlineCallbacks
-    def get_room_complexity(self, destination, room_id):
-        """
-        Fetch the complexity of a remote room from another server.
-
-        Args:
-            destination (str): The remote server
-            room_id (str): The room ID to ask about.
-
-        Returns:
-            Deferred[dict] or Deferred[None]: Dict contains the complexity
-            metric versions, while None means we could not fetch the complexity.
-        """
-        try:
-            complexity = yield self.transport_layer.get_room_complexity(
-                destination=destination,
-                room_id=room_id
-            )
-            defer.returnValue(complexity)
-        except CodeMessageException as e:
-            # We didn't manage to get it -- probably a 404. We are okay if other
-            # servers don't give it to us.
-            logger.debug(
-                "Failed to fetch room complexity via %s for %s, got a %d",
-                destination, room_id, e.code
-            )
-        except Exception:
-            logger.exception(
-                "Failed to fetch room complexity via %s for %s",
-                destination, room_id
-            )
-
-        # If we don't manage to find it, return None. It's not an error if a
-        # server doesn't give it to us.
-        defer.returnValue(None)

synapse/federation/transport/client.py

@@ -21,11 +21,7 @@ from six.moves import urllib
 from twisted.internet import defer
 
 from synapse.api.constants import Membership
-from synapse.api.urls import (
-    FEDERATION_UNSTABLE_PREFIX,
-    FEDERATION_V1_PREFIX,
-    FEDERATION_V2_PREFIX,
-)
+from synapse.api.urls import FEDERATION_V1_PREFIX, FEDERATION_V2_PREFIX
 from synapse.util.logutils import log_function
 
 logger = logging.getLogger(__name__)
@@ -939,28 +935,6 @@ class TransportLayerClient(object):
             destination=destination, path=path, data=content, ignore_backoff=True
         )
 
-    def get_room_complexity(self, destination, room_id):
-        """
-        Args:
-            destination (str): The remote server
-            room_id (str): The room ID to ask about.
-        """
-        path = _create_path(
-            FEDERATION_UNSTABLE_PREFIX, "/rooms/%s/complexity", room_id
-        )
-
-        return self.client.get_json(
-            destination=destination,
-            path=path
-        )
-
-
-def _create_path(federation_prefix, path, *args):
-    """
-    Ensures that all args are url encoded.
-    """
-    return federation_prefix + path % tuple(urllib.parse.quote(arg, "") for arg in args)
-
 
 def _create_v1_path(path, *args):
     """Creates a path against V1 federation API from the path template and
@@ -977,7 +951,9 @@ def _create_v1_path(path, *args):
     Returns:
         str
     """
-    return _create_path(FEDERATION_V1_PREFIX, path, *args)
+    return FEDERATION_V1_PREFIX + path % tuple(
+        urllib.parse.quote(arg, "") for arg in args
+    )
 
 
 def _create_v2_path(path, *args):
@@ -995,4 +971,6 @@ def _create_v2_path(path, *args):
     Returns:
         str
     """
-    return _create_path(FEDERATION_V2_PREFIX, path, *args)
+    return FEDERATION_V2_PREFIX + path % tuple(
+        urllib.parse.quote(arg, "") for arg in args
+    )

synapse/handlers/account_validity.py

@@ -22,7 +22,6 @@ from email.mime.text import MIMEText
 from twisted.internet import defer
 
 from synapse.api.errors import StoreError
-from synapse.metrics.background_process_metrics import run_as_background_process
 from synapse.types import UserID
 from synapse.util import stringutils
 from synapse.util.logcontext import make_deferred_yieldable
@@ -68,14 +67,7 @@ class AccountValidityHandler(object):
             )
 
             # Check the renewal emails to send and send them every 30min.
-            def send_emails():
-                # run as a background process to make sure that the database transactions
-                # have a logcontext to report to
-                return run_as_background_process(
-                    "send_renewals", self.send_renewal_emails
-                )
-
-            self.clock.looping_call(send_emails, 30 * 60 * 1000)
+            self.clock.looping_call(self.send_renewal_emails, 30 * 60 * 1000)
 
     @defer.inlineCallbacks
     def send_renewal_emails(self):

synapse/handlers/federation.py

@@ -2764,28 +2764,3 @@ class FederationHandler(BaseHandler):
             )
         else:
             return user_joined_room(self.distributor, user, room_id)
-
-    @defer.inlineCallbacks
-    def get_room_complexity(self, remote_room_hosts, room_id):
-        """
-        Fetch the complexity of a remote room over federation.
-
-        Args:
-            remote_room_hosts (list[str]): The remote servers to ask.
-            room_id (str): The room ID to ask about.
-
-        Returns:
-            Deferred[dict] or Deferred[None]: Dict contains the complexity
-            metric versions, while None means we could not fetch the complexity.
-        """
-
-        for host in remote_room_hosts:
-            res = yield self.federation_client.get_room_complexity(host, room_id)
-
-            # We got a result, return it.
-            if res:
-                defer.returnValue(res)
-
-        # We fell off the bottom, couldn't get the complexity from anyone. Oh
-        # well.
-        defer.returnValue(None)

synapse/handlers/room_member.py

@@ -26,7 +26,8 @@ from unpaddedbase64 import decode_base64
 
 from twisted.internet import defer
 
-from synapse import types
+import synapse.server
+import synapse.types
 from synapse.api.constants import EventTypes, Membership
 from synapse.api.errors import AuthError, Codes, SynapseError
 from synapse.types import RoomID, UserID
@@ -38,11 +39,6 @@ from ._base import BaseHandler
 logger = logging.getLogger(__name__)
 
 id_server_scheme = "https://"
-ROOM_COMPLEXITY_TOO_GREAT = (
-    "Your homeserver is unable to join rooms this large or complex. "
-    "Please speak to your server administrator, or upgrade your instance "
-    "to join this room."
-)
 
 
 class RoomMemberHandler(object):
@@ -565,7 +561,7 @@ class RoomMemberHandler(object):
             ), "Sender (%s) must be same as requester (%s)" % (sender, requester.user)
             assert self.hs.is_mine(sender), "Sender must be our own: %s" % (sender,)
         else:
-            requester = types.create_requester(target_user)
+            requester = synapse.types.create_requester(target_user)
 
         prev_event = yield self.event_creation_handler.deduplicate_state_event(
             event, context
@@ -968,47 +964,6 @@ class RoomMemberMasterHandler(RoomMemberHandler):
         self.distributor.declare("user_joined_room")
         self.distributor.declare("user_left_room")
 
-    @defer.inlineCallbacks
-    def _is_remote_room_too_complex(self, room_id, remote_room_hosts):
-        """
-        Check if complexity of a remote room is too great.
-
-        Args:
-            room_id (str)
-            remote_room_hosts (list[str])
-
-        Returns: bool of whether the complexity is too great, or None
-            if unable to be fetched
-        """
-        max_complexity = self.hs.config.limit_large_room_complexity
-        complexity = yield self.federation_handler.get_room_complexity(
-            remote_room_hosts, room_id
-        )
-
-        if complexity:
-            if complexity["v1"] > max_complexity:
-                return True
-            return False
-        return None
-
-    @defer.inlineCallbacks
-    def _is_local_room_too_complex(self, room_id):
-        """
-        Check if the complexity of a local room is too great.
-
-        Args:
-            room_id (str)
-
-        Returns: bool
-        """
-        max_complexity = self.hs.config.limit_large_room_complexity
-        complexity = yield self.store.get_room_complexity(room_id)
-
-        if complexity["v1"] > max_complexity:
-            return True
-
-        return False
-
     @defer.inlineCallbacks
     def _remote_join(self, requester, remote_room_hosts, room_id, user, content):
         """Implements RoomMemberHandler._remote_join
@@ -1016,6 +971,7 @@ class RoomMemberMasterHandler(RoomMemberHandler):
         # filter ourselves out of remote_room_hosts: do_invite_join ignores it
         # and if it is the only entry we'd like to return a 404 rather than a
         # 500.
+
         remote_room_hosts = [
             host for host in remote_room_hosts if host != self.hs.hostname
         ]
@@ -1023,17 +979,6 @@ class RoomMemberMasterHandler(RoomMemberHandler):
         if len(remote_room_hosts) == 0:
             raise SynapseError(404, "No known servers")
 
-        if self.hs.config.limit_large_room_joins:
-            # Fetch the room complexity
-            too_complex = yield self._is_remote_room_too_complex(
-                room_id, remote_room_hosts
-            )
-            if too_complex is True:
-                raise SynapseError(
-                    code=400, msg=ROOM_COMPLEXITY_TOO_GREAT,
-                    errcode=Codes.RESOURCE_LIMIT_EXCEEDED
-                )
-
         # We don't do an auth check if we are doing an invite
         # join dance for now, since we're kinda implicitly checking
         # that we are allowed to join when we decide whether or not we
@@ -1043,35 +988,6 @@ class RoomMemberMasterHandler(RoomMemberHandler):
         )
         yield self._user_joined_room(user, room_id)
 
-        # Check the room we just joined wasn't too large, if we didn't fetch the
-        # complexity of it before.
-        if self.hs.config.limit_large_room_joins:
-            if too_complex is False:
-                # We checked, and we're under the limit.
-                return
-
-            # Check again, but with the local state events
-            too_complex = yield self._is_local_room_too_complex(room_id)
-
-            if too_complex is False:
-                # We're under the limit.
-                return
-
-            # The room is too large. Leave.
-            requester = types.create_requester(
-                user, None, False, None
-            )
-            yield self.update_membership(
-                requester=requester,
-                target=user,
-                room_id=room_id,
-                action="leave"
-            )
-            raise SynapseError(
-                code=400, msg=ROOM_COMPLEXITY_TOO_GREAT,
-                errcode=Codes.RESOURCE_LIMIT_EXCEEDED
-            )
-
     @defer.inlineCallbacks
     def _remote_reject_invite(self, requester, remote_room_hosts, room_id, target):
         """Implements RoomMemberHandler._remote_reject_invite

synapse/http/server.py

@@ -65,8 +65,8 @@ def wrap_json_request_handler(h):
     The handler method must have a signature of "handle_foo(self, request)",
     where "request" must be a SynapseRequest.
 
-    The handler must return a deferred or a coroutine. If the deferred succeeds
-    we assume that a response has been sent. If the deferred fails with a SynapseError we use
+    The handler must return a deferred. If the deferred succeeds we assume that
+    a response has been sent. If the deferred fails with a SynapseError we use
     it to send a JSON response with the appropriate HTTP reponse code. If the
     deferred fails with any other type of error we send a 500 reponse.
     """
@@ -353,22 +353,16 @@ class DirectServeResource(resource.Resource):
         """
         Render the request, using an asynchronous render handler if it exists.
         """
-        async_render_callback_name = "_async_render_" + request.method.decode("ascii")
+        render_callback_name = "_async_render_" + request.method.decode("ascii")
 
-        # Try and get the async renderer
-        callback = getattr(self, async_render_callback_name, None)
+        if hasattr(self, render_callback_name):
+            # Call the handler
+            callback = getattr(self, render_callback_name)
+            defer.ensureDeferred(callback(request))
 
-        # No async renderer for this request method.
-        if not callback:
-            return super().render(request)
-
-        resp = callback(request)
-
-        # If it's a coroutine, turn it into a Deferred
-        if isinstance(resp, types.CoroutineType):
-            defer.ensureDeferred(resp)
-
-        return NOT_DONE_YET
+            return NOT_DONE_YET
+        else:
+            super().render(request)
 
 
 def _options_handler(request):

synapse/rest/media/v1/preview_url_resource.py

@@ -95,7 +95,6 @@ class PreviewUrlResource(DirectServeResource):
         )
 
     def render_OPTIONS(self, request):
-        request.setHeader(b"Allow", b"OPTIONS, GET")
         return respond_with_json(request, 200, {}, send_cors=True)
 
     @wrap_json_request_handler

synapse/storage/events.py

@@ -253,14 +253,7 @@ class EventsStore(
         )
 
         # Read the extrems every 60 minutes
-        def read_forward_extremities():
-            # run as a background process to make sure that the database transactions
-            # have a logcontext to report to
-            return run_as_background_process(
-                "read_forward_extremities", self._read_forward_extremities
-            )
-
-        hs.get_clock().looping_call(read_forward_extremities, 60 * 60 * 1000)
+        hs.get_clock().looping_call(self._read_forward_extremities, 60 * 60 * 1000)
 
     @defer.inlineCallbacks
     def _read_forward_extremities(self):

synapse/storage/events_worker.py

@@ -649,15 +649,6 @@ class EventsWorkerStore(SQLBaseStore):
 
         return self.runInteraction("get_seen_events_with_rejections", f)
 
-    def _get_current_state_event_counts_txn(self, txn, room_id):
-        """
-        See get_current_state_event_counts.
-        """
-        sql = "SELECT COUNT(*) FROM current_state_events WHERE room_id=?"
-        txn.execute(sql, (room_id,))
-        row = txn.fetchone()
-        return row[0] if row else 0
-
     def _get_total_state_event_counts_txn(self, txn, room_id):
         """
         See get_total_state_event_counts.
@@ -672,9 +663,9 @@ class EventsWorkerStore(SQLBaseStore):
         row = txn.fetchone()
         return row[0] if row else 0
 
-    def get_current_state_event_counts(self, room_id):
+    def get_total_state_event_counts(self, room_id):
         """
-        Gets the current number of state events in a room.
+        Gets the total number of state events in a room.
 
         Args:
             room_id (str)
@@ -683,7 +674,9 @@ class EventsWorkerStore(SQLBaseStore):
             Deferred[int]
         """
         return self.runInteraction(
-            "get_current_state_event_counts", self._get_current_state_event_counts_txn, room_id
+            "get_total_state_event_counts",
+            self._get_total_state_event_counts_txn,
+            room_id,
         )
 
     def _get_current_state_event_counts_txn(self, txn, room_id):

synapse/storage/registration.py

@@ -25,7 +25,6 @@ from twisted.internet import defer
 
 from synapse.api.constants import UserTypes
 from synapse.api.errors import Codes, StoreError, ThreepidValidationError
-from synapse.metrics.background_process_metrics import run_as_background_process
 from synapse.storage import background_updates
 from synapse.storage._base import SQLBaseStore
 from synapse.types import UserID
@@ -620,15 +619,9 @@ class RegistrationStore(
         )
 
         # Create a background job for culling expired 3PID validity tokens
-        def start_cull():
-            # run as a background process to make sure that the database transactions
-            # have a logcontext to report to
-            return run_as_background_process(
-                "cull_expired_threepid_validation_tokens",
-                self.cull_expired_threepid_validation_tokens,
-            )
-
-        hs.get_clock().looping_call(start_cull, THIRTY_MINUTES_IN_MS)
+        hs.get_clock().looping_call(
+            self.cull_expired_threepid_validation_tokens, THIRTY_MINUTES_IN_MS
+        )
 
     @defer.inlineCallbacks
     def _backgroud_update_set_deactivated_flag(self, progress, batch_size):

synapse/util/__init__.py

@@ -62,10 +62,7 @@ class Clock(object):
     def looping_call(self, f, msec):
         """Call a function repeatedly.
 
-        Waits `msec` initially before calling `f` for the first time.
-
-        Note that the function will be called with no logcontext, so if it is anything
-        other than trivial, you probably want to wrap it in run_as_background_process.
+         Waits `msec` initially before calling `f` for the first time.
 
         Args:
             f(function): The function to call repeatedly.
@@ -80,9 +77,6 @@ class Clock(object):
     def call_later(self, delay, callback, *args, **kwargs):
         """Call something later
 
-        Note that the function will be called with no logcontext, so if it is anything
-        other than trivial, you probably want to wrap it in run_as_background_process.
-
         Args:
             delay(float): How long to wait in seconds.
             callback(function): Function to call

synapse/util/logcontext.py

@@ -24,7 +24,6 @@ See doc/log_contexts.rst for details on how this works.
 
 import logging
 import threading
-import types
 
 from twisted.internet import defer, threads
 
@@ -529,9 +528,8 @@ def run_in_background(f, *args, **kwargs):
     return from the function, and that the sentinel context is set once the
     deferred returned by the function completes.
 
-    Useful for wrapping functions that return a deferred or coroutine, which you don't
-    yield or await on (for instance because you want to pass it to
-    deferred.gatherResults()).
+    Useful for wrapping functions that return a deferred which you don't yield
+    on (for instance because you want to pass it to deferred.gatherResults()).
 
     Note that if you completely discard the result, you should make sure that
     `f` doesn't raise any deferred exceptions, otherwise a scary-looking
@@ -546,9 +544,6 @@ def run_in_background(f, *args, **kwargs):
         # by synchronous exceptions, so let's turn them into Failures.
         return defer.fail()
 
-    if isinstance(res, types.CoroutineType):
-        res = defer.ensureDeferred(res)
-
     if not isinstance(res, defer.Deferred):
         return res
 

tests/federation/test_complexity.py

@@ -13,16 +13,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from mock import Mock
-
 from twisted.internet import defer
 
-from synapse.api.errors import Codes, SynapseError
 from synapse.config.ratelimiting import FederationRateLimitConfig
 from synapse.federation.transport import server
 from synapse.rest import admin
 from synapse.rest.client.v1 import login, room
-from synapse.types import UserID
 from synapse.util.ratelimitutils import FederationRateLimiter
 
 from tests import unittest
@@ -36,8 +32,8 @@ class RoomComplexityTests(unittest.HomeserverTestCase):
         login.register_servlets,
     ]
 
-    def default_config(self, name='test'):
-        config = super().default_config(name=name)
+    def default_config(self, name="test"):
+        config = super(RoomComplexityTests, self).default_config(name=name)
         config["limit_large_remote_room_joins"] = True
         config["limit_large_remote_room_complexity"] = 0.05
         return config
@@ -92,71 +88,3 @@ class RoomComplexityTests(unittest.HomeserverTestCase):
         self.assertEquals(200, channel.code)
         complexity = channel.json_body["v1"]
         self.assertEqual(complexity, 1.23)
-
-    def test_join_too_large(self):
-
-        u1 = self.register_user("u1", "pass")
-
-        handler = self.hs.get_room_member_handler()
-        fed_transport = self.hs.get_federation_transport_client()
-
-        # Mock out some things, because we don't want to test the whole join
-        fed_transport.client.get_json = Mock(return_value=defer.succeed({"v1": 9999}))
-        handler.federation_handler.do_invite_join = Mock(return_value=defer.succeed(1))
-
-        d = handler._remote_join(
-            None,
-            ["otherserver.example"],
-            "roomid",
-            UserID.from_string(u1),
-            {"membership": "join"},
-        )
-
-        self.pump()
-
-        # The request failed with a SynapseError saying the resource limit was
-        # exceeded.
-        f = self.get_failure(d, SynapseError)
-        self.assertEqual(f.value.code, 400, f.value)
-        self.assertEqual(f.value.errcode, Codes.RESOURCE_LIMIT_EXCEEDED)
-
-    def test_join_too_large_once_joined(self):
-
-        u1 = self.register_user("u1", "pass")
-        u1_token = self.login("u1", "pass")
-
-        # Ok, this might seem a bit weird -- I want to test that we actually
-        # leave the room, but I don't want to simulate two servers. So, we make
-        # a local room, which we say we're joining remotely, even if there's no
-        # remote, because we mock that out. Then, we'll leave the (actually
-        # local) room, which will be propagated over federation in a real
-        # scenario.
-        room_1 = self.helper.create_room_as(u1, tok=u1_token)
-
-        handler = self.hs.get_room_member_handler()
-        fed_transport = self.hs.get_federation_transport_client()
-
-        # Mock out some things, because we don't want to test the whole join
-        fed_transport.client.get_json = Mock(return_value=defer.succeed(None))
-        handler.federation_handler.do_invite_join = Mock(return_value=defer.succeed(1))
-
-        # Artificially raise the complexity
-        self.hs.get_datastore().get_current_state_event_counts = lambda x: defer.succeed(
-            600
-        )
-
-        d = handler._remote_join(
-            None,
-            ["otherserver.example"],
-            room_1,
-            UserID.from_string(u1),
-            {"membership": "join"},
-        )
-
-        self.pump()
-
-        # The request failed with a SynapseError saying the resource limit was
-        # exceeded.
-        f = self.get_failure(d, SynapseError)
-        self.assertEqual(f.value.code, 400)
-        self.assertEqual(f.value.errcode, Codes.RESOURCE_LIMIT_EXCEEDED)

tests/rest/media/v1/test_url_preview.py

@@ -460,15 +460,3 @@ class URLPreviewTests(unittest.HomeserverTestCase):
                 "error": "DNS resolution failure during URL preview generation",
             },
         )
-
-    def test_OPTIONS(self):
-        """
-        OPTIONS returns the OPTIONS.
-        """
-        request, channel = self.make_request(
-            "OPTIONS", "url_preview?url=http://example.com", shorthand=False
-        )
-        request.render(self.preview_url)
-        self.pump()
-        self.assertEqual(channel.code, 200)
-        self.assertEqual(channel.json_body, {})

tests/unittest.py

@@ -80,6 +80,10 @@ class TestCase(unittest.TestCase):
 
         @around(self)
         def setUp(orig):
+            # enable debugging of delayed calls - this means that we get a
+            # traceback when a unit test exits leaving things on the reactor.
+            twisted.internet.base.DelayedCall.debug = True
+
             # if we're not starting in the sentinel logcontext, then to be honest
             # all future bets are off.
             if LoggingContext.current_context() is not LoggingContext.sentinel:

tests/util/test_logcontext.py

@@ -39,17 +39,24 @@ class LoggingContextTestCase(unittest.TestCase):
 
         callback_completed = [False]
 
+        def test():
+            context_one.request = "one"
+            d = function()
+
+            def cb(res):
+                self._check_test_key("one")
+                callback_completed[0] = True
+                return res
+
+            d.addCallback(cb)
+
+            return d
+
         with LoggingContext() as context_one:
             context_one.request = "one"
 
             # fire off function, but don't wait on it.
-            d2 = logcontext.run_in_background(function)
-
-            def cb(res):
-                callback_completed[0] = True
-                return res
-
-            d2.addCallback(cb)
+            logcontext.run_in_background(test)
 
             self._check_test_key("one")
 
@@ -98,22 +105,6 @@ class LoggingContextTestCase(unittest.TestCase):
 
         return self._test_run_in_background(testfunc)
 
-    def test_run_in_background_with_coroutine(self):
-        async def testfunc():
-            self._check_test_key("one")
-            d = Clock(reactor).sleep(0)
-            self.assertIs(LoggingContext.current_context(), LoggingContext.sentinel)
-            await d
-            self._check_test_key("one")
-
-        return self._test_run_in_background(testfunc)
-
-    def test_run_in_background_with_nonblocking_coroutine(self):
-        async def testfunc():
-            self._check_test_key("one")
-
-        return self._test_run_in_background(testfunc)
-
     @defer.inlineCallbacks
     def test_make_deferred_yieldable(self):
         # a function which retuns an incomplete deferred, but doesn't follow