flake8

Use static column name insertion
Otherwise we end up trying to ORDER BY "is_admin", the literal string.
2017-11-06 16:50:33 +00:00 · 2017-11-06 16:16:24 +00:00 · 2017-11-06 15:45:20 +00:00
234 changed files with 5324 additions and 10993 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -46,5 +46,3 @@ static/client/register/register_config.js

 env/
 *.config
-
-.vscode/
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -1,200 +1,3 @@
-Changes in synapse v0.27.2 (2018-03-26)
-=======================================
-
-Bug fixes:
-
-* Fix bug which broke TCP replication between workers (PR #3015)
-
-
-Changes in synapse v0.27.1 (2018-03-26)
-=======================================
-
-Meta release as v0.27.0 temporarily pointed to the wrong commit
-
-
-Changes in synapse v0.27.0 (2018-03-26)
-=======================================
-
-No changes since v0.27.0-rc2
-
-
-Changes in synapse v0.27.0-rc2 (2018-03-19)
-===========================================
-
-Pulls in v0.26.1
-
-Bug fixes:
-
-* Fix bug introduced in v0.27.0-rc1 that causes much increased memory usage in state cache (PR #3005)
-
-
-Changes in synapse v0.26.1 (2018-03-15)
-=======================================
-
-Bug fixes:
-
-* Fix bug where an invalid event caused server to stop functioning correctly,
-  due to parsing and serializing bugs in ujson library (PR #3008)
-
-
-Changes in synapse v0.27.0-rc1 (2018-03-14)
-===========================================
-
-The common case for running Synapse is not to run separate workers, but for those that do, be aware that synctl no longer starts the main synapse when using ``-a`` option with workers. A new worker file should be added with ``worker_app: synapse.app.homeserver``.
-
-This release also begins the process of renaming a number of the metrics
-reported to prometheus. See `docs/metrics-howto.rst <docs/metrics-howto.rst#block-and-response-metrics-renamed-for-0-27-0>`_.
-Note that the v0.28.0 release will remove the deprecated metric names.
-
-Features:
-
-* Add ability for ASes to override message send time (PR #2754)
-* Add support for custom storage providers for media repository (PR #2867, #2777, #2783, #2789, #2791, #2804, #2812, #2814, #2857, #2868, #2767)
-* Add purge API features, see `docs/admin_api/purge_history_api.rst <docs/admin_api/purge_history_api.rst>`_ for full details (PR #2858, #2867, #2882, #2946, #2962, #2943)
-* Add support for whitelisting 3PIDs that users can register. (PR #2813)
-* Add ``/room/{id}/event/{id}`` API (PR #2766)
-* Add an admin API to get all the media in a room (PR #2818) Thanks to @turt2live!
-* Add ``federation_domain_whitelist`` option (PR #2820, #2821)
-
-
-Changes:
-
-* Continue to factor out processing from main process and into worker processes. See updated `docs/workers.rst <docs/metrics-howto.rst>`_ (PR #2892 - #2904, #2913, #2920 - #2926, #2947, #2847, #2854, #2872, #2873, #2874, #2928, #2929, #2934, #2856, #2976 - #2984, #2987 - #2989, #2991 - #2993, #2995, #2784)
-* Ensure state cache is used when persisting events (PR #2864, #2871, #2802, #2835, #2836, #2841, #2842, #2849)
-* Change the default config to bind on both IPv4 and IPv6 on all platforms (PR #2435) Thanks to @silkeh!
-* No longer require a specific version of saml2 (PR #2695) Thanks to @okurz!
-* Remove ``verbosity``/``log_file`` from generated config (PR #2755)
-* Add and improve metrics and logging (PR #2770, #2778, #2785, #2786, #2787, #2793, #2794, #2795, #2809, #2810, #2833, #2834, #2844, #2965, #2927, #2975, #2790, #2796, #2838)
-* When using synctl with workers, don't start the main synapse automatically (PR #2774)
-* Minor performance improvements (PR #2773, #2792)
-* Use a connection pool for non-federation outbound connections (PR #2817)
-* Make it possible to run unit tests against postgres (PR #2829)
-* Update pynacl dependency to 1.2.1 or higher (PR #2888) Thanks to @bachp!
-* Remove ability for AS users to call /events and /sync (PR #2948)
-* Use bcrypt.checkpw (PR #2949) Thanks to @krombel!
-
-Bug fixes:
-
-* Fix broken ``ldap_config`` config option (PR #2683) Thanks to @seckrv!
-* Fix error message when user is not allowed to unban (PR #2761) Thanks to @turt2live!
-* Fix publicised groups GET API (singular) over federation (PR #2772)
-* Fix user directory when using ``user_directory_search_all_users`` config option (PR #2803, #2831)
-* Fix error on ``/publicRooms`` when no rooms exist (PR #2827)
-* Fix bug in quarantine_media (PR #2837)
-* Fix url_previews when no Content-Type is returned from URL (PR #2845)
-* Fix rare race in sync API when joining room (PR #2944)
-* Fix slow event search, switch back from GIST to GIN indexes (PR #2769, #2848)
-
-
-Changes in synapse v0.26.0 (2018-01-05)
-=======================================
-
-No changes since v0.26.0-rc1
-
-
-Changes in synapse v0.26.0-rc1 (2017-12-13)
-===========================================
-
-Features:
-
-* Add ability for ASes to publicise groups for their users (PR #2686)
-* Add all local users to the user_directory and optionally search them (PR
-  #2723)
-* Add support for custom login types for validating users (PR #2729)
-
-
-Changes:
-
-* Update example Prometheus config to new format (PR #2648) Thanks to
-  @krombel!
-* Rename redact_content option to include_content in Push API (PR #2650)
-* Declare support for r0.3.0 (PR #2677)
-* Improve upserts (PR #2684, #2688, #2689, #2713)
-* Improve documentation of workers (PR #2700)
-* Improve tracebacks on exceptions (PR #2705)
-* Allow guest access to group APIs for reading (PR #2715)
-* Support for posting content in federation_client script (PR #2716)
-* Delete devices and pushers on logouts etc (PR #2722)
-
-
-Bug fixes:
-
-* Fix database port script (PR #2673)
-* Fix internal server error on login with ldap_auth_provider (PR #2678) Thanks
-  to @jkolo!
-* Fix error on sqlite 3.7 (PR #2697)
-* Fix OPTIONS on preview_url (PR #2707)
-* Fix error handling on dns lookup (PR #2711)
-* Fix wrong avatars when inviting multiple users when creating room (PR #2717)
-* Fix 500 when joining matrix-dev (PR #2719)
-
-
-Changes in synapse v0.25.1 (2017-11-17)
-=======================================
-
-Bug fixes:
-
-* Fix login with LDAP and other password provider modules (PR #2678). Thanks to
-  @jkolo!
-
-Changes in synapse v0.25.0 (2017-11-15)
-=======================================
-
-Bug fixes:
-
-* Fix port script (PR #2673)
-
-
-Changes in synapse v0.25.0-rc1 (2017-11-14)
-===========================================
-
-Features:
-
-* Add is_public to groups table to allow for private groups (PR #2582)
-* Add a route for determining who you are (PR #2668) Thanks to @turt2live!
-* Add more features to the password providers (PR #2608, #2610, #2620, #2622,
-  #2623, #2624, #2626, #2628, #2629)
-* Add a hook for custom rest endpoints (PR #2627)
-* Add API to update group room visibility (PR #2651)
-
-
-Changes:
-
-* Ignore <noscript> tags when generating URL preview descriptions (PR #2576)
-  Thanks to @maximevaillancourt!
-* Register some /unstable endpoints in /r0 as well (PR #2579) Thanks to
-  @krombel!
-* Support /keys/upload on /r0 as well as /unstable (PR #2585)
-* Front-end proxy: pass through auth header (PR #2586)
-* Allow ASes to deactivate their own users (PR #2589)
-* Remove refresh tokens (PR #2613)
-* Automatically set default displayname on register (PR #2617)
-* Log login requests (PR #2618)
-* Always return `is_public` in the `/groups/:group_id/rooms` API (PR #2630)
-* Avoid no-op media deletes (PR #2637) Thanks to @spantaleev!
-* Fix various embarrassing typos around user_directory and add some doc. (PR
-  #2643)
-* Return whether a user is an admin within a group (PR #2647)
-* Namespace visibility options for groups (PR #2657)
-* Downcase UserIDs on registration (PR #2662)
-* Cache failures when fetching URL previews (PR #2669)
-
-
-Bug fixes:
-
-* Fix port script (PR #2577)
-* Fix error when running synapse with no logfile (PR #2581)
-* Fix UI auth when deleting devices (PR #2591)
-* Fix typo when checking if user is invited to group (PR #2599)
-* Fix the port script to drop NUL values in all tables (PR #2611)
-* Fix appservices being backlogged and not receiving new events due to a bug in
-  notify_interested_services (PR #2631) Thanks to @xyzz!
-* Fix updating rooms avatar/display name when modified by admin (PR #2636)
-  Thanks to @farialima!
-* Fix bug in state group storage (PR #2649)
-* Fix 500 on invalid utf-8 in request (PR #2663)
-
-
 Changes in synapse v0.24.1 (2017-10-24)
 =======================================

--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -30,12 +30,8 @@ use github's pull request workflow to review the contribution, and either ask
 you to make any refinements needed or merge it and make them ourselves. The
 changes will then land on master when we next do a release.

-We use `Jenkins <http://matrix.org/jenkins>`_ and 
-`Travis <https://travis-ci.org/matrix-org/synapse>`_ for continuous
-integration. All pull requests to synapse get automatically tested by Travis; 
-the Jenkins builds require an adminstrator to start them. If your change 
-breaks the build, this will be shown in github, so please keep an eye on the 
-pull request for feedback.
+We use Jenkins for continuous integration (http://matrix.org/jenkins), and
+typically all pull requests get automatically tested Jenkins: if your change breaks the build, Jenkins will yell about it in #matrix-dev:matrix.org so please lurk there and keep an eye open.

 Code style
 ~~~~~~~~~~
@@ -119,4 +115,4 @@ can't be accepted. Git makes this trivial - just use the -s flag when you do
 Conclusion
 ~~~~~~~~~~

-That's it!  Matrix is a very open and collaborative project as you might expect given our obsession with open communication.  If we're going to successfully matrix together all the fragmented communication technologies out there we are reliant on contributions and collaboration from the community to do so.  So please get involved - and we hope you have as much fun hacking on Matrix as we do!
+That's it!  Matrix is a very open and collaborative project as you might expect given our obsession with open communication.  If we're going to successfully matrix together all the fragmented communication technologies out there we are reliant on contributions and collaboration from the community to do so.  So please get involved - and we hope you have as much fun hacking on Matrix as we do!
--- a/README.rst
+++ b/README.rst
@@ -354,10 +354,6 @@ https://matrix.org/docs/projects/try-matrix-now.html (or build your own with one
 Fedora
 ------

-Synapse is in the Fedora repositories as ``matrix-synapse``::
-
-    sudo dnf install matrix-synapse
-
 Oleg Girko provides Fedora RPMs at
 https://obs.infoserver.lv/project/monitor/matrix-synapse

@@ -636,11 +632,6 @@ largest boxes pause for thought.)

 Troubleshooting
 ---------------
-
-You can use the federation tester to check if your homeserver is all set:
-``https://matrix.org/federationtester/api/report?server_name=<your_server_name>``
-If any of the attributes under "checks" is false, federation won't work.
-
 The typical failure mode with federation is that when you try to join a room,
 it is rejected with "401: Unauthorized". Generally this means that other
 servers in the room couldn't access yours. (Joining a room over federation is a
@@ -894,17 +885,6 @@ This should end with a 'PASSED' result::

    PASSED (successes=143)

-Running the Integration Tests
-=============================
-
-Synapse is accompanied by `SyTest <https://github.com/matrix-org/sytest>`_,
-a Matrix homeserver integration testing suite, which uses HTTP requests to
-access the API as a Matrix client would. It is able to run Synapse directly from
-the source tree, so installation of the server is not required.
-
-Testing with SyTest is recommended for verifying that changes related to the
-Client-Server API are functioning correctly. See the `installation instructions
-<https://github.com/matrix-org/sytest#installing>`_ for details.

 Building Internal API Documentation
 ===================================
--- a/contrib/prometheus/README
+++ b/contrib/prometheus/README
@@ -5,8 +5,7 @@ To use it, first install prometheus by following the instructions at

  http://prometheus.io/

-### for Prometheus v1
-Add a new job to the main prometheus.conf file:
+Then add a new job to the main prometheus.conf file:

  job: {
    name: "synapse"
@@ -16,22 +15,6 @@ Add a new job to the main prometheus.conf file:
    }
  }

-### for Prometheus v2
-Add a new job to the main prometheus.yml file:
-
-  - job_name: "synapse"
-    metrics_path: "/_synapse/metrics"
-    # when endpoint uses https:
-    scheme: "https"
-
-    static_configs:
-    - targets: ['SERVER.LOCATION:PORT']
-
-To use `synapse.rules` add
-
-    rule_files:
-      - "/PATH/TO/synapse-v2.rules"
-
 Metrics are disabled by default when running synapse; they must be enabled
 with the 'enable-metrics' option, either in the synapse config file or as a
 command-line option.
--- a/contrib/prometheus/synapse-v2.rules
+++ b/contrib/prometheus/synapse-v2.rules
@@ -1,60 +0,0 @@
-groups:
- name: synapse
-  rules:
-  - record: "synapse_federation_transaction_queue_pendingEdus:total"
-    expr: "sum(synapse_federation_transaction_queue_pendingEdus or absent(synapse_federation_transaction_queue_pendingEdus)*0)"
-  - record: "synapse_federation_transaction_queue_pendingPdus:total"
-    expr:   "sum(synapse_federation_transaction_queue_pendingPdus or absent(synapse_federation_transaction_queue_pendingPdus)*0)"
-  - record: 'synapse_http_server_requests:method'
-    labels:
-      servlet: ""
-    expr: "sum(synapse_http_server_requests) by (method)"
-  - record: 'synapse_http_server_requests:servlet'
-    labels:
-      method: ""
-    expr: 'sum(synapse_http_server_requests) by (servlet)'
-
-  - record: 'synapse_http_server_requests:total'
-    labels:
-      servlet: ""
-    expr: 'sum(synapse_http_server_requests:by_method) by (servlet)'
-
-  - record: 'synapse_cache:hit_ratio_5m'
-    expr: 'rate(synapse_util_caches_cache:hits[5m]) / rate(synapse_util_caches_cache:total[5m])'
-  - record: 'synapse_cache:hit_ratio_30s'
-    expr: 'rate(synapse_util_caches_cache:hits[30s]) / rate(synapse_util_caches_cache:total[30s])'
-
-  - record: 'synapse_federation_client_sent'
-    labels:
-      type: "EDU"
-    expr: 'synapse_federation_client_sent_edus + 0'
-  - record: 'synapse_federation_client_sent'
-    labels:
-      type: "PDU"
-    expr: 'synapse_federation_client_sent_pdu_destinations:count + 0'
-  - record: 'synapse_federation_client_sent'
-    labels:
-      type: "Query"
-    expr: 'sum(synapse_federation_client_sent_queries) by (job)'
-
-  - record: 'synapse_federation_server_received'
-    labels:
-      type: "EDU"
-    expr: 'synapse_federation_server_received_edus + 0'
-  - record: 'synapse_federation_server_received'
-    labels:
-      type: "PDU"
-    expr: 'synapse_federation_server_received_pdus + 0'
-  - record: 'synapse_federation_server_received'
-    labels:
-      type: "Query"
-    expr: 'sum(synapse_federation_server_received_queries) by (job)'
-
-  - record: 'synapse_federation_transaction_queue_pending'
-    labels:
-      type: "EDU"
-    expr: 'synapse_federation_transaction_queue_pending_edus + 0'
-  - record: 'synapse_federation_transaction_queue_pending'
-    labels:
-      type: "PDU"
-    expr: 'synapse_federation_transaction_queue_pending_pdus + 0'
--- a/contrib/prometheus/synapse-v1.rules
+++ b/contrib/prometheus/synapse-v1.rules
--- a/docs/admin_api/media_admin_api.md
+++ b/docs/admin_api/media_admin_api.md
@@ -1,23 +0,0 @@
-# List all media in a room
-
-This API gets a list of known media in a room.
-
-The API is:
-```
-GET /_matrix/client/r0/admin/room/<room_id>/media
-```
-including an `access_token` of a server admin.
-
-It returns a JSON body like the following:
-```
-{
-    "local": [
-        "mxc://localhost/xwvutsrqponmlkjihgfedcba",
-        "mxc://localhost/abcdefghijklmnopqrstuvwx"
-    ],
-    "remote": [
-        "mxc://matrix.org/xwvutsrqponmlkjihgfedcba",
-        "mxc://matrix.org/abcdefghijklmnopqrstuvwx"
-    ]
-}
-```
--- a/docs/admin_api/purge_history_api.rst
+++ b/docs/admin_api/purge_history_api.rst
@@ -4,60 +4,14 @@ Purge History API
 The purge history API allows server admins to purge historic events from their
 database, reclaiming disk space.

+**NB!** This will not delete local events (locally sent messages content etc) from the database, but will remove lots of the metadata about them and does dramatically reduce the on disk space usage
+
 Depending on the amount of history being purged a call to the API may take
 several minutes or longer. During this period users will not be able to
 paginate further back in the room from the point being purged from.

-The API is:
+The API is simply:

-``POST /_matrix/client/r0/admin/purge_history/<room_id>[/<event_id>]``
+``POST /_matrix/client/r0/admin/purge_history/<room_id>/<event_id>``

 including an ``access_token`` of a server admin.
-
-By default, events sent by local users are not deleted, as they may represent
-the only copies of this content in existence. (Events sent by remote users are
-deleted.)
-
-Room state data (such as joins, leaves, topic) is always preserved.
-
-To delete local message events as well, set ``delete_local_events`` in the body:
-
-.. code:: json
-
-   {
-       "delete_local_events": true
-   }
-
-The caller must specify the point in the room to purge up to. This can be
-specified by including an event_id in the URI, or by setting a
-``purge_up_to_event_id`` or ``purge_up_to_ts`` in the request body. If an event
-id is given, that event (and others at the same graph depth) will be retained.
-If ``purge_up_to_ts`` is given, it should be a timestamp since the unix epoch,
-in milliseconds.
-
-The API starts the purge running, and returns immediately with a JSON body with
-a purge id:
-
-.. code:: json
-
-    {
-        "purge_id": "<opaque id>"
-    }
-
-Purge status query
------------------
-
-It is possible to poll for updates on recent purges with a second API;
-
-``GET /_matrix/client/r0/admin/purge_history_status/<purge_id>``
-
-(again, with a suitable ``access_token``). This API returns a JSON body like
-the following:
-
-.. code:: json
-
-    {
-        "status": "active"
-    }
-
-The status will be one of ``active``, ``complete``, or ``failed``.
--- a/docs/log_contexts.rst
+++ b/docs/log_contexts.rst
@@ -279,9 +279,9 @@ Obviously that option means that the operations done in
 that might be fixed by setting a different logcontext via a ``with
 LoggingContext(...)`` in ``background_operation``).

-The second option is to use ``logcontext.run_in_background``, which wraps a
-function so that it doesn't reset the logcontext even when it returns an
-incomplete deferred, and adds a callback to the returned deferred to reset the
+The second option is to use ``logcontext.preserve_fn``, which wraps a function
+so that it doesn't reset the logcontext even when it returns an incomplete
+deferred, and adds a callback to the returned deferred to reset the
 logcontext. In other words, it turns a function that follows the Synapse rules
 about logcontexts and Deferreds into one which behaves more like an external
 function — the opposite operation to that described in the previous section.
@@ -293,11 +293,15 @@ It can be used like this:
    def do_request_handling():
        yield foreground_operation()

-        logcontext.run_in_background(background_operation)
+        logcontext.preserve_fn(background_operation)()

        # this will now be logged against the request context
        logger.debug("Request handling complete")

+XXX: I think ``preserve_context_over_fn`` is supposed to do the first option,
+but the fact that it does ``preserve_context_over_deferred`` on its results
+means that its use is fraught with difficulty.
+
 Passing synapse deferreds into third-party functions
 ----------------------------------------------------

--- a/docs/metrics-howto.rst
+++ b/docs/metrics-howto.rst
@@ -16,7 +16,7 @@ How to monitor Synapse metrics using Prometheus
     metrics_port: 9092

   Also ensure that ``enable_metrics`` is set to ``True``.
-
+  
   Restart synapse.

 3. Add a prometheus target for synapse.
@@ -28,58 +28,11 @@ How to monitor Synapse metrics using Prometheus
      static_configs:
        - targets: ["my.server.here:9092"]

-   If your prometheus is older than 1.5.2, you will need to replace
+   If your prometheus is older than 1.5.2, you will need to replace 
   ``static_configs`` in the above with ``target_groups``.
-
+   
   Restart prometheus.

-
-Block and response metrics renamed for 0.27.0
---------------------------------------------
-
-Synapse 0.27.0 begins the process of rationalising the duplicate ``*:count``
-metrics reported for the resource tracking for code blocks and HTTP requests.
-
-At the same time, the corresponding ``*:total`` metrics are being renamed, as
-the ``:total`` suffix no longer makes sense in the absence of a corresponding
-``:count`` metric.
-
-To enable a graceful migration path, this release just adds new names for the
-metrics being renamed. A future release will remove the old ones.
-
-The following table shows the new metrics, and the old metrics which they are
-replacing.
-
-==================================================== ===================================================
-New name                                             Old name
-==================================================== ===================================================
-synapse_util_metrics_block_count                     synapse_util_metrics_block_timer:count
-synapse_util_metrics_block_count                     synapse_util_metrics_block_ru_utime:count
-synapse_util_metrics_block_count                     synapse_util_metrics_block_ru_stime:count
-synapse_util_metrics_block_count                     synapse_util_metrics_block_db_txn_count:count
-synapse_util_metrics_block_count                     synapse_util_metrics_block_db_txn_duration:count
-
-synapse_util_metrics_block_time_seconds              synapse_util_metrics_block_timer:total
-synapse_util_metrics_block_ru_utime_seconds          synapse_util_metrics_block_ru_utime:total
-synapse_util_metrics_block_ru_stime_seconds          synapse_util_metrics_block_ru_stime:total
-synapse_util_metrics_block_db_txn_count              synapse_util_metrics_block_db_txn_count:total
-synapse_util_metrics_block_db_txn_duration_seconds   synapse_util_metrics_block_db_txn_duration:total
-
-synapse_http_server_response_count                   synapse_http_server_requests
-synapse_http_server_response_count                   synapse_http_server_response_time:count
-synapse_http_server_response_count                   synapse_http_server_response_ru_utime:count
-synapse_http_server_response_count                   synapse_http_server_response_ru_stime:count
-synapse_http_server_response_count                   synapse_http_server_response_db_txn_count:count
-synapse_http_server_response_count                   synapse_http_server_response_db_txn_duration:count
-
-synapse_http_server_response_time_seconds            synapse_http_server_response_time:total
-synapse_http_server_response_ru_utime_seconds        synapse_http_server_response_ru_utime:total
-synapse_http_server_response_ru_stime_seconds        synapse_http_server_response_ru_stime:total
-synapse_http_server_response_db_txn_count            synapse_http_server_response_db_txn_count:total
-synapse_http_server_response_db_txn_duration_seconds synapse_http_server_response_db_txn_duration:total
-==================================================== ===================================================
-
-
 Standard Metric Names
 ---------------------

@@ -89,7 +42,7 @@ have been changed to seconds, from miliseconds.

 ================================== =============================
 New name                           Old name
-================================== =============================
+---------------------------------- -----------------------------
 process_cpu_user_seconds_total     process_resource_utime / 1000
 process_cpu_system_seconds_total   process_resource_stime / 1000
 process_open_fds (no 'type' label) process_fds
@@ -99,8 +52,8 @@ The python-specific counts of garbage collector performance have been renamed.

 =========================== ======================
 New name                    Old name
-=========================== ======================
-python_gc_time              reactor_gc_time
+--------------------------- ----------------------
+python_gc_time              reactor_gc_time      
 python_gc_unreachable_total reactor_gc_unreachable
 python_gc_counts            reactor_gc_counts
 =========================== ======================
@@ -109,7 +62,7 @@ The twisted-specific reactor metrics have been renamed.

 ==================================== =====================
 New name                             Old name
-==================================== =====================
+------------------------------------ ---------------------
 python_twisted_reactor_pending_calls reactor_pending_calls
 python_twisted_reactor_tick_time     reactor_tick_time
 ==================================== =====================
--- a/docs/user_directory.md
+++ b/docs/user_directory.md
@@ -1,17 +0,0 @@
-User Directory API Implementation
-=================================
-
-The user directory is currently maintained based on the 'visible' users
-on this particular server - i.e. ones which your account shares a room with, or
-who are present in a publicly viewable room present on the server.
-
-The directory info is stored in various tables, which can (typically after
-DB corruption) get stale or out of sync.  If this happens, for now the
-quickest solution to fix it is:
-
-```
-UPDATE user_directory_stream_pos SET stream_id = NULL;
-```
-
-and restart the synapse, which should then start a background task to
-flush the current tables and regenerate the directory.
--- a/docs/workers.rst
+++ b/docs/workers.rst
@@ -1,15 +1,11 @@
 Scaling synapse via workers
-===========================
+---------------------------

 Synapse has experimental support for splitting out functionality into
 multiple separate python processes, helping greatly with scalability.  These
 processes are called 'workers', and are (eventually) intended to scale
 horizontally independently.

-All of the below is highly experimental and subject to change as Synapse evolves,
-but documenting it here to help folks needing highly scalable Synapses similar
-to the one running matrix.org!
-
 All processes continue to share the same database instance, and as such, workers
 only work with postgres based synapse deployments (sharing a single sqlite
 across multiple processes is a recipe for disaster, plus you should be using
@@ -20,57 +16,37 @@ TCP protocol called 'replication' - analogous to MySQL or Postgres style
 database replication; feeding a stream of relevant data to the workers so they
 can be kept in sync with the main synapse process and database state.

-Configuration
-------------
-
-To make effective use of the workers, you will need to configure an HTTP
-reverse-proxy such as nginx or haproxy, which will direct incoming requests to
-the correct worker, or to the main synapse instance. Note that this includes
-requests made to the federation port. The caveats regarding running a
-reverse-proxy on the federation port still apply (see
-https://github.com/matrix-org/synapse/blob/master/README.rst#reverse-proxying-the-federation-port).
-
-To enable workers, you need to add two replication listeners to the master
-synapse, e.g.::
+To enable workers, you need to add a replication listener to the master synapse, e.g.::

    listeners:
-      # The TCP replication port
      - port: 9092
        bind_address: '127.0.0.1'
        type: replication
-      # The HTTP replication port
-      - port: 9093
-        bind_address: '127.0.0.1'
-        type: http
-        resources:
-         - names: [replication]

-Under **no circumstances** should these replication API listeners be exposed to
-the public internet; it currently implements no authentication whatsoever and is
+Under **no circumstances** should this replication API listener be exposed to the
+public internet; it currently implements no authentication whatsoever and is
 unencrypted.

-(Roughly, the TCP port is used for streaming data from the master to the
-workers, and the HTTP port for the workers to send data to the main
-synapse process.)
+You then create a set of configs for the various worker processes.  These should be
+worker configuration files should be stored in a dedicated subdirectory, to allow
+synctl to manipulate them.

-You then create a set of configs for the various worker processes.  These
-should be worker configuration files, and should be stored in a dedicated
-subdirectory, to allow synctl to manipulate them.
+The current available worker applications are:
+ * synapse.app.pusher - handles sending push notifications to sygnal and email
+ * synapse.app.synchrotron - handles /sync endpoints.  can scales horizontally through multiple instances.
+ * synapse.app.appservice - handles output traffic to Application Services
+ * synapse.app.federation_reader - handles receiving federation traffic (including public_rooms API)
+ * synapse.app.media_repository - handles the media repository.
+ * synapse.app.client_reader - handles client API endpoints like /publicRooms

 Each worker configuration file inherits the configuration of the main homeserver
 configuration file.  You can then override configuration specific to that worker,
 e.g. the HTTP listener that it provides (if any); logging configuration; etc.
 You should minimise the number of overrides though to maintain a usable config.

-You must specify the type of worker application (``worker_app``). The currently
-available worker applications are listed below. You must also specify the
-replication endpoints that it's talking to on the main synapse process.
-``worker_replication_host`` should specify the host of the main synapse,
-``worker_replication_port`` should point to the TCP replication listener port and
-``worker_replication_http_port`` should point to the HTTP replication port.
-
-Currently, only the ``event_creator`` worker requires specifying
-``worker_replication_http_port``.
+You must specify the type of worker application (worker_app) and the replication
+endpoint that it's talking to on the main synapse process (worker_replication_host
+and worker_replication_port).

 For instance::

@@ -79,7 +55,6 @@ For instance::
    # The replication listener on the synapse to talk to.
    worker_replication_host: 127.0.0.1
    worker_replication_port: 9092
-    worker_replication_http_port: 9093

    worker_listeners:
     - type: http
@@ -93,11 +68,11 @@ For instance::
    worker_log_config: /home/matrix/synapse/config/synchrotron_log_config.yaml

 ...is a full configuration for a synchrotron worker instance, which will expose a
-plain HTTP ``/sync`` endpoint on port 8083 separately from the ``/sync`` endpoint provided
+plain HTTP /sync endpoint on port 8083 separately from the /sync endpoint provided
 by the main synapse.

-Obviously you should configure your reverse-proxy to route the relevant
-endpoints to the worker (``localhost:8083`` in the above example).
+Obviously you should configure your loadbalancer to route the /sync endpoint to
+the synchrotron instance(s) in this instance.

 Finally, to actually run your worker-based synapse, you must pass synctl the -a
 commandline option to tell it to operate on all the worker configurations found
@@ -114,125 +89,6 @@ To manipulate a specific worker, you pass the -w option to synctl::

    synctl -w $CONFIG/workers/synchrotron.yaml restart

-
-Available worker applications
-----------------------------
-
-``synapse.app.pusher``
-~~~~~~~~~~~~~~~~~~~~~~
-
-Handles sending push notifications to sygnal and email. Doesn't handle any
-REST endpoints itself, but you should set ``start_pushers: False`` in the
-shared configuration file to stop the main synapse sending these notifications.
-
-Note this worker cannot be load-balanced: only one instance should be active.
-
-``synapse.app.synchrotron``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The synchrotron handles ``sync`` requests from clients. In particular, it can
-handle REST endpoints matching the following regular expressions::
-
-    ^/_matrix/client/(v2_alpha|r0)/sync$
-    ^/_matrix/client/(api/v1|v2_alpha|r0)/events$
-    ^/_matrix/client/(api/v1|r0)/initialSync$
-    ^/_matrix/client/(api/v1|r0)/rooms/[^/]+/initialSync$
-
-The above endpoints should all be routed to the synchrotron worker by the
-reverse-proxy configuration.
-
-It is possible to run multiple instances of the synchrotron to scale
-horizontally. In this case the reverse-proxy should be configured to
-load-balance across the instances, though it will be more efficient if all
-requests from a particular user are routed to a single instance. Extracting
-a userid from the access token is currently left as an exercise for the reader.
-
-``synapse.app.appservice``
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Handles sending output traffic to Application Services. Doesn't handle any
-REST endpoints itself, but you should set ``notify_appservices: False`` in the
-shared configuration file to stop the main synapse sending these notifications.
-
-Note this worker cannot be load-balanced: only one instance should be active.
-
-``synapse.app.federation_reader``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Handles a subset of federation endpoints. In particular, it can handle REST
-endpoints matching the following regular expressions::
-
-    ^/_matrix/federation/v1/event/
-    ^/_matrix/federation/v1/state/
-    ^/_matrix/federation/v1/state_ids/
-    ^/_matrix/federation/v1/backfill/
-    ^/_matrix/federation/v1/get_missing_events/
-    ^/_matrix/federation/v1/publicRooms
-
-The above endpoints should all be routed to the federation_reader worker by the
-reverse-proxy configuration.
-
-``synapse.app.federation_sender``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Handles sending federation traffic to other servers. Doesn't handle any
-REST endpoints itself, but you should set ``send_federation: False`` in the
-shared configuration file to stop the main synapse sending this traffic.
-
-Note this worker cannot be load-balanced: only one instance should be active.
-
-``synapse.app.media_repository``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Handles the media repository. It can handle all endpoints starting with::
-
-    /_matrix/media/
-
-You should also set ``enable_media_repo: False`` in the shared configuration
-file to stop the main synapse running background jobs related to managing the
-media repository.
-
-Note this worker cannot be load-balanced: only one instance should be active.
-
-``synapse.app.client_reader``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Handles client API endpoints. It can handle REST endpoints matching the
-following regular expressions::
-
-    ^/_matrix/client/(api/v1|r0|unstable)/publicRooms$
-
-``synapse.app.user_dir``
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-Handles searches in the user directory. It can handle REST endpoints matching
-the following regular expressions::
-
-    ^/_matrix/client/(api/v1|r0|unstable)/user_directory/search$
-
-``synapse.app.frontend_proxy``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Proxies some frequently-requested client endpoints to add caching and remove
-load from the main synapse. It can handle REST endpoints matching the following
-regular expressions::
-
-    ^/_matrix/client/(api/v1|r0|unstable)/keys/upload
-
-It will proxy any requests it cannot handle to the main synapse instance. It
-must therefore be configured with the location of the main instance, via
-the ``worker_main_http_uri`` setting in the frontend_proxy worker configuration
-file. For example::
-
-    worker_main_http_uri: http://127.0.0.1:8008
-
-
-``synapse.app.event_creator``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Handles non-state event creation. It can handle REST endpoints matching::
-
-    ^/_matrix/client/(api/v1|r0|unstable)/rooms/.*/send
-
-It will create events locally and then send them on to the main synapse
-instance to be persisted and handled.
+All of the above is highly experimental and subject to change as Synapse evolves,
+but documenting it here to help folks needing highly scalable Synapses similar
+to the one running matrix.org!
--- a/scripts-dev/federation_client.py
+++ b/scripts-dev/federation_client.py
@@ -123,25 +123,15 @@ def lookup(destination, path):
        except:
            return "https://%s:%d%s" % (destination, 8448, path)

-
-def request_json(method, origin_name, origin_key, destination, path, content):
-    if method is None:
-        if content is None:
-            method = "GET"
-        else:
-            method = "POST"
-
-    json_to_sign = {
-        "method": method,
+def get_json(origin_name, origin_key, destination, path):
+    request_json = {
+        "method": "GET",
        "uri": path,
        "origin": origin_name,
        "destination": destination,
    }

-    if content is not None:
-        json_to_sign["content"] = json.loads(content)
-
-    signed_json = sign_json(json_to_sign, origin_key, origin_name)
+    signed_json = sign_json(request_json, origin_key, origin_name)

    authorization_headers = []

@@ -155,12 +145,10 @@ def request_json(method, origin_name, origin_key, destination, path, content):
    dest = lookup(destination, path)
    print ("Requesting %s" % dest, file=sys.stderr)

-    result = requests.request(
-        method=method,
-        url=dest,
+    result = requests.get(
+        dest,
        headers={"Authorization": authorization_headers[0]},
        verify=False,
-        data=content,
    )
    sys.stderr.write("Status Code: %d\n" % (result.status_code,))
    return result.json()
@@ -198,17 +186,6 @@ def main():
             "connect appropriately.",
    )

-    parser.add_argument(
-        "-X", "--method",
-        help="HTTP method to use for the request. Defaults to GET if --data is"
-             "unspecified, POST if it is."
-    )
-
-    parser.add_argument(
-        "--body",
-        help="Data to send as the body of the HTTP request"
-    )
-
    parser.add_argument(
        "path",
        help="request path. We will add '/_matrix/federation/v1/' to this."
@@ -222,11 +199,8 @@ def main():
    with open(args.signing_key_path) as f:
        key = read_signing_keys(f)[0]

-    result = request_json(
-        args.method,
-        args.server_name, key, args.destination,
-        "/_matrix/federation/v1/" + args.path,
-        content=args.body,
+    result = get_json(
+        args.server_name, key, args.destination, "/_matrix/federation/v1/" + args.path
    )

    json.dump(result, sys.stdout)
--- a/scripts/move_remote_media_to_new_store.py
+++ b/scripts/move_remote_media_to_new_store.py
@@ -1,133 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright 2017 New Vector 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.
-
-"""
-Moves a list of remote media from one media store to another.
-
-The input should be a list of media files to be moved, one per line. Each line
-should be formatted::
-
-    <origin server>|<file id>
-
-This can be extracted from postgres with::
-
-    psql --tuples-only -A -c "select media_origin, filesystem_id from
-        matrix.remote_media_cache where ..."
-
-To use, pipe the above into::
-
-    PYTHON_PATH=. ./scripts/move_remote_media_to_new_store.py <source repo> <dest repo>
-"""
-
-from __future__ import print_function
-
-import argparse
-import logging
-
-import sys
-
-import os
-
-import shutil
-
-from synapse.rest.media.v1.filepath import MediaFilePaths
-
-logger = logging.getLogger()
-
-
-def main(src_repo, dest_repo):
-    src_paths = MediaFilePaths(src_repo)
-    dest_paths = MediaFilePaths(dest_repo)
-    for line in sys.stdin:
-        line = line.strip()
-        parts = line.split('|')
-        if len(parts) != 2:
-            print("Unable to parse input line %s" % line, file=sys.stderr)
-            exit(1)
-
-        move_media(parts[0], parts[1], src_paths, dest_paths)
-
-
-def move_media(origin_server, file_id, src_paths, dest_paths):
-    """Move the given file, and any thumbnails, to the dest repo
-
-    Args:
-        origin_server (str):
-        file_id (str):
-        src_paths (MediaFilePaths):
-        dest_paths (MediaFilePaths):
-    """
-    logger.info("%s/%s", origin_server, file_id)
-
-    # check that the original exists
-    original_file = src_paths.remote_media_filepath(origin_server, file_id)
-    if not os.path.exists(original_file):
-        logger.warn(
-            "Original for %s/%s (%s) does not exist",
-            origin_server, file_id, original_file,
-        )
-    else:
-        mkdir_and_move(
-            original_file,
-            dest_paths.remote_media_filepath(origin_server, file_id),
-        )
-
-    # now look for thumbnails
-    original_thumb_dir = src_paths.remote_media_thumbnail_dir(
-        origin_server, file_id,
-    )
-    if not os.path.exists(original_thumb_dir):
-        return
-
-    mkdir_and_move(
-        original_thumb_dir,
-        dest_paths.remote_media_thumbnail_dir(origin_server, file_id)
-    )
-
-
-def mkdir_and_move(original_file, dest_file):
-    dirname = os.path.dirname(dest_file)
-    if not os.path.exists(dirname):
-        logger.debug("mkdir %s", dirname)
-        os.makedirs(dirname)
-    logger.debug("mv %s %s", original_file, dest_file)
-    shutil.move(original_file, dest_file)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description=__doc__,
-        formatter_class = argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument(
-        "-v", action='store_true', help='enable debug logging')
-    parser.add_argument(
-        "src_repo",
-        help="Path to source content repo",
-    )
-    parser.add_argument(
-        "dest_repo",
-        help="Path to source content repo",
-    )
-    args = parser.parse_args()
-
-    logging_config = {
-        "level": logging.DEBUG if args.v else logging.INFO,
-        "format": "%(asctime)s - %(name)s - %(lineno)d - %(levelname)s - %(message)s"
-    }
-    logging.basicConfig(**logging_config)
-
-    main(args.src_repo, args.dest_repo)
--- a/scripts/synapse_port_db
+++ b/scripts/synapse_port_db
@@ -43,13 +43,6 @@ BOOLEAN_COLUMNS = {
    "device_lists_outbound_pokes": ["sent"],
    "users_who_share_rooms": ["share_private"],
    "groups": ["is_public"],
-    "group_rooms": ["is_public"],
-    "group_users": ["is_public", "is_admin"],
-    "group_summary_rooms": ["is_public"],
-    "group_room_categories": ["is_public"],
-    "group_summary_users": ["is_public"],
-    "group_roles": ["is_public"],
-    "local_group_membership": ["is_publicised", "is_admin"],
 }


--- a/scripts/sync_room_to_group.pl
+++ b/scripts/sync_room_to_group.pl
@@ -1,45 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-use warnings;
-
-use JSON::XS;
-use LWP::UserAgent;
-use URI::Escape;
-
-if (@ARGV < 4) {
-    die "usage: $0 <homeserver url> <access_token> <room_id|room_alias> <group_id>\n";
-}
-
-my ($hs, $access_token, $room_id, $group_id) = @ARGV;
-my $ua = LWP::UserAgent->new();
-$ua->timeout(10);
-
-if ($room_id =~ /^#/) {
-    $room_id = uri_escape($room_id);
-    $room_id = decode_json($ua->get("${hs}/_matrix/client/r0/directory/room/${room_id}?access_token=${access_token}")->decoded_content)->{room_id};
-}
-
-my $room_users  = [ keys %{decode_json($ua->get("${hs}/_matrix/client/r0/rooms/${room_id}/joined_members?access_token=${access_token}")->decoded_content)->{joined}} ];
-my $group_users = [
-    (map { $_->{user_id} } @{decode_json($ua->get("${hs}/_matrix/client/unstable/groups/${group_id}/users?access_token=${access_token}" )->decoded_content)->{chunk}}),
-    (map { $_->{user_id} } @{decode_json($ua->get("${hs}/_matrix/client/unstable/groups/${group_id}/invited_users?access_token=${access_token}" )->decoded_content)->{chunk}}),
-];
-
-die "refusing to sync from empty room" unless (@$room_users);
-die "refusing to sync to empty group" unless (@$group_users);
-
-my $diff = {};
-foreach my $user (@$room_users) { $diff->{$user}++ }
-foreach my $user (@$group_users) { $diff->{$user}-- }
-
-foreach my $user (keys %$diff) {
-    if ($diff->{$user} == 1) {
-        warn "inviting $user";
-        print STDERR $ua->put("${hs}/_matrix/client/unstable/groups/${group_id}/admin/users/invite/${user}?access_token=${access_token}", Content=>'{}')->status_line."\n";
-    }
-    elsif ($diff->{$user} == -1) {
-        warn "removing $user";
-        print STDERR $ua->put("${hs}/_matrix/client/unstable/groups/${group_id}/admin/users/remove/${user}?access_token=${access_token}", Content=>'{}')->status_line."\n";
-    }
-}
--- a/synapse/init.py
+++ b/synapse/init.py
@@ -16,4 +16,4 @@
 """ This is a reference implementation of a Matrix home server.
 """

-__version__ = "0.27.2"
+__version__ = "0.24.1"
--- a/synapse/api/auth.py
+++ b/synapse/api/auth.py
@@ -270,11 +270,7 @@ class Auth(object):
            rights (str): The operation being performed; the access token must
                allow this.
        Returns:
-            Deferred[dict]: dict that includes:
-               `user` (UserID)
-               `is_guest` (bool)
-               `token_id` (int|None): access token id. May be None if guest
-               `device_id` (str|None): device corresponding to access token
+            dict : dict that includes the user and the ID of their access token.
        Raises:
            AuthError if no user by that token exists or the token is invalid.
        """
--- a/synapse/api/errors.py
+++ b/synapse/api/errors.py
@@ -46,7 +46,6 @@ class Codes(object):
    THREEPID_AUTH_FAILED = "M_THREEPID_AUTH_FAILED"
    THREEPID_IN_USE = "M_THREEPID_IN_USE"
    THREEPID_NOT_FOUND = "M_THREEPID_NOT_FOUND"
-    THREEPID_DENIED = "M_THREEPID_DENIED"
    INVALID_USERNAME = "M_INVALID_USERNAME"
    SERVER_NOT_TRUSTED = "M_SERVER_NOT_TRUSTED"

@@ -141,48 +140,6 @@ class RegistrationError(SynapseError):
    pass


-class FederationDeniedError(SynapseError):
-    """An error raised when the server tries to federate with a server which
-    is not on its federation whitelist.
-
-    Attributes:
-        destination (str): The destination which has been denied
-    """
-
-    def __init__(self, destination):
-        """Raised by federation client or server to indicate that we are
-        are deliberately not attempting to contact a given server because it is
-        not on our federation whitelist.
-
-        Args:
-            destination (str): the domain in question
-        """
-
-        self.destination = destination
-
-        super(FederationDeniedError, self).__init__(
-            code=403,
-            msg="Federation denied with %s." % (self.destination,),
-            errcode=Codes.FORBIDDEN,
-        )
-
-
-class InteractiveAuthIncompleteError(Exception):
-    """An error raised when UI auth is not yet complete
-
-    (This indicates we should return a 401 with 'result' as the body)
-
-    Attributes:
-        result (dict): the server response to the request, which should be
-            passed back to the client
-    """
-    def __init__(self, result):
-        super(InteractiveAuthIncompleteError, self).__init__(
-            "Interactive auth not yet complete",
-        )
-        self.result = result
-
-
 class UnrecognizedRequestError(SynapseError):
    """An error indicating we don't understand the request you're trying to make"""
    def __init__(self, *args, **kwargs):
--- a/synapse/api/filtering.py
+++ b/synapse/api/filtering.py
@@ -17,7 +17,7 @@ from synapse.storage.presence import UserPresenceState
 from synapse.types import UserID, RoomID
 from twisted.internet import defer

-import simplejson as json
+import ujson as json
 import jsonschema
 from jsonschema import FormatChecker

--- a/synapse/app/_base.py
+++ b/synapse/app/_base.py
@@ -25,9 +25,7 @@ except Exception:
 from daemonize import Daemonize
 from synapse.util import PreserveLoggingContext
 from synapse.util.rlimit import change_resource_limit
-from twisted.internet import error, reactor
-
-logger = logging.getLogger(__name__)
+from twisted.internet import reactor


 def start_worker_reactor(appname, config):
@@ -122,57 +120,3 @@ def quit_with_error(error_string):
        sys.stderr.write(" %s\n" % (line.rstrip(),))
    sys.stderr.write("*" * line_length + '\n')
    sys.exit(1)
-
-
-def listen_tcp(bind_addresses, port, factory, backlog=50):
-    """
-    Create a TCP socket for a port and several addresses
-    """
-    for address in bind_addresses:
-        try:
-            reactor.listenTCP(
-                port,
-                factory,
-                backlog,
-                address
-            )
-        except error.CannotListenError as e:
-            check_bind_error(e, address, bind_addresses)
-
-
-def listen_ssl(bind_addresses, port, factory, context_factory, backlog=50):
-    """
-    Create an SSL socket for a port and several addresses
-    """
-    for address in bind_addresses:
-        try:
-            reactor.listenSSL(
-                port,
-                factory,
-                context_factory,
-                backlog,
-                address
-            )
-        except error.CannotListenError as e:
-            check_bind_error(e, address, bind_addresses)
-
-
-def check_bind_error(e, address, bind_addresses):
-    """
-    This method checks an exception occurred while binding on 0.0.0.0.
-    If :: is specified in the bind addresses a warning is shown.
-    The exception is still raised otherwise.
-
-    Binding on both 0.0.0.0 and :: causes an exception on Linux and macOS
-    because :: binds on both IPv4 and IPv6 (as per RFC 3493).
-    When binding on 0.0.0.0 after :: this can safely be ignored.
-
-    Args:
-        e (Exception): Exception that was caught.
-        address (str): Address on which binding was attempted.
-        bind_addresses (list): Addresses on which the service listens.
-    """
-    if address == '0.0.0.0' and '::' in bind_addresses:
-        logger.warn('Failed to listen on 0.0.0.0, continuing because listening on [::]')
-    else:
-        raise e
--- a/synapse/app/appservice.py
+++ b/synapse/app/appservice.py
@@ -49,6 +49,19 @@ class AppserviceSlaveStore(


 class AppserviceServer(HomeServer):
+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+
    def setup(self):
        logger.info("Setting up.")
        self.datastore = AppserviceSlaveStore(self.get_db_conn(), self)
@@ -66,16 +79,17 @@ class AppserviceServer(HomeServer):

        root_resource = create_resource_tree(resources, Resource())

-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
+        for address in bind_addresses:
+            reactor.listenTCP(
+                port,
+                SynapseSite(
+                    "synapse.access.http.%s" % (site_tag,),
+                    site_tag,
+                    listener_config,
+                    root_resource,
+                ),
+                interface=address
            )
-        )

        logger.info("Synapse appservice now listening on port %d", port)

@@ -84,15 +98,18 @@ class AppserviceServer(HomeServer):
            if listener["type"] == "http":
                self._listen_http(listener)
            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
+                bind_addresses = listener["bind_addresses"]
+
+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
                    )
-                )
            else:
                logger.warn("Unrecognized listener type: %s", listener["type"])

--- a/synapse/app/client_reader.py
+++ b/synapse/app/client_reader.py
@@ -64,6 +64,19 @@ class ClientReaderSlavedStore(


 class ClientReaderServer(HomeServer):
+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+
    def setup(self):
        logger.info("Setting up.")
        self.datastore = ClientReaderSlavedStore(self.get_db_conn(), self)
@@ -90,16 +103,17 @@ class ClientReaderServer(HomeServer):

        root_resource = create_resource_tree(resources, Resource())

-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
+        for address in bind_addresses:
+            reactor.listenTCP(
+                port,
+                SynapseSite(
+                    "synapse.access.http.%s" % (site_tag,),
+                    site_tag,
+                    listener_config,
+                    root_resource,
+                ),
+                interface=address
            )
-        )

        logger.info("Synapse client reader now listening on port %d", port)

@@ -108,16 +122,18 @@ class ClientReaderServer(HomeServer):
            if listener["type"] == "http":
                self._listen_http(listener)
            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
-                    )
-                )
+                bind_addresses = listener["bind_addresses"]

+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
+                    )
            else:
                logger.warn("Unrecognized listener type: %s", listener["type"])

@@ -156,6 +172,7 @@ def start(config_options):
    )

    ss.setup()
+    ss.get_handlers()
    ss.start_listening(config.worker_listeners)

    def start():
--- a/synapse/app/event_creator.py
+++ b/synapse/app/event_creator.py
@@ -1,189 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright 2018 New Vector 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
-import sys
-
-import synapse
-from synapse import events
-from synapse.app import _base
-from synapse.config._base import ConfigError
-from synapse.config.homeserver import HomeServerConfig
-from synapse.config.logger import setup_logging
-from synapse.crypto import context_factory
-from synapse.http.server import JsonResource
-from synapse.http.site import SynapseSite
-from synapse.metrics.resource import METRICS_PREFIX, MetricsResource
-from synapse.replication.slave.storage._base import BaseSlavedStore
-from synapse.replication.slave.storage.account_data import SlavedAccountDataStore
-from synapse.replication.slave.storage.appservice import SlavedApplicationServiceStore
-from synapse.replication.slave.storage.client_ips import SlavedClientIpStore
-from synapse.replication.slave.storage.devices import SlavedDeviceStore
-from synapse.replication.slave.storage.directory import DirectoryStore
-from synapse.replication.slave.storage.events import SlavedEventStore
-from synapse.replication.slave.storage.profile import SlavedProfileStore
-from synapse.replication.slave.storage.push_rule import SlavedPushRuleStore
-from synapse.replication.slave.storage.pushers import SlavedPusherStore
-from synapse.replication.slave.storage.receipts import SlavedReceiptsStore
-from synapse.replication.slave.storage.registration import SlavedRegistrationStore
-from synapse.replication.slave.storage.room import RoomStore
-from synapse.replication.slave.storage.transactions import TransactionStore
-from synapse.replication.tcp.client import ReplicationClientHandler
-from synapse.rest.client.v1.room import (
-    RoomSendEventRestServlet, RoomMembershipRestServlet, RoomStateEventRestServlet,
-    JoinRoomAliasServlet,
-)
-from synapse.server import HomeServer
-from synapse.storage.engines import create_engine
-from synapse.util.httpresourcetree import create_resource_tree
-from synapse.util.logcontext import LoggingContext
-from synapse.util.manhole import manhole
-from synapse.util.versionstring import get_version_string
-from twisted.internet import reactor
-from twisted.web.resource import Resource
-
-logger = logging.getLogger("synapse.app.event_creator")
-
-
-class EventCreatorSlavedStore(
-    DirectoryStore,
-    TransactionStore,
-    SlavedProfileStore,
-    SlavedAccountDataStore,
-    SlavedPusherStore,
-    SlavedReceiptsStore,
-    SlavedPushRuleStore,
-    SlavedDeviceStore,
-    SlavedClientIpStore,
-    SlavedApplicationServiceStore,
-    SlavedEventStore,
-    SlavedRegistrationStore,
-    RoomStore,
-    BaseSlavedStore,
-):
-    pass
-
-
-class EventCreatorServer(HomeServer):
-    def setup(self):
-        logger.info("Setting up.")
-        self.datastore = EventCreatorSlavedStore(self.get_db_conn(), self)
-        logger.info("Finished setting up.")
-
-    def _listen_http(self, listener_config):
-        port = listener_config["port"]
-        bind_addresses = listener_config["bind_addresses"]
-        site_tag = listener_config.get("tag", port)
-        resources = {}
-        for res in listener_config["resources"]:
-            for name in res["names"]:
-                if name == "metrics":
-                    resources[METRICS_PREFIX] = MetricsResource(self)
-                elif name == "client":
-                    resource = JsonResource(self, canonical_json=False)
-                    RoomSendEventRestServlet(self).register(resource)
-                    RoomMembershipRestServlet(self).register(resource)
-                    RoomStateEventRestServlet(self).register(resource)
-                    JoinRoomAliasServlet(self).register(resource)
-                    resources.update({
-                        "/_matrix/client/r0": resource,
-                        "/_matrix/client/unstable": resource,
-                        "/_matrix/client/v2_alpha": resource,
-                        "/_matrix/client/api/v1": resource,
-                    })
-
-        root_resource = create_resource_tree(resources, Resource())
-
-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
-            )
-        )
-
-        logger.info("Synapse event creator now listening on port %d", port)
-
-    def start_listening(self, listeners):
-        for listener in listeners:
-            if listener["type"] == "http":
-                self._listen_http(listener)
-            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
-                    )
-                )
-            else:
-                logger.warn("Unrecognized listener type: %s", listener["type"])
-
-        self.get_tcp_replication().start_replication(self)
-
-    def build_tcp_replication(self):
-        return ReplicationClientHandler(self.get_datastore())
-
-
-def start(config_options):
-    try:
-        config = HomeServerConfig.load_config(
-            "Synapse event creator", config_options
-        )
-    except ConfigError as e:
-        sys.stderr.write("\n" + e.message + "\n")
-        sys.exit(1)
-
-    assert config.worker_app == "synapse.app.event_creator"
-
-    assert config.worker_replication_http_port is not None
-
-    setup_logging(config, use_worker_options=True)
-
-    events.USE_FROZEN_DICTS = config.use_frozen_dicts
-
-    database_engine = create_engine(config.database_config)
-
-    tls_server_context_factory = context_factory.ServerContextFactory(config)
-
-    ss = EventCreatorServer(
-        config.server_name,
-        db_config=config.database_config,
-        tls_server_context_factory=tls_server_context_factory,
-        config=config,
-        version_string="Synapse/" + get_version_string(synapse),
-        database_engine=database_engine,
-    )
-
-    ss.setup()
-    ss.start_listening(config.worker_listeners)
-
-    def start():
-        ss.get_state_handler().start_caching()
-        ss.get_datastore().start_profiling()
-
-    reactor.callWhenRunning(start)
-
-    _base.start_worker_reactor("synapse-event-creator", config)
-
-
-if __name__ == '__main__':
-    with LoggingContext("main"):
-        start(sys.argv[1:])
--- a/synapse/app/federation_reader.py
+++ b/synapse/app/federation_reader.py
@@ -58,6 +58,19 @@ class FederationReaderSlavedStore(


 class FederationReaderServer(HomeServer):
+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+
    def setup(self):
        logger.info("Setting up.")
        self.datastore = FederationReaderSlavedStore(self.get_db_conn(), self)
@@ -79,16 +92,17 @@ class FederationReaderServer(HomeServer):

        root_resource = create_resource_tree(resources, Resource())

-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
+        for address in bind_addresses:
+            reactor.listenTCP(
+                port,
+                SynapseSite(
+                    "synapse.access.http.%s" % (site_tag,),
+                    site_tag,
+                    listener_config,
+                    root_resource,
+                ),
+                interface=address
            )
-        )

        logger.info("Synapse federation reader now listening on port %d", port)

@@ -97,15 +111,18 @@ class FederationReaderServer(HomeServer):
            if listener["type"] == "http":
                self._listen_http(listener)
            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
+                bind_addresses = listener["bind_addresses"]
+
+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
                    )
-                )
            else:
                logger.warn("Unrecognized listener type: %s", listener["type"])

@@ -144,6 +161,7 @@ def start(config_options):
    )

    ss.setup()
+    ss.get_handlers()
    ss.start_listening(config.worker_listeners)

    def start():
--- a/synapse/app/federation_sender.py
+++ b/synapse/app/federation_sender.py
@@ -76,6 +76,19 @@ class FederationSenderSlaveStore(


 class FederationSenderServer(HomeServer):
+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+
    def setup(self):
        logger.info("Setting up.")
        self.datastore = FederationSenderSlaveStore(self.get_db_conn(), self)
@@ -93,16 +106,17 @@ class FederationSenderServer(HomeServer):

        root_resource = create_resource_tree(resources, Resource())

-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
+        for address in bind_addresses:
+            reactor.listenTCP(
+                port,
+                SynapseSite(
+                    "synapse.access.http.%s" % (site_tag,),
+                    site_tag,
+                    listener_config,
+                    root_resource,
+                ),
+                interface=address
            )
-        )

        logger.info("Synapse federation_sender now listening on port %d", port)

@@ -111,15 +125,18 @@ class FederationSenderServer(HomeServer):
            if listener["type"] == "http":
                self._listen_http(listener)
            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
+                bind_addresses = listener["bind_addresses"]
+
+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
                    )
-                )
            else:
                logger.warn("Unrecognized listener type: %s", listener["type"])

--- a/synapse/app/frontend_proxy.py
+++ b/synapse/app/frontend_proxy.py
@@ -118,6 +118,19 @@ class FrontendProxySlavedStore(


 class FrontendProxyServer(HomeServer):
+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+
    def setup(self):
        logger.info("Setting up.")
        self.datastore = FrontendProxySlavedStore(self.get_db_conn(), self)
@@ -144,16 +157,17 @@ class FrontendProxyServer(HomeServer):

        root_resource = create_resource_tree(resources, Resource())

-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
+        for address in bind_addresses:
+            reactor.listenTCP(
+                port,
+                SynapseSite(
+                    "synapse.access.http.%s" % (site_tag,),
+                    site_tag,
+                    listener_config,
+                    root_resource,
+                ),
+                interface=address
            )
-        )

        logger.info("Synapse client reader now listening on port %d", port)

@@ -162,15 +176,18 @@ class FrontendProxyServer(HomeServer):
            if listener["type"] == "http":
                self._listen_http(listener)
            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
+                bind_addresses = listener["bind_addresses"]
+
+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
                    )
-                )
            else:
                logger.warn("Unrecognized listener type: %s", listener["type"])

@@ -211,6 +228,7 @@ def start(config_options):
    )

    ss.setup()
+    ss.get_handlers()
    ss.start_listening(config.worker_listeners)

    def start():
--- a/synapse/app/homeserver.py
+++ b/synapse/app/homeserver.py
@@ -25,7 +25,7 @@ from synapse.api.urls import CONTENT_REPO_PREFIX, FEDERATION_PREFIX, \
    LEGACY_MEDIA_PREFIX, MEDIA_PREFIX, SERVER_KEY_PREFIX, SERVER_KEY_V2_PREFIX, \
    STATIC_PREFIX, WEB_CLIENT_PREFIX
 from synapse.app import _base
-from synapse.app._base import quit_with_error, listen_ssl, listen_tcp
+from synapse.app._base import quit_with_error
 from synapse.config._base import ConfigError
 from synapse.config.homeserver import HomeServerConfig
 from synapse.crypto import context_factory
@@ -38,12 +38,12 @@ from synapse.metrics import register_memory_metrics
 from synapse.metrics.resource import METRICS_PREFIX, MetricsResource
 from synapse.python_dependencies import CONDITIONAL_REQUIREMENTS, \
    check_requirements
-from synapse.replication.http import ReplicationRestResource, REPLICATION_PREFIX
 from synapse.replication.tcp.resource import ReplicationStreamProtocolFactory
 from synapse.rest import ClientRestResource
 from synapse.rest.key.v1.server_key_resource import LocalKey
 from synapse.rest.key.v2 import KeyApiV2Resource
 from synapse.rest.media.v0.content_repository import ContentRepoResource
+from synapse.rest.media.v1.media_repository import MediaRepositoryResource
 from synapse.server import HomeServer
 from synapse.storage import are_all_users_on_domain
 from synapse.storage.engines import IncorrectDatabaseSetup, create_engine
@@ -131,29 +131,30 @@ class SynapseHomeServer(HomeServer):
        root_resource = create_resource_tree(resources, root_resource)

        if tls:
-            listen_ssl(
-                bind_addresses,
-                port,
-                SynapseSite(
-                    "synapse.access.https.%s" % (site_tag,),
-                    site_tag,
-                    listener_config,
-                    root_resource,
-                ),
-                self.tls_server_context_factory,
-            )
-
-        else:
-            listen_tcp(
-                bind_addresses,
-                port,
-                SynapseSite(
-                    "synapse.access.http.%s" % (site_tag,),
-                    site_tag,
-                    listener_config,
-                    root_resource,
+            for address in bind_addresses:
+                reactor.listenSSL(
+                    port,
+                    SynapseSite(
+                        "synapse.access.https.%s" % (site_tag,),
+                        site_tag,
+                        listener_config,
+                        root_resource,
+                    ),
+                    self.tls_server_context_factory,
+                    interface=address
+                )
+        else:
+            for address in bind_addresses:
+                reactor.listenTCP(
+                    port,
+                    SynapseSite(
+                        "synapse.access.http.%s" % (site_tag,),
+                        site_tag,
+                        listener_config,
+                        root_resource,
+                    ),
+                    interface=address
                )
-            )
        logger.info("Synapse now listening on port %d", port)

    def _configure_named_resource(self, name, compress=False):
@@ -194,19 +195,14 @@ class SynapseHomeServer(HomeServer):
            })

        if name in ["media", "federation", "client"]:
-            if self.get_config().enable_media_repo:
-                media_repo = self.get_media_repository_resource()
-                resources.update({
-                    MEDIA_PREFIX: media_repo,
-                    LEGACY_MEDIA_PREFIX: media_repo,
-                    CONTENT_REPO_PREFIX: ContentRepoResource(
-                        self, self.config.uploads_path
-                    ),
-                })
-            elif name == "media":
-                raise ConfigError(
-                    "'media' resource conflicts with enable_media_repo=False",
-                )
+            media_repo = MediaRepositoryResource(self)
+            resources.update({
+                MEDIA_PREFIX: media_repo,
+                LEGACY_MEDIA_PREFIX: media_repo,
+                CONTENT_REPO_PREFIX: ContentRepoResource(
+                    self, self.config.uploads_path
+                ),
+            })

        if name in ["keys", "federation"]:
            resources.update({
@@ -220,9 +216,6 @@ class SynapseHomeServer(HomeServer):
        if name == "metrics" and self.get_config().enable_metrics:
            resources[METRICS_PREFIX] = MetricsResource(self)

-        if name == "replication":
-            resources[REPLICATION_PREFIX] = ReplicationRestResource(self)
-
        return resources

    def start_listening(self):
@@ -232,15 +225,18 @@ class SynapseHomeServer(HomeServer):
            if listener["type"] == "http":
                self._listener_http(config, listener)
            elif listener["type"] == "manhole":
-                listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
+                bind_addresses = listener["bind_addresses"]
+
+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
                    )
-                )
            elif listener["type"] == "replication":
                bind_addresses = listener["bind_addresses"]
                for address in bind_addresses:
@@ -270,6 +266,19 @@ class SynapseHomeServer(HomeServer):
        except IncorrectDatabaseSetup as e:
            quit_with_error(e.message)

+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+

 def setup(config_options):
    """
@@ -348,7 +357,7 @@ def setup(config_options):
        hs.get_state_handler().start_caching()
        hs.get_datastore().start_profiling()
        hs.get_datastore().start_doing_background_updates()
-        hs.get_federation_client().start_get_pdu_cache()
+        hs.get_replication_layer().start_get_pdu_cache()

        register_memory_metrics(hs)

--- a/synapse/app/media_repository.py
+++ b/synapse/app/media_repository.py
@@ -35,6 +35,7 @@ from synapse.replication.slave.storage.registration import SlavedRegistrationSto
 from synapse.replication.slave.storage.transactions import TransactionStore
 from synapse.replication.tcp.client import ReplicationClientHandler
 from synapse.rest.media.v0.content_repository import ContentRepoResource
+from synapse.rest.media.v1.media_repository import MediaRepositoryResource
 from synapse.server import HomeServer
 from synapse.storage.engines import create_engine
 from synapse.storage.media_repository import MediaRepositoryStore
@@ -60,6 +61,19 @@ class MediaRepositorySlavedStore(


 class MediaRepositoryServer(HomeServer):
+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+
    def setup(self):
        logger.info("Setting up.")
        self.datastore = MediaRepositorySlavedStore(self.get_db_conn(), self)
@@ -75,7 +89,7 @@ class MediaRepositoryServer(HomeServer):
                if name == "metrics":
                    resources[METRICS_PREFIX] = MetricsResource(self)
                elif name == "media":
-                    media_repo = self.get_media_repository_resource()
+                    media_repo = MediaRepositoryResource(self)
                    resources.update({
                        MEDIA_PREFIX: media_repo,
                        LEGACY_MEDIA_PREFIX: media_repo,
@@ -86,16 +100,17 @@ class MediaRepositoryServer(HomeServer):

        root_resource = create_resource_tree(resources, Resource())

-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
+        for address in bind_addresses:
+            reactor.listenTCP(
+                port,
+                SynapseSite(
+                    "synapse.access.http.%s" % (site_tag,),
+                    site_tag,
+                    listener_config,
+                    root_resource,
+                ),
+                interface=address
            )
-        )

        logger.info("Synapse media repository now listening on port %d", port)

@@ -104,15 +119,18 @@ class MediaRepositoryServer(HomeServer):
            if listener["type"] == "http":
                self._listen_http(listener)
            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
+                bind_addresses = listener["bind_addresses"]
+
+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
                    )
-                )
            else:
                logger.warn("Unrecognized listener type: %s", listener["type"])

@@ -133,13 +151,6 @@ def start(config_options):

    assert config.worker_app == "synapse.app.media_repository"

-    if config.enable_media_repo:
-        _base.quit_with_error(
-            "enable_media_repo must be disabled in the main synapse process\n"
-            "before the media repo can be run in a separate worker.\n"
-            "Please add ``enable_media_repo: false`` to the main config\n"
-        )
-
    setup_logging(config, use_worker_options=True)

    events.USE_FROZEN_DICTS = config.use_frozen_dicts
@@ -158,6 +169,7 @@ def start(config_options):
    )

    ss.setup()
+    ss.get_handlers()
    ss.start_listening(config.worker_listeners)

    def start():
--- a/synapse/app/pusher.py
+++ b/synapse/app/pusher.py
@@ -32,6 +32,7 @@ from synapse.replication.tcp.client import ReplicationClientHandler
 from synapse.server import HomeServer
 from synapse.storage import DataStore
 from synapse.storage.engines import create_engine
+from synapse.storage.roommember import RoomMemberStore
 from synapse.util.httpresourcetree import create_resource_tree
 from synapse.util.logcontext import LoggingContext, preserve_fn
 from synapse.util.manhole import manhole
@@ -74,8 +75,25 @@ class PusherSlaveStore(
        DataStore.get_profile_displayname.__func__
    )

+    who_forgot_in_room = (
+        RoomMemberStore.__dict__["who_forgot_in_room"]
+    )
+

 class PusherServer(HomeServer):
+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+
    def setup(self):
        logger.info("Setting up.")
        self.datastore = PusherSlaveStore(self.get_db_conn(), self)
@@ -96,16 +114,17 @@ class PusherServer(HomeServer):

        root_resource = create_resource_tree(resources, Resource())

-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
+        for address in bind_addresses:
+            reactor.listenTCP(
+                port,
+                SynapseSite(
+                    "synapse.access.http.%s" % (site_tag,),
+                    site_tag,
+                    listener_config,
+                    root_resource,
+                ),
+                interface=address
            )
-        )

        logger.info("Synapse pusher now listening on port %d", port)

@@ -114,15 +133,18 @@ class PusherServer(HomeServer):
            if listener["type"] == "http":
                self._listen_http(listener)
            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
+                bind_addresses = listener["bind_addresses"]
+
+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
                    )
-                )
            else:
                logger.warn("Unrecognized listener type: %s", listener["type"])

--- a/synapse/app/synchrotron.py
+++ b/synapse/app/synchrotron.py
@@ -62,6 +62,8 @@ logger = logging.getLogger("synapse.app.synchrotron")


 class SynchrotronSlavedStore(
+    SlavedPushRuleStore,
+    SlavedEventStore,
    SlavedReceiptsStore,
    SlavedAccountDataStore,
    SlavedApplicationServiceStore,
@@ -71,12 +73,14 @@ class SynchrotronSlavedStore(
    SlavedGroupServerStore,
    SlavedDeviceInboxStore,
    SlavedDeviceStore,
-    SlavedPushRuleStore,
-    SlavedEventStore,
    SlavedClientIpStore,
    RoomStore,
    BaseSlavedStore,
 ):
+    who_forgot_in_room = (
+        RoomMemberStore.__dict__["who_forgot_in_room"]
+    )
+
    did_forget = (
        RoomMemberStore.__dict__["did_forget"]
    )
@@ -242,6 +246,19 @@ class SynchrotronApplicationService(object):


 class SynchrotronServer(HomeServer):
+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+
    def setup(self):
        logger.info("Setting up.")
        self.datastore = SynchrotronSlavedStore(self.get_db_conn(), self)
@@ -271,16 +288,17 @@ class SynchrotronServer(HomeServer):

        root_resource = create_resource_tree(resources, Resource())

-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
+        for address in bind_addresses:
+            reactor.listenTCP(
+                port,
+                SynapseSite(
+                    "synapse.access.http.%s" % (site_tag,),
+                    site_tag,
+                    listener_config,
+                    root_resource,
+                ),
+                interface=address
            )
-        )

        logger.info("Synapse synchrotron now listening on port %d", port)

@@ -289,15 +307,18 @@ class SynchrotronServer(HomeServer):
            if listener["type"] == "http":
                self._listen_http(listener)
            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
+                bind_addresses = listener["bind_addresses"]
+
+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
                    )
-                )
            else:
                logger.warn("Unrecognized listener type: %s", listener["type"])

@@ -319,10 +340,11 @@ class SyncReplicationHandler(ReplicationClientHandler):

        self.store = hs.get_datastore()
        self.typing_handler = hs.get_typing_handler()
-        # NB this is a SynchrotronPresence, not a normal PresenceHandler
        self.presence_handler = hs.get_presence_handler()
        self.notifier = hs.get_notifier()

+        self.presence_handler.sync_callback = self.send_user_sync
+
    def on_rdata(self, stream_name, token, rows):
        super(SyncReplicationHandler, self).on_rdata(stream_name, token, rows)

--- a/synapse/app/synctl.py
+++ b/synapse/app/synctl.py
@@ -184,9 +184,6 @@ def main():
        worker_configfiles.append(worker_configfile)

    if options.all_processes:
-        # To start the main synapse with -a you need to add a worker file
-        # with worker_app == "synapse.app.homeserver"
-        start_stop_synapse = False
        worker_configdir = options.all_processes
        if not os.path.isdir(worker_configdir):
            write(
@@ -203,29 +200,11 @@ def main():
        with open(worker_configfile) as stream:
            worker_config = yaml.load(stream)
        worker_app = worker_config["worker_app"]
-        if worker_app == "synapse.app.homeserver":
-            # We need to special case all of this to pick up options that may
-            # be set in the main config file or in this worker config file.
-            worker_pidfile = (
-                worker_config.get("pid_file")
-                or pidfile
-            )
-            worker_cache_factor = worker_config.get("synctl_cache_factor") or cache_factor
-            daemonize = worker_config.get("daemonize") or config.get("daemonize")
-            assert daemonize, "Main process must have daemonize set to true"
-
-            # The master process doesn't support using worker_* config.
-            for key in worker_config:
-                if key == "worker_app":  # But we allow worker_app
-                    continue
-                assert not key.startswith("worker_"), \
-                    "Main process cannot use worker_* config"
-        else:
-            worker_pidfile = worker_config["worker_pid_file"]
-            worker_daemonize = worker_config["worker_daemonize"]
-            assert worker_daemonize, "In config %r: expected '%s' to be True" % (
-                worker_configfile, "worker_daemonize")
-            worker_cache_factor = worker_config.get("synctl_cache_factor")
+        worker_pidfile = worker_config["worker_pid_file"]
+        worker_daemonize = worker_config["worker_daemonize"]
+        assert worker_daemonize, "In config %r: expected '%s' to be True" % (
+            worker_configfile, "worker_daemonize")
+        worker_cache_factor = worker_config.get("synctl_cache_factor")
        workers.append(Worker(
            worker_app, worker_configfile, worker_pidfile, worker_cache_factor,
        ))
--- a/synapse/app/user_dir.py
+++ b/synapse/app/user_dir.py
@@ -92,6 +92,19 @@ class UserDirectorySlaveStore(


 class UserDirectoryServer(HomeServer):
+    def get_db_conn(self, run_new_connection=True):
+        # Any param beginning with cp_ is a parameter for adbapi, and should
+        # not be passed to the database engine.
+        db_params = {
+            k: v for k, v in self.db_config.get("args", {}).items()
+            if not k.startswith("cp_")
+        }
+        db_conn = self.database_engine.module.connect(**db_params)
+
+        if run_new_connection:
+            self.database_engine.on_new_connection(db_conn)
+        return db_conn
+
    def setup(self):
        logger.info("Setting up.")
        self.datastore = UserDirectorySlaveStore(self.get_db_conn(), self)
@@ -118,16 +131,17 @@ class UserDirectoryServer(HomeServer):

        root_resource = create_resource_tree(resources, Resource())

-        _base.listen_tcp(
-            bind_addresses,
-            port,
-            SynapseSite(
-                "synapse.access.http.%s" % (site_tag,),
-                site_tag,
-                listener_config,
-                root_resource,
+        for address in bind_addresses:
+            reactor.listenTCP(
+                port,
+                SynapseSite(
+                    "synapse.access.http.%s" % (site_tag,),
+                    site_tag,
+                    listener_config,
+                    root_resource,
+                ),
+                interface=address
            )
-        )

        logger.info("Synapse user_dir now listening on port %d", port)

@@ -136,15 +150,18 @@ class UserDirectoryServer(HomeServer):
            if listener["type"] == "http":
                self._listen_http(listener)
            elif listener["type"] == "manhole":
-                _base.listen_tcp(
-                    listener["bind_addresses"],
-                    listener["port"],
-                    manhole(
-                        username="matrix",
-                        password="rabbithole",
-                        globals={"hs": self},
+                bind_addresses = listener["bind_addresses"]
+
+                for address in bind_addresses:
+                    reactor.listenTCP(
+                        listener["port"],
+                        manhole(
+                            username="matrix",
+                            password="rabbithole",
+                            globals={"hs": self},
+                        ),
+                        interface=address
                    )
-                )
            else:
                logger.warn("Unrecognized listener type: %s", listener["type"])

--- a/synapse/appservice/init.py
+++ b/synapse/appservice/init.py
@@ -14,7 +14,6 @@
 # limitations under the License.
 from synapse.api.constants import EventTypes
 from synapse.util.caches.descriptors import cachedInlineCallbacks
-from synapse.types import GroupID, get_domain_from_id

 from twisted.internet import defer

@@ -82,13 +81,12 @@ class ApplicationService(object):
    # values.
    NS_LIST = [NS_USERS, NS_ALIASES, NS_ROOMS]

-    def __init__(self, token, hostname, url=None, namespaces=None, hs_token=None,
+    def __init__(self, token, url=None, namespaces=None, hs_token=None,
                 sender=None, id=None, protocols=None, rate_limited=True):
        self.token = token
        self.url = url
        self.hs_token = hs_token
        self.sender = sender
-        self.server_name = hostname
        self.namespaces = self._check_namespaces(namespaces)
        self.id = id

@@ -127,24 +125,6 @@ class ApplicationService(object):
                    raise ValueError(
                        "Expected bool for 'exclusive' in ns '%s'" % ns
                    )
-                group_id = regex_obj.get("group_id")
-                if group_id:
-                    if not isinstance(group_id, str):
-                        raise ValueError(
-                            "Expected string for 'group_id' in ns '%s'" % ns
-                        )
-                    try:
-                        GroupID.from_string(group_id)
-                    except Exception:
-                        raise ValueError(
-                            "Expected valid group ID for 'group_id' in ns '%s'" % ns
-                        )
-
-                    if get_domain_from_id(group_id) != self.server_name:
-                        raise ValueError(
-                            "Expected 'group_id' to be this host in ns '%s'" % ns
-                        )
-
                regex = regex_obj.get("regex")
                if isinstance(regex, basestring):
                    regex_obj["regex"] = re.compile(regex)  # Pre-compile regex
@@ -271,21 +251,6 @@ class ApplicationService(object):
            if regex_obj["exclusive"]
        ]

-    def get_groups_for_user(self, user_id):
-        """Get the groups that this user is associated with by this AS
-
-        Args:
-            user_id (str): The ID of the user.
-
-        Returns:
-            iterable[str]: an iterable that yields group_id strings.
-        """
-        return (
-            regex_obj["group_id"]
-            for regex_obj in self.namespaces[ApplicationService.NS_USERS]
-            if "group_id" in regex_obj and regex_obj["regex"].match(user_id)
-        )
-
    def is_rate_limited(self):
        return self.rate_limited

--- a/synapse/config/appservice.py
+++ b/synapse/config/appservice.py
@@ -154,7 +154,6 @@ def _load_appservice(hostname, as_info, config_filename):
        )
    return ApplicationService(
        token=as_info["as_token"],
-        hostname=hostname,
        url=as_info["url"],
        namespaces=as_info["namespaces"],
        hs_token=as_info["hs_token"],
--- a/synapse/config/homeserver.py
+++ b/synapse/config/homeserver.py
@@ -36,7 +36,6 @@ from .workers import WorkerConfig
 from .push import PushConfig
 from .spam_checker import SpamCheckerConfig
 from .groups import GroupsConfig
-from .user_directory import UserDirectoryConfig


 class HomeServerConfig(TlsConfig, ServerConfig, DatabaseConfig, LoggingConfig,
@@ -45,7 +44,7 @@ class HomeServerConfig(TlsConfig, ServerConfig, DatabaseConfig, LoggingConfig,
                       AppServiceConfig, KeyConfig, SAML2Config, CasConfig,
                       JWTConfig, PasswordConfig, EmailConfig,
                       WorkerConfig, PasswordAuthProviderConfig, PushConfig,
-                       SpamCheckerConfig, GroupsConfig, UserDirectoryConfig,):
+                       SpamCheckerConfig, GroupsConfig,):
    pass


--- a/synapse/config/logger.py
+++ b/synapse/config/logger.py
@@ -28,27 +28,27 @@ DEFAULT_LOG_CONFIG = Template("""
 version: 1

 formatters:
-    precise:
-        format: '%(asctime)s - %(name)s - %(lineno)d - %(levelname)s - \
-%(request)s - %(message)s'
+  precise:
+   format: '%(asctime)s - %(name)s - %(lineno)d - %(levelname)s - %(request)s\
+- %(message)s'

 filters:
-    context:
-        (): synapse.util.logcontext.LoggingContextFilter
-        request: ""
+  context:
+    (): synapse.util.logcontext.LoggingContextFilter
+    request: ""

 handlers:
-    file:
-        class: logging.handlers.RotatingFileHandler
-        formatter: precise
-        filename: ${log_file}
-        maxBytes: 104857600
-        backupCount: 10
-        filters: [context]
-    console:
-        class: logging.StreamHandler
-        formatter: precise
-        filters: [context]
+  file:
+    class: logging.handlers.RotatingFileHandler
+    formatter: precise
+    filename: ${log_file}
+    maxBytes: 104857600
+    backupCount: 10
+    filters: [context]
+  console:
+    class: logging.StreamHandler
+    formatter: precise
+    filters: [context]

 loggers:
    synapse:
@@ -74,10 +74,17 @@ class LoggingConfig(Config):
        self.log_file = self.abspath(config.get("log_file"))

    def default_config(self, config_dir_path, server_name, **kwargs):
+        log_file = self.abspath("homeserver.log")
        log_config = self.abspath(
            os.path.join(config_dir_path, server_name + ".log.config")
        )
        return """
+        # Logging verbosity level. Ignored if log_config is specified.
+        verbose: 0
+
+        # File to write logging to. Ignored if log_config is specified.
+        log_file: "%(log_file)s"
+
        # A yaml python logging config file
        log_config: "%(log_config)s"
        """ % locals()
@@ -116,10 +123,9 @@ class LoggingConfig(Config):
    def generate_files(self, config):
        log_config = config.get("log_config")
        if log_config and not os.path.exists(log_config):
-            log_file = self.abspath("homeserver.log")
            with open(log_config, "wb") as log_config_file:
                log_config_file.write(
-                    DEFAULT_LOG_CONFIG.substitute(log_file=log_file)
+                    DEFAULT_LOG_CONFIG.substitute(log_file=config["log_file"])
                )


@@ -144,9 +150,6 @@ def setup_logging(config, use_worker_options=False):
    )

    if log_config is None:
-        # We don't have a logfile, so fall back to the 'verbosity' param from
-        # the config or cmdline. (Note that we generate a log config for new
-        # installs, so this will be an unusual case)
        level = logging.INFO
        level_for_storage = logging.INFO
        if config.verbosity:
@@ -154,10 +157,11 @@ def setup_logging(config, use_worker_options=False):
            if config.verbosity > 1:
                level_for_storage = logging.DEBUG

+        # FIXME: we need a logging.WARN for a -q quiet option
        logger = logging.getLogger('')
        logger.setLevel(level)

-        logging.getLogger('synapse.storage.SQL').setLevel(level_for_storage)
+        logging.getLogger('synapse.storage').setLevel(level_for_storage)

        formatter = logging.Formatter(log_format)
        if log_file:
--- a/synapse/config/password_auth_providers.py
+++ b/synapse/config/password_auth_providers.py
@@ -29,10 +29,10 @@ class PasswordAuthProviderConfig(Config):
        # param.
        ldap_config = config.get("ldap_config", {})
        if ldap_config.get("enabled", False):
-            providers.append({
+            providers.append[{
                'module': LDAP_PROVIDER,
                'config': ldap_config,
-            })
+            }]

        providers.extend(config.get("password_providers", []))
        for provider in providers:
--- a/synapse/config/push.py
+++ b/synapse/config/push.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 # Copyright 2015, 2016 OpenMarket Ltd
-# Copyright 2017 New Vector Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -19,43 +18,28 @@ from ._base import Config

 class PushConfig(Config):
    def read_config(self, config):
-        push_config = config.get("push", {})
-        self.push_include_content = push_config.get("include_content", True)
+        self.push_redact_content = False

-        # There was a a 'redact_content' setting but mistakenly read from the
-        # 'email'section'. Check for the flag in the 'push' section, and log,
-        # but do not honour it to avoid nasty surprises when people upgrade.
-        if push_config.get("redact_content") is not None:
-            print(
-                "The push.redact_content content option has never worked. "
-                "Please set push.include_content if you want this behaviour"
-            )
-
-        # Now check for the one in the 'email' section and honour it,
-        # with a warning.
        push_config = config.get("email", {})
-        redact_content = push_config.get("redact_content")
-        if redact_content is not None:
-            print(
-                "The 'email.redact_content' option is deprecated: "
-                "please set push.include_content instead"
-            )
-            self.push_include_content = not redact_content
+        self.push_redact_content = push_config.get("redact_content", False)

    def default_config(self, config_dir_path, server_name, **kwargs):
        return """
-        # Clients requesting push notifications can either have the body of
-        # the message sent in the notification poke along with other details
-        # like the sender, or just the event ID and room ID (`event_id_only`).
-        # If clients choose the former, this option controls whether the
-        # notification request includes the content of the event (other details
-        # like the sender are still included). For `event_id_only` push, it
-        # has no effect.
-
+        # Control how push messages are sent to google/apple to notifications.
+        # Normally every message said in a room with one or more people using
+        # mobile devices will be posted to a push server hosted by matrix.org
+        # which is registered with google and apple in order to allow push
+        # notifications to be sent to these mobile devices.
+        #
+        # Setting redact_content to true will make the push messages contain no
+        # message content which will provide increased privacy. This is a
+        # temporary solution pending improvements to Android and iPhone apps
+        # to get content from the app rather than the notification.
+        #
        # For modern android devices the notification content will still appear
        # because it is loaded by the app. iPhone, however will send a
        # notification saying only that a message arrived and who it came from.
        #
        #push:
-        #   include_content: true
+        #   redact_content: false
        """
--- a/synapse/config/registration.py
+++ b/synapse/config/registration.py
@@ -31,8 +31,6 @@ class RegistrationConfig(Config):
                strtobool(str(config["disable_registration"]))
            )

-        self.registrations_require_3pid = config.get("registrations_require_3pid", [])
-        self.allowed_local_3pids = config.get("allowed_local_3pids", [])
        self.registration_shared_secret = config.get("registration_shared_secret")

        self.bcrypt_rounds = config.get("bcrypt_rounds", 12)
@@ -54,32 +52,13 @@ class RegistrationConfig(Config):
        # Enable registration for new users.
        enable_registration: False

-        # The user must provide all of the below types of 3PID when registering.
-        #
-        # registrations_require_3pid:
-        #     - email
-        #     - msisdn
-
-        # Mandate that users are only allowed to associate certain formats of
-        # 3PIDs with accounts on this server.
-        #
-        # allowed_local_3pids:
-        #     - medium: email
-        #       pattern: ".*@matrix\\.org"
-        #     - medium: email
-        #       pattern: ".*@vector\\.im"
-        #     - medium: msisdn
-        #       pattern: "\\+44"
-
        # If set, allows registration by anyone who also has the shared
        # secret, even if registration is otherwise disabled.
        registration_shared_secret: "%(registration_shared_secret)s"

        # Set the number of bcrypt rounds used to generate password hash.
        # Larger numbers increase the work factor needed to generate the hash.
-        # The default number is 12 (which equates to 2^12 rounds).
-        # N.B. that increasing this will exponentially increase the time required
-        # to register or login - e.g. 24 => 2^24 rounds which will take >20 mins.
+        # The default number of rounds is 12.
        bcrypt_rounds: 12

        # Allows users to register as guests without a password/email/etc, and
--- a/synapse/config/repository.py
+++ b/synapse/config/repository.py
@@ -16,8 +16,6 @@
 from ._base import Config, ConfigError
 from collections import namedtuple

-from synapse.util.module_loader import load_module
-

 MISSING_NETADDR = (
    "Missing netaddr library. This is required for URL preview API."
@@ -38,14 +36,6 @@ ThumbnailRequirement = namedtuple(
    "ThumbnailRequirement", ["width", "height", "method", "media_type"]
 )

-MediaStorageProviderConfig = namedtuple(
-    "MediaStorageProviderConfig", (
-        "store_local",  # Whether to store newly uploaded local files
-        "store_remote",  # Whether to store newly downloaded remote files
-        "store_synchronous",  # Whether to wait for successful storage for local uploads
-    ),
-)
-

 def parse_thumbnail_requirements(thumbnail_sizes):
    """ Takes a list of dictionaries with "width", "height", and "method" keys
@@ -83,61 +73,16 @@ class ContentRepositoryConfig(Config):

        self.media_store_path = self.ensure_directory(config["media_store_path"])

-        backup_media_store_path = config.get("backup_media_store_path")
+        self.backup_media_store_path = config.get("backup_media_store_path")
+        if self.backup_media_store_path:
+            self.backup_media_store_path = self.ensure_directory(
+                self.backup_media_store_path
+            )

-        synchronous_backup_media_store = config.get(
+        self.synchronous_backup_media_store = config.get(
            "synchronous_backup_media_store", False
        )

-        storage_providers = config.get("media_storage_providers", [])
-
-        if backup_media_store_path:
-            if storage_providers:
-                raise ConfigError(
-                    "Cannot use both 'backup_media_store_path' and 'storage_providers'"
-                )
-
-            storage_providers = [{
-                "module": "file_system",
-                "store_local": True,
-                "store_synchronous": synchronous_backup_media_store,
-                "store_remote": True,
-                "config": {
-                    "directory": backup_media_store_path,
-                }
-            }]
-
-        # This is a list of config that can be used to create the storage
-        # providers. The entries are tuples of (Class, class_config,
-        # MediaStorageProviderConfig), where Class is the class of the provider,
-        # the class_config the config to pass to it, and
-        # MediaStorageProviderConfig are options for StorageProviderWrapper.
-        #
-        # We don't create the storage providers here as not all workers need
-        # them to be started.
-        self.media_storage_providers = []
-
-        for provider_config in storage_providers:
-            # We special case the module "file_system" so as not to need to
-            # expose FileStorageProviderBackend
-            if provider_config["module"] == "file_system":
-                provider_config["module"] = (
-                    "synapse.rest.media.v1.storage_provider"
-                    ".FileStorageProviderBackend"
-                )
-
-            provider_class, parsed_config = load_module(provider_config)
-
-            wrapper_config = MediaStorageProviderConfig(
-                provider_config.get("store_local", False),
-                provider_config.get("store_remote", False),
-                provider_config.get("store_synchronous", False),
-            )
-
-            self.media_storage_providers.append(
-                (provider_class, parsed_config, wrapper_config,)
-            )
-
        self.uploads_path = self.ensure_directory(config["uploads_path"])
        self.dynamic_thumbnails = config["dynamic_thumbnails"]
        self.thumbnail_requirements = parse_thumbnail_requirements(
@@ -182,19 +127,13 @@ class ContentRepositoryConfig(Config):
        # Directory where uploaded images and attachments are stored.
        media_store_path: "%(media_store)s"

-        # Media storage providers allow media to be stored in different
-        # locations.
-        # media_storage_providers:
-        # - module: file_system
-        #   # Whether to write new local files.
-        #   store_local: false
-        #   # Whether to write new remote media
-        #   store_remote: false
-        #   # Whether to block upload requests waiting for write to this
-        #   # provider to complete
-        #   store_synchronous: false
-        #   config:
-        #     directory: /mnt/some/other/directory
+        # A secondary directory where uploaded images and attachments are
+        # stored as a backup.
+        # backup_media_store_path: "%(media_store)s"
+
+        # Whether to wait for successful write to backup media store before
+        # returning successfully.
+        # synchronous_backup_media_store: false

        # Directory where in-progress uploads are stored.
        uploads_path: "%(uploads_path)s"
--- a/synapse/config/server.py
+++ b/synapse/config/server.py
@@ -41,12 +41,6 @@ class ServerConfig(Config):
        # false only if we are updating the user directory in a worker
        self.update_user_directory = config.get("update_user_directory", True)

-        # whether to enable the media repository endpoints. This should be set
-        # to false if the media repository is running as a separate endpoint;
-        # doing so ensures that we will not run cache cleanup jobs on the
-        # master, potentially causing inconsistency.
-        self.enable_media_repo = config.get("enable_media_repo", True)
-
        self.filter_timeline_limit = config.get("filter_timeline_limit", -1)

        # Whether we should block invites sent to users on this server
@@ -55,17 +49,6 @@ class ServerConfig(Config):
            "block_non_admin_invites", False,
        )

-        # FIXME: federation_domain_whitelist needs sytests
-        self.federation_domain_whitelist = None
-        federation_domain_whitelist = config.get(
-            "federation_domain_whitelist", None
-        )
-        # turn the whitelist into a hash for speed of lookup
-        if federation_domain_whitelist is not None:
-            self.federation_domain_whitelist = {}
-            for domain in federation_domain_whitelist:
-                self.federation_domain_whitelist[domain] = True
-
        if self.public_baseurl is not None:
            if self.public_baseurl[-1] != '/':
                self.public_baseurl += '/'
@@ -221,17 +204,6 @@ class ServerConfig(Config):
        # (except those sent by local server admins). The default is False.
        # block_non_admin_invites: True

-        # Restrict federation to the following whitelist of domains.
-        # N.B. we recommend also firewalling your federation listener to limit
-        # inbound federation traffic as early as possible, rather than relying
-        # purely on this application-layer restriction.  If not specified, the
-        # default is to whitelist everything.
-        #
-        # federation_domain_whitelist:
-        #  - lon.example.com
-        #  - nyc.example.com
-        #  - syd.example.com
-
        # List of ports that Synapse should listen on, their purpose and their
        # configuration.
        listeners:
@@ -242,12 +214,13 @@ class ServerConfig(Config):
            port: %(bind_port)s

            # Local addresses to listen on.
-            # On Linux and Mac OS, `::` will listen on all IPv4 and IPv6
-            # addresses by default. For most other OSes, this will only listen
-            # on IPv6.
+            # This will listen on all IPv4 addresses by default.
            bind_addresses:
-              - '::'
              - '0.0.0.0'
+              # Uncomment to listen on all IPv6 interfaces
+              # N.B: On at least Linux this will also listen on all IPv4
+              # addresses, so you will need to comment out the line above.
+              # - '::'

            # This is a 'http' listener, allows us to specify 'resources'.
            type: http
@@ -285,7 +258,7 @@ class ServerConfig(Config):
          # For when matrix traffic passes through loadbalancer that unwraps TLS.
          - port: %(unsecure_port)s
            tls: false
-            bind_addresses: ['::', '0.0.0.0']
+            bind_addresses: ['0.0.0.0']
            type: http

            x_forwarded: false
@@ -299,7 +272,7 @@ class ServerConfig(Config):
          # Turn on the twisted ssh manhole service on localhost on the given
          # port.
          # - port: 9000
-          #   bind_addresses: ['::1', '127.0.0.1']
+          #   bind_address: 127.0.0.1
          #   type: manhole
        """ % locals()

--- a/synapse/config/tls.py
+++ b/synapse/config/tls.py
@@ -96,7 +96,7 @@ class TlsConfig(Config):
        # certificates returned by this server match one of the fingerprints.
        #
        # Synapse automatically adds the fingerprint of its own certificate
-        # to the list. So if federation traffic is handled directly by synapse
+        # to the list. So if federation traffic is handle directly by synapse
        # then no modification to the list is required.
        #
        # If synapse is run behind a load balancer that handles the TLS then it
--- a/synapse/config/user_directory.py
+++ b/synapse/config/user_directory.py
@@ -1,44 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2017 New Vector 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.
-
-from ._base import Config
-
-
-class UserDirectoryConfig(Config):
-    """User Directory Configuration
-    Configuration for the behaviour of the /user_directory API
-    """
-
-    def read_config(self, config):
-        self.user_directory_search_all_users = False
-        user_directory_config = config.get("user_directory", None)
-        if user_directory_config:
-            self.user_directory_search_all_users = (
-                user_directory_config.get("search_all_users", False)
-            )
-
-    def default_config(self, config_dir_path, server_name, **kwargs):
-        return """
-        # User Directory configuration
-        #
-        # 'search_all_users' defines whether to search all users visible to your HS
-        # when searching the user directory, rather than limiting to users visible
-        # in public rooms.  Defaults to false.  If you set it True, you'll have to run
-        # UPDATE user_directory_stream_pos SET stream_id = NULL;
-        # on your database to tell it to rebuild the user_directory search indexes.
-        #
-        #user_directory:
-        #   search_all_users: false
-        """
--- a/synapse/config/workers.py
+++ b/synapse/config/workers.py
@@ -23,26 +23,13 @@ class WorkerConfig(Config):

    def read_config(self, config):
        self.worker_app = config.get("worker_app")
-
-        # Canonicalise worker_app so that master always has None
-        if self.worker_app == "synapse.app.homeserver":
-            self.worker_app = None
-
        self.worker_listeners = config.get("worker_listeners")
        self.worker_daemonize = config.get("worker_daemonize")
        self.worker_pid_file = config.get("worker_pid_file")
        self.worker_log_file = config.get("worker_log_file")
        self.worker_log_config = config.get("worker_log_config")
-
-        # The host used to connect to the main synapse
        self.worker_replication_host = config.get("worker_replication_host", None)
-
-        # The port on the main synapse for TCP replication
        self.worker_replication_port = config.get("worker_replication_port", None)
-
-        # The port on the main synapse for HTTP replication endpoint
-        self.worker_replication_http_port = config.get("worker_replication_http_port")
-
        self.worker_name = config.get("worker_name", self.worker_app)

        self.worker_main_http_uri = config.get("worker_main_http_uri", None)
--- a/synapse/crypto/event_signing.py
+++ b/synapse/crypto/event_signing.py
@@ -32,22 +32,15 @@ def check_event_content_hash(event, hash_algorithm=hashlib.sha256):
    """Check whether the hash for this PDU matches the contents"""
    name, expected_hash = compute_content_hash(event, hash_algorithm)
    logger.debug("Expecting hash: %s", encode_base64(expected_hash))
-
-    # some malformed events lack a 'hashes'. Protect against it being missing
-    # or a weird type by basically treating it the same as an unhashed event.
-    hashes = event.get("hashes")
-    if not isinstance(hashes, dict):
-        raise SynapseError(400, "Malformed 'hashes'", Codes.UNAUTHORIZED)
-
-    if name not in hashes:
+    if name not in event.hashes:
        raise SynapseError(
            400,
            "Algorithm %s not in hashes %s" % (
-                name, list(hashes),
+                name, list(event.hashes),
            ),
            Codes.UNAUTHORIZED,
        )
-    message_hash_base64 = hashes[name]
+    message_hash_base64 = event.hashes[name]
    try:
        message_hash_bytes = decode_base64(message_hash_base64)
    except Exception:
--- a/synapse/event_auth.py
+++ b/synapse/event_auth.py
@@ -319,7 +319,7 @@ def _is_membership_change_allowed(event, auth_events):
        # TODO (erikj): Implement kicks.
        if target_banned and user_level < ban_level:
            raise AuthError(
-                403, "You cannot unban user %s." % (target_user_id,)
+                403, "You cannot unban user &s." % (target_user_id,)
            )
        elif target_user_id != event.user_id:
            kick_level = _get_named_level(auth_events, "kick", 50)
--- a/synapse/events/snapshot.py
+++ b/synapse/events/snapshot.py
@@ -13,10 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-from twisted.internet import defer
-
-from frozendict import frozendict
-

 class EventContext(object):
    """
@@ -29,9 +25,7 @@ class EventContext(object):
            The current state map excluding the current event.
            (type, state_key) -> event_id

-        state_group (int|None): state group id, if the state has been stored
-            as a state group. This is usually only None if e.g. the event is
-            an outlier.
+        state_group (int): state group id
        rejected (bool|str): A rejection reason if the event was rejected, else
            False

@@ -52,6 +46,7 @@ class EventContext(object):
        "prev_state_ids",
        "state_group",
        "rejected",
+        "push_actions",
        "prev_group",
        "delta_ids",
        "prev_state_events",
@@ -66,6 +61,7 @@ class EventContext(object):
        self.state_group = None

        self.rejected = False
+        self.push_actions = []

        # A previously persisted state group and a delta between that
        # and this state.
@@ -75,98 +71,3 @@ class EventContext(object):
        self.prev_state_events = None

        self.app_service = None
-
-    def serialize(self, event):
-        """Converts self to a type that can be serialized as JSON, and then
-        deserialized by `deserialize`
-
-        Args:
-            event (FrozenEvent): The event that this context relates to
-
-        Returns:
-            dict
-        """
-
-        # We don't serialize the full state dicts, instead they get pulled out
-        # of the DB on the other side. However, the other side can't figure out
-        # the prev_state_ids, so if we're a state event we include the event
-        # id that we replaced in the state.
-        if event.is_state():
-            prev_state_id = self.prev_state_ids.get((event.type, event.state_key))
-        else:
-            prev_state_id = None
-
-        return {
-            "prev_state_id": prev_state_id,
-            "event_type": event.type,
-            "event_state_key": event.state_key if event.is_state() else None,
-            "state_group": self.state_group,
-            "rejected": self.rejected,
-            "prev_group": self.prev_group,
-            "delta_ids": _encode_state_dict(self.delta_ids),
-            "prev_state_events": self.prev_state_events,
-            "app_service_id": self.app_service.id if self.app_service else None
-        }
-
-    @staticmethod
-    @defer.inlineCallbacks
-    def deserialize(store, input):
-        """Converts a dict that was produced by `serialize` back into a
-        EventContext.
-
-        Args:
-            store (DataStore): Used to convert AS ID to AS object
-            input (dict): A dict produced by `serialize`
-
-        Returns:
-            EventContext
-        """
-        context = EventContext()
-        context.state_group = input["state_group"]
-        context.rejected = input["rejected"]
-        context.prev_group = input["prev_group"]
-        context.delta_ids = _decode_state_dict(input["delta_ids"])
-        context.prev_state_events = input["prev_state_events"]
-
-        # We use the state_group and prev_state_id stuff to pull the
-        # current_state_ids out of the DB and construct prev_state_ids.
-        prev_state_id = input["prev_state_id"]
-        event_type = input["event_type"]
-        event_state_key = input["event_state_key"]
-
-        context.current_state_ids = yield store.get_state_ids_for_group(
-            context.state_group,
-        )
-        if prev_state_id and event_state_key:
-            context.prev_state_ids = dict(context.current_state_ids)
-            context.prev_state_ids[(event_type, event_state_key)] = prev_state_id
-        else:
-            context.prev_state_ids = context.current_state_ids
-
-        app_service_id = input["app_service_id"]
-        if app_service_id:
-            context.app_service = store.get_app_service_by_id(app_service_id)
-
-        defer.returnValue(context)
-
-
-def _encode_state_dict(state_dict):
-    """Since dicts of (type, state_key) -> event_id cannot be serialized in
-    JSON we need to convert them to a form that can.
-    """
-    if state_dict is None:
-        return None
-
-    return [
-        (etype, state_key, v)
-        for (etype, state_key), v in state_dict.iteritems()
-    ]
-
-
-def _decode_state_dict(input):
-    """Decodes a state dict encoded using `_encode_state_dict` above
-    """
-    if input is None:
-        return None
-
-    return frozendict({(etype, state_key,): v for etype, state_key, v in input})
--- a/synapse/federation/init.py
+++ b/synapse/federation/init.py
@@ -15,3 +15,11 @@

 """ This package includes all the federation specific logic.
 """
+
+from .replication import ReplicationLayer
+
+
+def initialize_http_replication(hs):
+    transport = hs.get_federation_transport_client()
+
+    return ReplicationLayer(hs, transport)
--- a/synapse/federation/federation_base.py
+++ b/synapse/federation/federation_base.py
@@ -16,9 +16,7 @@ import logging

 from synapse.api.errors import SynapseError
 from synapse.crypto.event_signing import check_event_content_hash
-from synapse.events import FrozenEvent
 from synapse.events.utils import prune_event
-from synapse.http.servlet import assert_params_in_request
 from synapse.util import unwrapFirstError, logcontext
 from twisted.internet import defer

@@ -27,13 +25,7 @@ logger = logging.getLogger(__name__)

 class FederationBase(object):
    def __init__(self, hs):
-        self.hs = hs
-
-        self.server_name = hs.hostname
-        self.keyring = hs.get_keyring()
        self.spam_checker = hs.get_spam_checker()
-        self.store = hs.get_datastore()
-        self._clock = hs.get_clock()

    @defer.inlineCallbacks
    def _check_sigs_and_hash_and_fetch(self, origin, pdus, outlier=False,
@@ -177,28 +169,3 @@ class FederationBase(object):
            )

        return deferreds
-
-
-def event_from_pdu_json(pdu_json, outlier=False):
-    """Construct a FrozenEvent from an event json received over federation
-
-    Args:
-        pdu_json (object): pdu as received over federation
-        outlier (bool): True to mark this event as an outlier
-
-    Returns:
-        FrozenEvent
-
-    Raises:
-        SynapseError: if the pdu is missing required fields
-    """
-    # we could probably enforce a bunch of other fields here (room_id, sender,
-    # origin, etc etc)
-    assert_params_in_request(pdu_json, ('event_id', 'type'))
-    event = FrozenEvent(
-        pdu_json
-    )
-
-    event.internal_metadata.outlier = outlier
-
-    return event
--- a/synapse/federation/federation_client.py
+++ b/synapse/federation/federation_client.py
@@ -14,28 +14,28 @@
 # limitations under the License.


+from twisted.internet import defer
+
+from .federation_base import FederationBase
+from synapse.api.constants import Membership
+
+from synapse.api.errors import (
+    CodeMessageException, HttpResponseException, SynapseError,
+)
+from synapse.util import unwrapFirstError, logcontext
+from synapse.util.caches.expiringcache import ExpiringCache
+from synapse.util.logutils import log_function
+from synapse.util.logcontext import preserve_fn, preserve_context_over_deferred
+from synapse.events import FrozenEvent, builder
+import synapse.metrics
+
+from synapse.util.retryutils import NotRetryingDestination
+
 import copy
 import itertools
 import logging
 import random

-from twisted.internet import defer
-
-from synapse.api.constants import Membership
-from synapse.api.errors import (
-    CodeMessageException, HttpResponseException, SynapseError, FederationDeniedError
-)
-from synapse.events import builder
-from synapse.federation.federation_base import (
-    FederationBase,
-    event_from_pdu_json,
-)
-import synapse.metrics
-from synapse.util import logcontext, unwrapFirstError
-from synapse.util.caches.expiringcache import ExpiringCache
-from synapse.util.logcontext import make_deferred_yieldable, preserve_fn
-from synapse.util.logutils import log_function
-from synapse.util.retryutils import NotRetryingDestination

 logger = logging.getLogger(__name__)

@@ -58,7 +58,6 @@ class FederationClient(FederationBase):
            self._clear_tried_cache, 60 * 1000,
        )
        self.state = hs.get_state_handler()
-        self.transport_layer = hs.get_federation_transport_client()

    def _clear_tried_cache(self):
        """Clear pdu_destination_tried cache"""
@@ -185,7 +184,7 @@ class FederationClient(FederationBase):
        logger.debug("backfill transaction_data=%s", repr(transaction_data))

        pdus = [
-            event_from_pdu_json(p, outlier=False)
+            self.event_from_pdu_json(p, outlier=False)
            for p in transaction_data["pdus"]
        ]

@@ -245,7 +244,7 @@ class FederationClient(FederationBase):
                logger.debug("transaction_data %r", transaction_data)

                pdu_list = [
-                    event_from_pdu_json(p, outlier=outlier)
+                    self.event_from_pdu_json(p, outlier=outlier)
                    for p in transaction_data["pdus"]
                ]

@@ -267,9 +266,6 @@ class FederationClient(FederationBase):
            except NotRetryingDestination as e:
                logger.info(e.message)
                continue
-            except FederationDeniedError as e:
-                logger.info(e.message)
-                continue
            except Exception as e:
                pdu_attempts[destination] = now

@@ -340,11 +336,11 @@ class FederationClient(FederationBase):
        )

        pdus = [
-            event_from_pdu_json(p, outlier=True) for p in result["pdus"]
+            self.event_from_pdu_json(p, outlier=True) for p in result["pdus"]
        ]

        auth_chain = [
-            event_from_pdu_json(p, outlier=True)
+            self.event_from_pdu_json(p, outlier=True)
            for p in result.get("auth_chain", [])
        ]

@@ -424,7 +420,7 @@ class FederationClient(FederationBase):
                for e_id in batch
            ]

-            res = yield make_deferred_yieldable(
+            res = yield preserve_context_over_deferred(
                defer.DeferredList(deferreds, consumeErrors=True)
            )
            for success, result in res:
@@ -445,7 +441,7 @@ class FederationClient(FederationBase):
        )

        auth_chain = [
-            event_from_pdu_json(p, outlier=True)
+            self.event_from_pdu_json(p, outlier=True)
            for p in res["auth_chain"]
        ]

@@ -574,12 +570,12 @@ class FederationClient(FederationBase):
                logger.debug("Got content: %s", content)

                state = [
-                    event_from_pdu_json(p, outlier=True)
+                    self.event_from_pdu_json(p, outlier=True)
                    for p in content.get("state", [])
                ]

                auth_chain = [
-                    event_from_pdu_json(p, outlier=True)
+                    self.event_from_pdu_json(p, outlier=True)
                    for p in content.get("auth_chain", [])
                ]

@@ -654,7 +650,7 @@ class FederationClient(FederationBase):

        logger.debug("Got response to send_invite: %s", pdu_dict)

-        pdu = event_from_pdu_json(pdu_dict)
+        pdu = self.event_from_pdu_json(pdu_dict)

        # Check signatures are correct.
        pdu = yield self._check_sigs_and_hash(pdu)
@@ -744,7 +740,7 @@ class FederationClient(FederationBase):
        )

        auth_chain = [
-            event_from_pdu_json(e)
+            self.event_from_pdu_json(e)
            for e in content["auth_chain"]
        ]

@@ -792,7 +788,7 @@ class FederationClient(FederationBase):
            )

            events = [
-                event_from_pdu_json(e)
+                self.event_from_pdu_json(e)
                for e in content.get("events", [])
            ]

@@ -809,6 +805,15 @@ class FederationClient(FederationBase):

        defer.returnValue(signed_events)

+    def event_from_pdu_json(self, pdu_json, outlier=False):
+        event = FrozenEvent(
+            pdu_json
+        )
+
+        event.internal_metadata.outlier = outlier
+
+        return event
+
    @defer.inlineCallbacks
    def forward_third_party_invite(self, destinations, room_id, event_dict):
        for destination in destinations:
--- a/synapse/federation/federation_server.py
+++ b/synapse/federation/federation_server.py
@@ -12,26 +12,25 @@
 # 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
-
-import simplejson as json
 from twisted.internet import defer

-from synapse.api.errors import AuthError, FederationError, SynapseError, NotFoundError
-from synapse.crypto.event_signing import compute_event_signature
-from synapse.federation.federation_base import (
-    FederationBase,
-    event_from_pdu_json,
-)
+from .federation_base import FederationBase
+from .units import Transaction, Edu

-from synapse.federation.persistence import TransactionActions
-from synapse.federation.units import Edu, Transaction
-import synapse.metrics
-from synapse.types import get_domain_from_id
 from synapse.util import async
-from synapse.util.caches.response_cache import ResponseCache
 from synapse.util.logcontext import make_deferred_yieldable, preserve_fn
 from synapse.util.logutils import log_function
+from synapse.util.caches.response_cache import ResponseCache
+from synapse.events import FrozenEvent
+from synapse.types import get_domain_from_id
+import synapse.metrics
+
+from synapse.api.errors import AuthError, FederationError, SynapseError
+
+from synapse.crypto.event_signing import compute_event_signature
+
+import simplejson as json
+import logging

 # when processing incoming transactions, we try to handle multiple rooms in
 # parallel, up to this limit.
@@ -54,19 +53,50 @@ class FederationServer(FederationBase):
        super(FederationServer, self).__init__(hs)

        self.auth = hs.get_auth()
-        self.handler = hs.get_handlers().federation_handler

        self._server_linearizer = async.Linearizer("fed_server")
        self._transaction_linearizer = async.Linearizer("fed_txn_handler")

-        self.transaction_actions = TransactionActions(self.store)
-
-        self.registry = hs.get_federation_registry()
-
        # We cache responses to state queries, as they take a while and often
        # come in waves.
        self._state_resp_cache = ResponseCache(hs, timeout_ms=30000)

+    def set_handler(self, handler):
+        """Sets the handler that the replication layer will use to communicate
+        receipt of new PDUs from other home servers. The required methods are
+        documented on :py:class:`.ReplicationHandler`.
+        """
+        self.handler = handler
+
+    def register_edu_handler(self, edu_type, handler):
+        if edu_type in self.edu_handlers:
+            raise KeyError("Already have an EDU handler for %s" % (edu_type,))
+
+        self.edu_handlers[edu_type] = handler
+
+    def register_query_handler(self, query_type, handler):
+        """Sets the handler callable that will be used to handle an incoming
+        federation Query of the given type.
+
+        Args:
+            query_type (str): Category name of the query, which should match
+                the string used by make_query.
+            handler (callable): Invoked to handle incoming queries of this type
+
+        handler is invoked as:
+            result = handler(args)
+
+        where 'args' is a dict mapping strings to strings of the query
+          arguments. It should return a Deferred that will eventually yield an
+          object to encode as JSON.
+        """
+        if query_type in self.query_handlers:
+            raise KeyError(
+                "Already have a Query handler for %s" % (query_type,)
+            )
+
+        self.query_handlers[query_type] = handler
+
    @defer.inlineCallbacks
    @log_function
    def on_backfill_request(self, origin, room_id, versions, limit):
@@ -142,7 +172,7 @@ class FederationServer(FederationBase):
                p["age_ts"] = request_time - int(p["age"])
                del p["age"]

-            event = event_from_pdu_json(p)
+            event = self.event_from_pdu_json(p)
            room_id = event.room_id
            pdus_by_room.setdefault(room_id, []).append(event)

@@ -200,7 +230,16 @@ class FederationServer(FederationBase):
    @defer.inlineCallbacks
    def received_edu(self, origin, edu_type, content):
        received_edus_counter.inc()
-        yield self.registry.on_edu(edu_type, origin, content)
+
+        if edu_type in self.edu_handlers:
+            try:
+                yield self.edu_handlers[edu_type](origin, content)
+            except SynapseError as e:
+                logger.info("Failed to handle edu %r: %r", edu_type, e)
+            except Exception as e:
+                logger.exception("Failed to handle edu %r", edu_type)
+        else:
+            logger.warn("Received EDU of type %s with no handler", edu_type)

    @defer.inlineCallbacks
    @log_function
@@ -290,8 +329,14 @@ class FederationServer(FederationBase):
    @defer.inlineCallbacks
    def on_query_request(self, query_type, args):
        received_queries_counter.inc(query_type)
-        resp = yield self.registry.on_query(query_type, args)
-        defer.returnValue((200, resp))
+
+        if query_type in self.query_handlers:
+            response = yield self.query_handlers[query_type](args)
+            defer.returnValue((200, response))
+        else:
+            defer.returnValue(
+                (404, "No handler for Query type '%s'" % (query_type,))
+            )

    @defer.inlineCallbacks
    def on_make_join_request(self, room_id, user_id):
@@ -301,7 +346,7 @@ class FederationServer(FederationBase):

    @defer.inlineCallbacks
    def on_invite_request(self, origin, content):
-        pdu = event_from_pdu_json(content)
+        pdu = self.event_from_pdu_json(content)
        ret_pdu = yield self.handler.on_invite_request(origin, pdu)
        time_now = self._clock.time_msec()
        defer.returnValue((200, {"event": ret_pdu.get_pdu_json(time_now)}))
@@ -309,7 +354,7 @@ class FederationServer(FederationBase):
    @defer.inlineCallbacks
    def on_send_join_request(self, origin, content):
        logger.debug("on_send_join_request: content: %s", content)
-        pdu = event_from_pdu_json(content)
+        pdu = self.event_from_pdu_json(content)
        logger.debug("on_send_join_request: pdu sigs: %s", pdu.signatures)
        res_pdus = yield self.handler.on_send_join_request(origin, pdu)
        time_now = self._clock.time_msec()
@@ -329,7 +374,7 @@ class FederationServer(FederationBase):
    @defer.inlineCallbacks
    def on_send_leave_request(self, origin, content):
        logger.debug("on_send_leave_request: content: %s", content)
-        pdu = event_from_pdu_json(content)
+        pdu = self.event_from_pdu_json(content)
        logger.debug("on_send_leave_request: pdu sigs: %s", pdu.signatures)
        yield self.handler.on_send_leave_request(origin, pdu)
        defer.returnValue((200, {}))
@@ -366,7 +411,7 @@ class FederationServer(FederationBase):
        """
        with (yield self._server_linearizer.queue((origin, room_id))):
            auth_chain = [
-                event_from_pdu_json(e)
+                self.event_from_pdu_json(e)
                for e in content["auth_chain"]
            ]

@@ -541,6 +586,15 @@ class FederationServer(FederationBase):
    def __str__(self):
        return "<ReplicationLayer(%s)>" % self.server_name

+    def event_from_pdu_json(self, pdu_json, outlier=False):
+        event = FrozenEvent(
+            pdu_json
+        )
+
+        event.internal_metadata.outlier = outlier
+
+        return event
+
    @defer.inlineCallbacks
    def exchange_third_party_invite(
            self,
@@ -563,66 +617,3 @@ class FederationServer(FederationBase):
            origin, room_id, event_dict
        )
        defer.returnValue(ret)
-
-
-class FederationHandlerRegistry(object):
-    """Allows classes to register themselves as handlers for a given EDU or
-    query type for incoming federation traffic.
-    """
-    def __init__(self):
-        self.edu_handlers = {}
-        self.query_handlers = {}
-
-    def register_edu_handler(self, edu_type, handler):
-        """Sets the handler callable that will be used to handle an incoming
-        federation EDU of the given type.
-
-        Args:
-            edu_type (str): The type of the incoming EDU to register handler for
-            handler (Callable[[str, dict]]): A callable invoked on incoming EDU
-                of the given type. The arguments are the origin server name and
-                the EDU contents.
-        """
-        if edu_type in self.edu_handlers:
-            raise KeyError("Already have an EDU handler for %s" % (edu_type,))
-
-        self.edu_handlers[edu_type] = handler
-
-    def register_query_handler(self, query_type, handler):
-        """Sets the handler callable that will be used to handle an incoming
-        federation query of the given type.
-
-        Args:
-            query_type (str): Category name of the query, which should match
-                the string used by make_query.
-            handler (Callable[[dict], Deferred[dict]]): Invoked to handle
-                incoming queries of this type. The return will be yielded
-                on and the result used as the response to the query request.
-        """
-        if query_type in self.query_handlers:
-            raise KeyError(
-                "Already have a Query handler for %s" % (query_type,)
-            )
-
-        self.query_handlers[query_type] = handler
-
-    @defer.inlineCallbacks
-    def on_edu(self, edu_type, origin, content):
-        handler = self.edu_handlers.get(edu_type)
-        if not handler:
-            logger.warn("No handler registered for EDU type %s", edu_type)
-
-        try:
-            yield handler(origin, content)
-        except SynapseError as e:
-            logger.info("Failed to handle edu %r: %r", edu_type, e)
-        except Exception as e:
-            logger.exception("Failed to handle edu %r", edu_type)
-
-    def on_query(self, query_type, args):
-        handler = self.query_handlers.get(query_type)
-        if not handler:
-            logger.warn("No handler registered for query type %s", query_type)
-            raise NotFoundError("No handler for Query type '%s'" % (query_type,))
-
-        return handler(args)
--- a/synapse/federation/replication.py
+++ b/synapse/federation/replication.py
@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# 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.
+
+"""This layer is responsible for replicating with remote home servers using
+a given transport.
+"""
+
+from .federation_client import FederationClient
+from .federation_server import FederationServer
+
+from .persistence import TransactionActions
+
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class ReplicationLayer(FederationClient, FederationServer):
+    """This layer is responsible for replicating with remote home servers over
+    the given transport. I.e., does the sending and receiving of PDUs to
+    remote home servers.
+
+    The layer communicates with the rest of the server via a registered
+    ReplicationHandler.
+
+    In more detail, the layer:
+        * Receives incoming data and processes it into transactions and pdus.
+        * Fetches any PDUs it thinks it might have missed.
+        * Keeps the current state for contexts up to date by applying the
+          suitable conflict resolution.
+        * Sends outgoing pdus wrapped in transactions.
+        * Fills out the references to previous pdus/transactions appropriately
+          for outgoing data.
+    """
+
+    def __init__(self, hs, transport_layer):
+        self.server_name = hs.hostname
+
+        self.keyring = hs.get_keyring()
+
+        self.transport_layer = transport_layer
+
+        self.federation_client = self
+
+        self.store = hs.get_datastore()
+
+        self.handler = None
+        self.edu_handlers = {}
+        self.query_handlers = {}
+
+        self._clock = hs.get_clock()
+
+        self.transaction_actions = TransactionActions(self.store)
+
+        self.hs = hs
+
+        super(ReplicationLayer, self).__init__(hs)
+
+    def __str__(self):
+        return "<ReplicationLayer(%s)>" % self.server_name
--- a/synapse/federation/transaction_queue.py
+++ b/synapse/federation/transaction_queue.py
@@ -19,8 +19,8 @@ from twisted.internet import defer
 from .persistence import TransactionActions
 from .units import Transaction, Edu

-from synapse.api.errors import HttpResponseException, FederationDeniedError
-from synapse.util import logcontext, PreserveLoggingContext
+from synapse.api.errors import HttpResponseException
+from synapse.util import logcontext
 from synapse.util.async import run_on_reactor
 from synapse.util.retryutils import NotRetryingDestination, get_retry_limiter
 from synapse.util.metrics import measure_func
@@ -42,8 +42,6 @@ sent_edus_counter = client_metrics.register_counter("sent_edus")

 sent_transactions_counter = client_metrics.register_counter("sent_transactions")

-events_processed_counter = client_metrics.register_counter("events_processed")
-

 class TransactionQueue(object):
    """This class makes sure we only have one transaction in flight at
@@ -148,6 +146,7 @@ class TransactionQueue(object):
        else:
            return not destination.startswith("localhost")

+    @defer.inlineCallbacks
    def notify_new_events(self, current_id):
        """This gets called when we have some new events we might want to
        send out to other servers.
@@ -157,13 +156,6 @@ class TransactionQueue(object):
        if self._is_processing:
            return

-        # fire off a processing loop in the background. It's likely it will
-        # outlast the current request, so run it in the sentinel logcontext.
-        with PreserveLoggingContext():
-            self._process_event_queue_loop()
-
-    @defer.inlineCallbacks
-    def _process_event_queue_loop(self):
        try:
            self._is_processing = True
            while True:
@@ -207,8 +199,6 @@ class TransactionQueue(object):

                    self._send_pdu(event, destinations)

-                events_processed_counter.inc_by(len(events))
-
                yield self.store.update_federation_out_pos(
                    "events", next_token
                )
@@ -490,8 +480,6 @@ class TransactionQueue(object):
                    (e.retry_last_ts + e.retry_interval) / 1000.0
                ),
            )
-        except FederationDeniedError as e:
-            logger.info(e)
        except Exception as e:
            logger.warn(
                "TX [%s] Failed to send transaction: %s",
--- a/synapse/federation/transport/client.py
+++ b/synapse/federation/transport/client.py
@@ -212,9 +212,6 @@ class TransportLayerClient(object):

            Fails with ``NotRetryingDestination`` if we are not yet ready
            to retry this server.
-
-            Fails with ``FederationDeniedError`` if the remote destination
-            is not in our federation whitelist
        """
        valid_memberships = {Membership.JOIN, Membership.LEAVE}
        if membership not in valid_memberships:
@@ -534,9 +531,9 @@ class TransportLayerClient(object):
            ignore_backoff=True,
        )

-    def add_room_to_group(self, destination, group_id, requester_user_id, room_id,
-                          content):
-        """Add a room to a group
+    def update_room_group_association(self, destination, group_id, requester_user_id,
+                                      room_id, content):
+        """Add or update an association between room and group
        """
        path = PREFIX + "/groups/%s/room/%s" % (group_id, room_id,)

@@ -548,21 +545,8 @@ class TransportLayerClient(object):
            ignore_backoff=True,
        )

-    def update_room_in_group(self, destination, group_id, requester_user_id, room_id,
-                             config_key, content):
-        """Update room in group
-        """
-        path = PREFIX + "/groups/%s/room/%s/config/%s" % (group_id, room_id, config_key,)
-
-        return self.client.post_json(
-            destination=destination,
-            path=path,
-            args={"requester_user_id": requester_user_id},
-            data=content,
-            ignore_backoff=True,
-        )
-
-    def remove_room_from_group(self, destination, group_id, requester_user_id, room_id):
+    def delete_room_group_association(self, destination, group_id, requester_user_id,
+                                      room_id):
        """Remove a room from a group
        """
        path = PREFIX + "/groups/%s/room/%s" % (group_id, room_id,)
--- a/synapse/federation/transport/server.py
+++ b/synapse/federation/transport/server.py
@@ -16,7 +16,7 @@
 from twisted.internet import defer

 from synapse.api.urls import FEDERATION_PREFIX as PREFIX
-from synapse.api.errors import Codes, SynapseError, FederationDeniedError
+from synapse.api.errors import Codes, SynapseError
 from synapse.http.server import JsonResource
 from synapse.http.servlet import (
    parse_json_object_from_request, parse_integer_from_args, parse_string_from_args,
@@ -81,7 +81,6 @@ class Authenticator(object):
        self.keyring = hs.get_keyring()
        self.server_name = hs.hostname
        self.store = hs.get_datastore()
-        self.federation_domain_whitelist = hs.config.federation_domain_whitelist

    # A method just so we can pass 'self' as the authenticator to the Servlets
    @defer.inlineCallbacks
@@ -93,12 +92,6 @@ class Authenticator(object):
            "signatures": {},
        }

-        if (
-            self.federation_domain_whitelist is not None and
-            self.server_name not in self.federation_domain_whitelist
-        ):
-            raise FederationDeniedError(self.server_name)
-
        if content is not None:
            json_request["content"] = content

@@ -683,7 +676,7 @@ class FederationGroupsRoomsServlet(BaseFederationServlet):
 class FederationGroupsAddRoomsServlet(BaseFederationServlet):
    """Add/remove room from group
    """
-    PATH = "/groups/(?P<group_id>[^/]*)/room/(?P<room_id>[^/]*)$"
+    PATH = "/groups/(?P<group_id>[^/]*)/room/(?<room_id>)$"

    @defer.inlineCallbacks
    def on_POST(self, origin, content, query, group_id, room_id):
@@ -691,7 +684,7 @@ class FederationGroupsAddRoomsServlet(BaseFederationServlet):
        if get_domain_from_id(requester_user_id) != origin:
            raise SynapseError(403, "requester_user_id doesn't match origin")

-        new_content = yield self.handler.add_room_to_group(
+        new_content = yield self.handler.update_room_group_association(
            group_id, requester_user_id, room_id, content
        )

@@ -703,34 +696,13 @@ class FederationGroupsAddRoomsServlet(BaseFederationServlet):
        if get_domain_from_id(requester_user_id) != origin:
            raise SynapseError(403, "requester_user_id doesn't match origin")

-        new_content = yield self.handler.remove_room_from_group(
+        new_content = yield self.handler.delete_room_group_association(
            group_id, requester_user_id, room_id,
        )

        defer.returnValue((200, new_content))


-class FederationGroupsAddRoomsConfigServlet(BaseFederationServlet):
-    """Update room config in group
-    """
-    PATH = (
-        "/groups/(?P<group_id>[^/]*)/room/(?P<room_id>[^/]*)"
-        "/config/(?P<config_key>[^/]*)$"
-    )
-
-    @defer.inlineCallbacks
-    def on_POST(self, origin, content, query, group_id, room_id, config_key):
-        requester_user_id = parse_string_from_args(query, "requester_user_id")
-        if get_domain_from_id(requester_user_id) != origin:
-            raise SynapseError(403, "requester_user_id doesn't match origin")
-
-        result = yield self.groups_handler.update_room_in_group(
-            group_id, requester_user_id, room_id, config_key, content,
-        )
-
-        defer.returnValue((200, result))
-
-
 class FederationGroupsUsersServlet(BaseFederationServlet):
    """Get the users in a group on behalf of a user
    """
@@ -1170,8 +1142,6 @@ GROUP_SERVER_SERVLET_CLASSES = (
    FederationGroupsRolesServlet,
    FederationGroupsRoleServlet,
    FederationGroupsSummaryUsersServlet,
-    FederationGroupsAddRoomsServlet,
-    FederationGroupsAddRoomsConfigServlet,
 )


@@ -1190,7 +1160,7 @@ GROUP_ATTESTATION_SERVLET_CLASSES = (
 def register_servlets(hs, resource, authenticator, ratelimiter):
    for servletclass in FEDERATION_SERVLET_CLASSES:
        servletclass(
-            handler=hs.get_federation_server(),
+            handler=hs.get_replication_layer(),
            authenticator=authenticator,
            ratelimiter=ratelimiter,
            server_name=hs.hostname,
--- a/synapse/groups/groups_server.py
+++ b/synapse/groups/groups_server.py
@@ -426,7 +426,7 @@ class GroupsServerHandler(object):
        for user_result in user_results:
            g_user_id = user_result["user_id"]
            is_public = user_result["is_public"]
-            is_privileged = user_result["is_admin"]
+            is_admin = user_result["is_admin"]

            entry = {"user_id": g_user_id}

@@ -434,7 +434,7 @@ class GroupsServerHandler(object):
            entry.update(profile)

            entry["is_public"] = bool(is_public)
-            entry["is_privileged"] = bool(is_privileged)
+            entry["is_admin"] = bool(is_admin)

            if not self.is_mine_id(g_user_id):
                attestation = yield self.store.get_remote_attestation(group_id, g_user_id)
@@ -530,8 +530,9 @@ class GroupsServerHandler(object):
        })

    @defer.inlineCallbacks
-    def add_room_to_group(self, group_id, requester_user_id, room_id, content):
-        """Add room to group
+    def update_room_group_association(self, group_id, requester_user_id, room_id,
+                                      content):
+        """Add or update an association between room and group
        """
        RoomID.from_string(room_id)  # Ensure valid room id

@@ -541,42 +542,21 @@ class GroupsServerHandler(object):

        is_public = _parse_visibility_from_contents(content)

-        yield self.store.add_room_to_group(group_id, room_id, is_public=is_public)
-
-        defer.returnValue({})
-
-    @defer.inlineCallbacks
-    def update_room_in_group(self, group_id, requester_user_id, room_id, config_key,
-                             content):
-        """Update room in group
-        """
-        RoomID.from_string(room_id)  # Ensure valid room id
-
-        yield self.check_group_is_ours(
-            group_id, requester_user_id, and_exists=True, and_is_admin=requester_user_id
+        yield self.store.update_room_group_association(
+            group_id, room_id, is_public=is_public
        )

-        if config_key == "m.visibility":
-            is_public = _parse_visibility_dict(content)
-
-            yield self.store.update_room_in_group_visibility(
-                group_id, room_id,
-                is_public=is_public,
-            )
-        else:
-            raise SynapseError(400, "Uknown config option")
-
        defer.returnValue({})

    @defer.inlineCallbacks
-    def remove_room_from_group(self, group_id, requester_user_id, room_id):
+    def delete_room_group_association(self, group_id, requester_user_id, room_id):
        """Remove room from group
        """
        yield self.check_group_is_ours(
            group_id, requester_user_id, and_exists=True, and_is_admin=requester_user_id
        )

-        yield self.store.remove_room_from_group(group_id, room_id)
+        yield self.store.delete_room_group_association(group_id, room_id)

        defer.returnValue({})

@@ -840,25 +820,15 @@ def _parse_visibility_from_contents(content):
    public or not
    """

-    visibility = content.get("m.visibility")
+    visibility = content.get("visibility")
    if visibility:
-        return _parse_visibility_dict(visibility)
+        vis_type = visibility["type"]
+        if vis_type not in ("public", "private"):
+            raise SynapseError(
+                400, "Synapse only supports 'public'/'private' visibility"
+            )
+        is_public = vis_type == "public"
    else:
        is_public = True

    return is_public
-
-
-def _parse_visibility_dict(visibility):
-    """Given a dict for the "m.visibility" config return if the entity should
-    be public or not
-    """
-    vis_type = visibility.get("type")
-    if not vis_type:
-        return True
-
-    if vis_type not in ("public", "private"):
-        raise SynapseError(
-            400, "Synapse only supports 'public'/'private' visibility"
-        )
-    return vis_type == "public"
--- a/synapse/handlers/init.py
+++ b/synapse/handlers/init.py
@@ -17,6 +17,7 @@ from .register import RegistrationHandler
 from .room import (
    RoomCreationHandler, RoomContextHandler,
 )
+from .room_member import RoomMemberHandler
 from .message import MessageHandler
 from .federation import FederationHandler
 from .directory import DirectoryHandler
@@ -48,6 +49,7 @@ class Handlers(object):
        self.registration_handler = RegistrationHandler(hs)
        self.message_handler = MessageHandler(hs)
        self.room_creation_handler = RoomCreationHandler(hs)
+        self.room_member_handler = RoomMemberHandler(hs)
        self.federation_handler = FederationHandler(hs)
        self.directory_handler = DirectoryHandler(hs)
        self.admin_handler = AdminHandler(hs)
--- a/synapse/handlers/_base.py
+++ b/synapse/handlers/_base.py
@@ -158,7 +158,7 @@ class BaseHandler(object):
                # homeserver.
                requester = synapse.types.create_requester(
                    target_user, is_guest=True)
-                handler = self.hs.get_room_member_handler()
+                handler = self.hs.get_handlers().room_member_handler
                yield handler.update_membership(
                    requester,
                    target_user,
--- a/synapse/handlers/appservice.py
+++ b/synapse/handlers/appservice.py
@@ -15,19 +15,14 @@

 from twisted.internet import defer

-import synapse
 from synapse.api.constants import EventTypes
 from synapse.util.metrics import Measure
-from synapse.util.logcontext import make_deferred_yieldable, preserve_fn
+from synapse.util.logcontext import preserve_fn, preserve_context_over_deferred

 import logging

 logger = logging.getLogger(__name__)

-metrics = synapse.metrics.get_metrics_for(__name__)
-
-events_processed_counter = metrics.register_counter("events_processed")
-

 def log_failure(failure):
    logger.error(
@@ -75,10 +70,11 @@ class ApplicationServicesHandler(object):
        with Measure(self.clock, "notify_interested_services"):
            self.is_processing = True
            try:
+                upper_bound = self.current_max
                limit = 100
                while True:
                    upper_bound, events = yield self.store.get_new_events_for_appservice(
-                        self.current_max, limit
+                        upper_bound, limit
                    )

                    if not events:
@@ -108,9 +104,10 @@ class ApplicationServicesHandler(object):
                                service, event
                            )

-                    events_processed_counter.inc_by(len(events))
-
                    yield self.store.set_appservice_last_pos(upper_bound)
+
+                    if len(events) < limit:
+                        break
            finally:
                self.is_processing = False

@@ -166,7 +163,7 @@ class ApplicationServicesHandler(object):
    def query_3pe(self, kind, protocol, fields):
        services = yield self._get_services_for_3pn(protocol)

-        results = yield make_deferred_yieldable(defer.DeferredList([
+        results = yield preserve_context_over_deferred(defer.DeferredList([
            preserve_fn(self.appservice_api.query_3pe)(service, kind, protocol, fields)
            for service in services
        ], consumeErrors=True))
--- a/synapse/handlers/auth.py
+++ b/synapse/handlers/auth.py
@@ -13,19 +13,15 @@
 # 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.
-from twisted.internet import defer, threads
+from twisted.internet import defer

 from ._base import BaseHandler
 from synapse.api.constants import LoginType
-from synapse.api.errors import (
-    AuthError, Codes, InteractiveAuthIncompleteError, LoginError, StoreError,
-    SynapseError,
-)
+from synapse.api.errors import AuthError, LoginError, Codes, StoreError, SynapseError
 from synapse.module_api import ModuleApi
 from synapse.types import UserID
 from synapse.util.async import run_on_reactor
 from synapse.util.caches.expiringcache import ExpiringCache
-from synapse.util.logcontext import make_deferred_yieldable

 from twisted.web.client import PartialDownloadError

@@ -50,6 +46,7 @@ class AuthHandler(BaseHandler):
        """
        super(AuthHandler, self).__init__(hs)
        self.checkers = {
+            LoginType.PASSWORD: self._check_password_auth,
            LoginType.RECAPTCHA: self._check_recaptcha,
            LoginType.EMAIL_IDENTITY: self._check_email_identity,
            LoginType.MSISDN: self._check_msisdn,
@@ -78,76 +75,15 @@ class AuthHandler(BaseHandler):
        self.macaroon_gen = hs.get_macaroon_generator()
        self._password_enabled = hs.config.password_enabled

-        # we keep this as a list despite the O(N^2) implication so that we can
-        # keep PASSWORD first and avoid confusing clients which pick the first
-        # type in the list. (NB that the spec doesn't require us to do so and
-        # clients which favour types that they don't understand over those that
-        # they do are technically broken)
-        login_types = []
+        login_types = set()
        if self._password_enabled:
-            login_types.append(LoginType.PASSWORD)
+            login_types.add(LoginType.PASSWORD)
        for provider in self.password_providers:
            if hasattr(provider, "get_supported_login_types"):
-                for t in provider.get_supported_login_types().keys():
-                    if t not in login_types:
-                        login_types.append(t)
-        self._supported_login_types = login_types
-
-    @defer.inlineCallbacks
-    def validate_user_via_ui_auth(self, requester, request_body, clientip):
-        """
-        Checks that the user is who they claim to be, via a UI auth.
-
-        This is used for things like device deletion and password reset where
-        the user already has a valid access token, but we want to double-check
-        that it isn't stolen by re-authenticating them.
-
-        Args:
-            requester (Requester): The user, as given by the access token
-
-            request_body (dict): The body of the request sent by the client
-
-            clientip (str): The IP address of the client.
-
-        Returns:
-            defer.Deferred[dict]: the parameters for this request (which may
-                have been given only in a previous call).
-
-        Raises:
-            InteractiveAuthIncompleteError if the client has not yet completed
-                any of the permitted login flows
-
-            AuthError if the client has completed a login flow, and it gives
-                a different user to `requester`
-        """
-
-        # build a list of supported flows
-        flows = [
-            [login_type] for login_type in self._supported_login_types
-        ]
-
-        result, params, _ = yield self.check_auth(
-            flows, request_body, clientip,
-        )
-
-        # find the completed login type
-        for login_type in self._supported_login_types:
-            if login_type not in result:
-                continue
-
-            user_id = result[login_type]
-            break
-        else:
-            # this can't happen
-            raise Exception(
-                "check_auth returned True but no successful login type",
-            )
-
-        # check that the UI auth matched the access token
-        if user_id != requester.user.to_string():
-            raise AuthError(403, "Invalid auth")
-
-        defer.returnValue(params)
+                login_types.update(
+                    provider.get_supported_login_types().keys()
+                )
+        self._supported_login_types = frozenset(login_types)

    @defer.inlineCallbacks
    def check_auth(self, flows, clientdict, clientip):
@@ -159,36 +95,26 @@ class AuthHandler(BaseHandler):
        session with a map, which maps each auth-type (str) to the relevant
        identity authenticated by that auth-type (mostly str, but for captcha, bool).

-        If no auth flows have been completed successfully, raises an
-        InteractiveAuthIncompleteError. To handle this, you can use
-        synapse.rest.client.v2_alpha._base.interactive_auth_handler as a
-        decorator.
-
        Args:
            flows (list): A list of login flows. Each flow is an ordered list of
                          strings representing auth-types. At least one full
                          flow must be completed in order for auth to be successful.
-
            clientdict: The dictionary from the client root level, not the
                        'auth' key: this method prompts for auth if none is sent.
-
            clientip (str): The IP address of the client.
-
        Returns:
-            defer.Deferred[dict, dict, str]: a deferred tuple of
-                (creds, params, session_id).
+            A tuple of (authed, dict, dict, session_id) where authed is true if
+            the client has successfully completed an auth flow. If it is true
+            the first dict contains the authenticated credentials of each stage.

-                'creds' contains the authenticated credentials of each stage.
+            If authed is false, the first dictionary is the server response to
+            the login request and should be passed back to the client.

-                'params' contains the parameters for this request (which may
-                have been given only in a previous call).
+            In either case, the second dict contains the parameters for this
+            request (which may have been given only in a previous call).

-                'session_id' is the ID of this session, either passed in by the
-                client or assigned by this call
-
-        Raises:
-            InteractiveAuthIncompleteError if the client has not yet completed
-                all the stages in any of the permitted flows.
+            session_id is the ID of this session, either passed in by the client
+            or assigned by the call to check_auth
        """

        authdict = None
@@ -216,8 +142,11 @@ class AuthHandler(BaseHandler):
            clientdict = session['clientdict']

        if not authdict:
-            raise InteractiveAuthIncompleteError(
-                self._auth_dict_for_flows(flows, session),
+            defer.returnValue(
+                (
+                    False, self._auth_dict_for_flows(flows, session),
+                    clientdict, session['id']
+                )
            )

        if 'creds' not in session:
@@ -228,12 +157,14 @@ class AuthHandler(BaseHandler):
        errordict = {}
        if 'type' in authdict:
            login_type = authdict['type']
+            if login_type not in self.checkers:
+                raise LoginError(400, "", Codes.UNRECOGNIZED)
            try:
-                result = yield self._check_auth_dict(authdict, clientip)
+                result = yield self.checkers[login_type](authdict, clientip)
                if result:
                    creds[login_type] = result
                    self._save_session(session)
-            except LoginError as e:
+            except LoginError, e:
                if login_type == LoginType.EMAIL_IDENTITY:
                    # riot used to have a bug where it would request a new
                    # validation token (thus sending a new email) each time it
@@ -242,7 +173,7 @@ class AuthHandler(BaseHandler):
                    #
                    # Grandfather in the old behaviour for now to avoid
                    # breaking old riot deployments.
-                    raise
+                    raise e

                # this step failed. Merge the error dict into the response
                # so that the client can have another go.
@@ -259,14 +190,12 @@ class AuthHandler(BaseHandler):
                    "Auth completed with creds: %r. Client dict has keys: %r",
                    creds, clientdict.keys()
                )
-                defer.returnValue((creds, clientdict, session['id']))
+                defer.returnValue((True, creds, clientdict, session['id']))

        ret = self._auth_dict_for_flows(flows, session)
        ret['completed'] = creds.keys()
        ret.update(errordict)
-        raise InteractiveAuthIncompleteError(
-            ret,
-        )
+        defer.returnValue((False, ret, clientdict, session['id']))

    @defer.inlineCallbacks
    def add_oob_auth(self, stagetype, authdict, clientip):
@@ -339,35 +268,17 @@ class AuthHandler(BaseHandler):
        return sess.setdefault('serverdict', {}).get(key, default)

    @defer.inlineCallbacks
-    def _check_auth_dict(self, authdict, clientip):
-        """Attempt to validate the auth dict provided by a client
+    def _check_password_auth(self, authdict, _):
+        if "user" not in authdict or "password" not in authdict:
+            raise LoginError(400, "", Codes.MISSING_PARAM)

-        Args:
-            authdict (object): auth dict provided by the client
-            clientip (str): IP address of the client
+        user_id = authdict["user"]
+        password = authdict["password"]

-        Returns:
-            Deferred: result of the stage verification.
-
-        Raises:
-            StoreError if there was a problem accessing the database
-            SynapseError if there was a problem with the request
-            LoginError if there was an authentication problem.
-        """
-        login_type = authdict['type']
-        checker = self.checkers.get(login_type)
-        if checker is not None:
-            res = yield checker(authdict, clientip)
-            defer.returnValue(res)
-
-        # build a v1-login-style dict out of the authdict and fall back to the
-        # v1 code
-        user_id = authdict.get("user")
-
-        if user_id is None:
-            raise SynapseError(400, "", Codes.MISSING_PARAM)
-
-        (canonical_id, callback) = yield self.validate_login(user_id, authdict)
+        (canonical_id, callback) = yield self.validate_login(user_id, {
+            "type": LoginType.PASSWORD,
+            "password": password,
+        })
        defer.returnValue(canonical_id)

    @defer.inlineCallbacks
@@ -640,7 +551,7 @@ class AuthHandler(BaseHandler):
                    qualified_user_id, password,
                )
                if is_valid:
-                    defer.returnValue((qualified_user_id, None))
+                    defer.returnValue(qualified_user_id)

            if (not hasattr(provider, "get_supported_login_types")
                    or not hasattr(provider, "check_auth")):
@@ -715,7 +626,7 @@ class AuthHandler(BaseHandler):
        if not lookupres:
            defer.returnValue(None)
        (user_id, password_hash) = lookupres
-        result = yield self.validate_hash(password, password_hash)
+        result = self.validate_hash(password, password_hash)
        if not result:
            logger.warn("Failed password login for user %s", user_id)
            defer.returnValue(None)
@@ -738,6 +649,41 @@ class AuthHandler(BaseHandler):
        except Exception:
            raise AuthError(403, "Invalid token", errcode=Codes.FORBIDDEN)

+    @defer.inlineCallbacks
+    def set_password(self, user_id, newpassword, requester=None):
+        password_hash = self.hash(newpassword)
+
+        except_access_token_id = requester.access_token_id if requester else None
+
+        try:
+            yield self.store.user_set_password_hash(user_id, password_hash)
+        except StoreError as e:
+            if e.code == 404:
+                raise SynapseError(404, "Unknown user", Codes.NOT_FOUND)
+            raise e
+        yield self.delete_access_tokens_for_user(
+            user_id, except_token_id=except_access_token_id,
+        )
+        yield self.hs.get_pusherpool().remove_pushers_by_user(
+            user_id, except_access_token_id
+        )
+
+    @defer.inlineCallbacks
+    def deactivate_account(self, user_id):
+        """Deactivate a user's account
+
+        Args:
+            user_id (str): ID of user to be deactivated
+
+        Returns:
+            Deferred
+        """
+        # FIXME: Theoretically there is a race here wherein user resets
+        # password using threepid.
+        yield self.delete_access_tokens_for_user(user_id)
+        yield self.store.user_delete_threepids(user_id)
+        yield self.store.user_set_password_hash(user_id, None)
+
    @defer.inlineCallbacks
    def delete_access_token(self, access_token):
        """Invalidate a single access token
@@ -760,12 +706,6 @@ class AuthHandler(BaseHandler):
                    access_token=access_token,
                )

-        # delete pushers associated with this access token
-        if user_info["token_id"] is not None:
-            yield self.hs.get_pusherpool().remove_pushers_by_access_token(
-                str(user_info["user"]), (user_info["token_id"], )
-            )
-
    @defer.inlineCallbacks
    def delete_access_tokens_for_user(self, user_id, except_token_id=None,
                                      device_id=None):
@@ -788,18 +728,13 @@ class AuthHandler(BaseHandler):
        # see if any of our auth providers want to know about this
        for provider in self.password_providers:
            if hasattr(provider, "on_logged_out"):
-                for token, token_id, device_id in tokens_and_devices:
+                for token, device_id in tokens_and_devices:
                    yield provider.on_logged_out(
                        user_id=user_id,
                        device_id=device_id,
                        access_token=token,
                    )

-        # delete pushers associated with the access tokens
-        yield self.hs.get_pusherpool().remove_pushers_by_access_token(
-            user_id, (token_id for _, token_id, _ in tokens_and_devices),
-        )
-
    @defer.inlineCallbacks
    def add_threepid(self, user_id, medium, address, validated_at):
        # 'Canonicalise' email addresses down to lower case.
@@ -843,13 +778,10 @@ class AuthHandler(BaseHandler):
            password (str): Password to hash.

        Returns:
-            Deferred(str): Hashed password.
+            Hashed password (str).
        """
-        def _do_hash():
-            return bcrypt.hashpw(password.encode('utf8') + self.hs.config.password_pepper,
-                                 bcrypt.gensalt(self.bcrypt_rounds))
-
-        return make_deferred_yieldable(threads.deferToThread(_do_hash))
+        return bcrypt.hashpw(password.encode('utf8') + self.hs.config.password_pepper,
+                             bcrypt.gensalt(self.bcrypt_rounds))

    def validate_hash(self, password, stored_hash):
        """Validates that self.hash(password) == stored_hash.
@@ -859,19 +791,13 @@ class AuthHandler(BaseHandler):
            stored_hash (str): Expected hash value.

        Returns:
-            Deferred(bool): Whether self.hash(password) == stored_hash.
+            Whether self.hash(password) == stored_hash (bool).
        """
-
-        def _do_validate_hash():
-            return bcrypt.checkpw(
-                password.encode('utf8') + self.hs.config.password_pepper,
-                stored_hash.encode('utf8')
-            )
-
        if stored_hash:
-            return make_deferred_yieldable(threads.deferToThread(_do_validate_hash))
+            return bcrypt.hashpw(password.encode('utf8') + self.hs.config.password_pepper,
+                                 stored_hash.encode('utf8')) == stored_hash
        else:
-            return defer.succeed(False)
+            return False


 class MacaroonGeneartor(object):
--- a/synapse/handlers/deactivate_account.py
+++ b/synapse/handlers/deactivate_account.py
@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2017 New Vector 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.
-from twisted.internet import defer
-
-from ._base import BaseHandler
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class DeactivateAccountHandler(BaseHandler):
-    """Handler which deals with deactivating user accounts."""
-    def __init__(self, hs):
-        super(DeactivateAccountHandler, self).__init__(hs)
-        self._auth_handler = hs.get_auth_handler()
-        self._device_handler = hs.get_device_handler()
-
-    @defer.inlineCallbacks
-    def deactivate_account(self, user_id):
-        """Deactivate a user's account
-
-        Args:
-            user_id (str): ID of user to be deactivated
-
-        Returns:
-            Deferred
-        """
-        # FIXME: Theoretically there is a race here wherein user resets
-        # password using threepid.
-
-        # first delete any devices belonging to the user, which will also
-        # delete corresponding access tokens.
-        yield self._device_handler.delete_all_devices_for_user(user_id)
-        # then delete any remaining access tokens which weren't associated with
-        # a device.
-        yield self._auth_handler.delete_access_tokens_for_user(user_id)
-
-        yield self.store.user_delete_threepids(user_id)
-        yield self.store.user_set_password_hash(user_id, None)
--- a/synapse/handlers/device.py
+++ b/synapse/handlers/device.py
@@ -14,7 +14,6 @@
 # limitations under the License.
 from synapse.api import errors
 from synapse.api.constants import EventTypes
-from synapse.api.errors import FederationDeniedError
 from synapse.util import stringutils
 from synapse.util.async import Linearizer
 from synapse.util.caches.expiringcache import ExpiringCache
@@ -37,15 +36,14 @@ class DeviceHandler(BaseHandler):
        self.state = hs.get_state_handler()
        self._auth_handler = hs.get_auth_handler()
        self.federation_sender = hs.get_federation_sender()
+        self.federation = hs.get_replication_layer()

        self._edu_updater = DeviceListEduUpdater(hs, self)

-        federation_registry = hs.get_federation_registry()
-
-        federation_registry.register_edu_handler(
+        self.federation.register_edu_handler(
            "m.device_list_update", self._edu_updater.incoming_device_list_update,
        )
-        federation_registry.register_query_handler(
+        self.federation.register_query_handler(
            "user_devices", self.on_federation_query_user_devices,
        )

@@ -172,31 +170,13 @@ class DeviceHandler(BaseHandler):

        yield self.notify_device_update(user_id, [device_id])

-    @defer.inlineCallbacks
-    def delete_all_devices_for_user(self, user_id, except_device_id=None):
-        """Delete all of the user's devices
-
-        Args:
-            user_id (str):
-            except_device_id (str|None): optional device id which should not
-                be deleted
-
-        Returns:
-            defer.Deferred:
-        """
-        device_map = yield self.store.get_devices_by_user(user_id)
-        device_ids = device_map.keys()
-        if except_device_id is not None:
-            device_ids = [d for d in device_ids if d != except_device_id]
-        yield self.delete_devices(user_id, device_ids)
-
    @defer.inlineCallbacks
    def delete_devices(self, user_id, device_ids):
        """ Delete several devices

        Args:
            user_id (str):
-            device_ids (List[str]): The list of device IDs to delete
+            device_ids (str): The list of device IDs to delete

        Returns:
            defer.Deferred:
@@ -431,7 +411,7 @@ class DeviceListEduUpdater(object):

    def __init__(self, hs, device_handler):
        self.store = hs.get_datastore()
-        self.federation = hs.get_federation_client()
+        self.federation = hs.get_replication_layer()
        self.clock = hs.get_clock()
        self.device_handler = device_handler

@@ -515,9 +495,6 @@ class DeviceListEduUpdater(object):
                    # This makes it more likely that the device lists will
                    # eventually become consistent.
                    return
-                except FederationDeniedError as e:
-                    logger.info(e)
-                    return
                except Exception:
                    # TODO: Remember that we are now out of sync and try again
                    # later
--- a/synapse/handlers/devicemessage.py
+++ b/synapse/handlers/devicemessage.py
@@ -17,8 +17,7 @@ import logging

 from twisted.internet import defer

-from synapse.api.errors import SynapseError
-from synapse.types import get_domain_from_id, UserID
+from synapse.types import get_domain_from_id
 from synapse.util.stringutils import random_string


@@ -34,10 +33,10 @@ class DeviceMessageHandler(object):
        """
        self.store = hs.get_datastore()
        self.notifier = hs.get_notifier()
-        self.is_mine = hs.is_mine
+        self.is_mine_id = hs.is_mine_id
        self.federation = hs.get_federation_sender()

-        hs.get_federation_registry().register_edu_handler(
+        hs.get_replication_layer().register_edu_handler(
            "m.direct_to_device", self.on_direct_to_device_edu
        )

@@ -53,12 +52,6 @@ class DeviceMessageHandler(object):
        message_type = content["type"]
        message_id = content["message_id"]
        for user_id, by_device in content["messages"].items():
-            # we use UserID.from_string to catch invalid user ids
-            if not self.is_mine(UserID.from_string(user_id)):
-                logger.warning("Request for keys for non-local user %s",
-                               user_id)
-                raise SynapseError(400, "Not a user here")
-
            messages_by_device = {
                device_id: {
                    "content": message_content,
@@ -84,8 +77,7 @@ class DeviceMessageHandler(object):
        local_messages = {}
        remote_messages = {}
        for user_id, by_device in messages.items():
-            # we use UserID.from_string to catch invalid user ids
-            if self.is_mine(UserID.from_string(user_id)):
+            if self.is_mine_id(user_id):
                messages_by_device = {
                    device_id: {
                        "content": message_content,
--- a/synapse/handlers/directory.py
+++ b/synapse/handlers/directory.py
@@ -34,10 +34,9 @@ class DirectoryHandler(BaseHandler):

        self.state = hs.get_state_handler()
        self.appservice_handler = hs.get_application_service_handler()
-        self.event_creation_handler = hs.get_event_creation_handler()

-        self.federation = hs.get_federation_client()
-        hs.get_federation_registry().register_query_handler(
+        self.federation = hs.get_replication_layer()
+        self.federation.register_query_handler(
            "directory", self.on_directory_query
        )

@@ -250,7 +249,8 @@ class DirectoryHandler(BaseHandler):
    def send_room_alias_update_event(self, requester, user_id, room_id):
        aliases = yield self.store.get_aliases_for_room(room_id)

-        yield self.event_creation_handler.create_and_send_nonmember_event(
+        msg_handler = self.hs.get_handlers().message_handler
+        yield msg_handler.create_and_send_nonmember_event(
            requester,
            {
                "type": EventTypes.Aliases,
@@ -272,7 +272,8 @@ class DirectoryHandler(BaseHandler):
        if not alias_event or alias_event.content.get("alias", "") != alias_str:
            return

-        yield self.event_creation_handler.create_and_send_nonmember_event(
+        msg_handler = self.hs.get_handlers().message_handler
+        yield msg_handler.create_and_send_nonmember_event(
            requester,
            {
                "type": EventTypes.CanonicalAlias,
--- a/synapse/handlers/e2e_keys.py
+++ b/synapse/handlers/e2e_keys.py
@@ -13,16 +13,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-import simplejson as json
+import ujson as json
 import logging

 from canonicaljson import encode_canonical_json
 from twisted.internet import defer

-from synapse.api.errors import (
-    SynapseError, CodeMessageException, FederationDeniedError,
-)
-from synapse.types import get_domain_from_id, UserID
+from synapse.api.errors import SynapseError, CodeMessageException
+from synapse.types import get_domain_from_id
 from synapse.util.logcontext import preserve_fn, make_deferred_yieldable
 from synapse.util.retryutils import NotRetryingDestination

@@ -32,15 +30,15 @@ logger = logging.getLogger(__name__)
 class E2eKeysHandler(object):
    def __init__(self, hs):
        self.store = hs.get_datastore()
-        self.federation = hs.get_federation_client()
+        self.federation = hs.get_replication_layer()
        self.device_handler = hs.get_device_handler()
-        self.is_mine = hs.is_mine
+        self.is_mine_id = hs.is_mine_id
        self.clock = hs.get_clock()

        # doesn't really work as part of the generic query API, because the
        # query request requires an object POST, but we abuse the
        # "query handler" interface.
-        hs.get_federation_registry().register_query_handler(
+        self.federation.register_query_handler(
            "client_keys", self.on_federation_query_client_keys
        )

@@ -72,8 +70,7 @@ class E2eKeysHandler(object):
        remote_queries = {}

        for user_id, device_ids in device_keys_query.items():
-            # we use UserID.from_string to catch invalid user ids
-            if self.is_mine(UserID.from_string(user_id)):
+            if self.is_mine_id(user_id):
                local_query[user_id] = device_ids
            else:
                remote_queries[user_id] = device_ids
@@ -142,10 +139,6 @@ class E2eKeysHandler(object):
                failures[destination] = {
                    "status": 503, "message": "Not ready for retry",
                }
-            except FederationDeniedError as e:
-                failures[destination] = {
-                    "status": 403, "message": "Federation Denied",
-                }
            except Exception as e:
                # include ConnectionRefused and other errors
                failures[destination] = {
@@ -177,8 +170,7 @@ class E2eKeysHandler(object):

        result_dict = {}
        for user_id, device_ids in query.items():
-            # we use UserID.from_string to catch invalid user ids
-            if not self.is_mine(UserID.from_string(user_id)):
+            if not self.is_mine_id(user_id):
                logger.warning("Request for keys for non-local user %s",
                               user_id)
                raise SynapseError(400, "Not a user here")
@@ -221,8 +213,7 @@ class E2eKeysHandler(object):
        remote_queries = {}

        for user_id, device_keys in query.get("one_time_keys", {}).items():
-            # we use UserID.from_string to catch invalid user ids
-            if self.is_mine(UserID.from_string(user_id)):
+            if self.is_mine_id(user_id):
                for device_id, algorithm in device_keys.items():
                    local_query.append((user_id, device_id, algorithm))
            else:
--- a/synapse/handlers/federation.py
+++ b/synapse/handlers/federation.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 # Copyright 2014-2016 OpenMarket Ltd
-# Copyright 2018 New Vector Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,7 +22,6 @@ from ._base import BaseHandler

 from synapse.api.errors import (
    AuthError, FederationError, StoreError, CodeMessageException, SynapseError,
-    FederationDeniedError,
 )
 from synapse.api.constants import EventTypes, Membership, RejectedReason
 from synapse.events.validator import EventValidator
@@ -68,7 +66,7 @@ class FederationHandler(BaseHandler):
        self.hs = hs

        self.store = hs.get_datastore()
-        self.replication_layer = hs.get_federation_client()
+        self.replication_layer = hs.get_replication_layer()
        self.state_handler = hs.get_state_handler()
        self.server_name = hs.hostname
        self.keyring = hs.get_keyring()
@@ -76,7 +74,8 @@ class FederationHandler(BaseHandler):
        self.is_mine_id = hs.is_mine_id
        self.pusher_pool = hs.get_pusherpool()
        self.spam_checker = hs.get_spam_checker()
-        self.event_creation_handler = hs.get_event_creation_handler()
+
+        self.replication_layer.set_handler(self)

        # When joining a room we need to queue any events for that room up
        self.room_queues = {}
@@ -783,9 +782,6 @@ class FederationHandler(BaseHandler):
                except NotRetryingDestination as e:
                    logger.info(e.message)
                    continue
-                except FederationDeniedError as e:
-                    logger.info(e)
-                    continue
                except Exception as e:
                    logger.exception(
                        "Failed to backfill from %s because %s",
@@ -808,12 +804,13 @@ class FederationHandler(BaseHandler):
        event_ids = list(extremities.keys())

        logger.debug("calling resolve_state_groups in _maybe_backfill")
-        resolve = logcontext.preserve_fn(
-            self.state_handler.resolve_state_groups_for_events
-        )
        states = yield logcontext.make_deferred_yieldable(defer.gatherResults(
-            [resolve(room_id, [e]) for e in event_ids],
-            consumeErrors=True,
+            [
+                logcontext.preserve_fn(self.state_handler.resolve_state_groups)(
+                    room_id, [e]
+                )
+                for e in event_ids
+            ], consumeErrors=True,
        ))
        states = dict(zip(event_ids, [s.state for s in states]))

@@ -1007,7 +1004,8 @@ class FederationHandler(BaseHandler):
        })

        try:
-            event, context = yield self.event_creation_handler.create_new_client_event(
+            message_handler = self.hs.get_handlers().message_handler
+            event, context = yield message_handler._create_new_client_event(
                builder=builder,
            )
        except AuthError as e:
@@ -1247,7 +1245,8 @@ class FederationHandler(BaseHandler):
            "state_key": user_id,
        })

-        event, context = yield self.event_creation_handler.create_new_client_event(
+        message_handler = self.hs.get_handlers().message_handler
+        event, context = yield message_handler._create_new_client_event(
            builder=builder,
        )

@@ -1445,24 +1444,16 @@ class FederationHandler(BaseHandler):
            auth_events=auth_events,
        )

-        try:
-            if not event.internal_metadata.is_outlier() and not backfilled:
-                yield self.action_generator.handle_push_actions_for_event(
-                    event, context
-                )
-
-            event_stream_id, max_stream_id = yield self.store.persist_event(
-                event,
-                context=context,
-                backfilled=backfilled,
+        if not event.internal_metadata.is_outlier() and not backfilled:
+            yield self.action_generator.handle_push_actions_for_event(
+                event, context
            )
-        except:  # noqa: E722, as we reraise the exception this is fine.
-            # Ensure that we actually remove the entries in the push actions
-            # staging area
-            logcontext.preserve_fn(
-                self.store.remove_push_actions_from_staging
-            )(event.event_id)
-            raise
+
+        event_stream_id, max_stream_id = yield self.store.persist_event(
+            event,
+            context=context,
+            backfilled=backfilled,
+        )

        if not backfilled:
            # this intentionally does not yield: we don't care about the result
@@ -1715,17 +1706,6 @@ class FederationHandler(BaseHandler):
    @defer.inlineCallbacks
    @log_function
    def do_auth(self, origin, event, context, auth_events):
-        """
-
-        Args:
-            origin (str):
-            event (synapse.events.FrozenEvent):
-            context (synapse.events.snapshot.EventContext):
-            auth_events (dict[(str, str)->str]):
-
-        Returns:
-            defer.Deferred[None]
-        """
        # Check if we have all the auth events.
        current_state = set(e.event_id for e in auth_events.values())
        event_auth_events = set(e_id for e_id, _ in event.auth_events)
@@ -1837,9 +1817,16 @@ class FederationHandler(BaseHandler):
                current_state = set(e.event_id for e in auth_events.values())
                different_auth = event_auth_events - current_state

-                yield self._update_context_for_auth_events(
-                    event, context, auth_events, event_key,
-                )
+                context.current_state_ids = dict(context.current_state_ids)
+                context.current_state_ids.update({
+                    k: a.event_id for k, a in auth_events.items()
+                    if k != event_key
+                })
+                context.prev_state_ids = dict(context.prev_state_ids)
+                context.prev_state_ids.update({
+                    k: a.event_id for k, a in auth_events.items()
+                })
+                context.state_group = self.store.get_next_state_group()

        if different_auth and not event.internal_metadata.is_outlier():
            logger.info("Different auth after resolution: %s", different_auth)
@@ -1919,9 +1906,16 @@ class FederationHandler(BaseHandler):
                # 4. Look at rejects and their proofs.
                # TODO.

-                yield self._update_context_for_auth_events(
-                    event, context, auth_events, event_key,
-                )
+                context.current_state_ids = dict(context.current_state_ids)
+                context.current_state_ids.update({
+                    k: a.event_id for k, a in auth_events.items()
+                    if k != event_key
+                })
+                context.prev_state_ids = dict(context.prev_state_ids)
+                context.prev_state_ids.update({
+                    k: a.event_id for k, a in auth_events.items()
+                })
+                context.state_group = self.store.get_next_state_group()

        try:
            self.auth.check(event, auth_events=auth_events)
@@ -1929,45 +1923,6 @@ class FederationHandler(BaseHandler):
            logger.warn("Failed auth resolution for %r because %s", event, e)
            raise e

-    @defer.inlineCallbacks
-    def _update_context_for_auth_events(self, event, context, auth_events,
-                                        event_key):
-        """Update the state_ids in an event context after auth event resolution,
-        storing the changes as a new state group.
-
-        Args:
-            event (Event): The event we're handling the context for
-
-            context (synapse.events.snapshot.EventContext): event context
-                to be updated
-
-            auth_events (dict[(str, str)->str]): Events to update in the event
-                context.
-
-            event_key ((str, str)): (type, state_key) for the current event.
-                this will not be included in the current_state in the context.
-        """
-        state_updates = {
-            k: a.event_id for k, a in auth_events.iteritems()
-            if k != event_key
-        }
-        context.current_state_ids = dict(context.current_state_ids)
-        context.current_state_ids.update(state_updates)
-        if context.delta_ids is not None:
-            context.delta_ids = dict(context.delta_ids)
-            context.delta_ids.update(state_updates)
-        context.prev_state_ids = dict(context.prev_state_ids)
-        context.prev_state_ids.update({
-            k: a.event_id for k, a in auth_events.iteritems()
-        })
-        context.state_group = yield self.store.store_state_group(
-            event.event_id,
-            event.room_id,
-            prev_group=context.prev_group,
-            delta_ids=context.delta_ids,
-            current_state_ids=context.current_state_ids,
-        )
-
    @defer.inlineCallbacks
    def construct_auth_difference(self, local_auth, remote_auth):
        """ Given a local and remote auth chain, find the differences. This
@@ -2136,7 +2091,8 @@ class FederationHandler(BaseHandler):
        if (yield self.auth.check_host_in_room(room_id, self.hs.hostname)):
            builder = self.event_builder_factory.new(event_dict)
            EventValidator().validate_new(builder)
-            event, context = yield self.event_creation_handler.create_new_client_event(
+            message_handler = self.hs.get_handlers().message_handler
+            event, context = yield message_handler._create_new_client_event(
                builder=builder
            )

@@ -2151,7 +2107,7 @@ class FederationHandler(BaseHandler):
                raise e

            yield self._check_signature(event, context)
-            member_handler = self.hs.get_room_member_handler()
+            member_handler = self.hs.get_handlers().room_member_handler
            yield member_handler.send_membership_event(None, event, context)
        else:
            destinations = set(x.split(":", 1)[-1] for x in (sender_user_id, room_id))
@@ -2174,7 +2130,8 @@ class FederationHandler(BaseHandler):
        """
        builder = self.event_builder_factory.new(event_dict)

-        event, context = yield self.event_creation_handler.create_new_client_event(
+        message_handler = self.hs.get_handlers().message_handler
+        event, context = yield message_handler._create_new_client_event(
            builder=builder,
        )

@@ -2195,7 +2152,7 @@ class FederationHandler(BaseHandler):
        # TODO: Make sure the signatures actually are correct.
        event.signatures.update(returned_invite.signatures)

-        member_handler = self.hs.get_room_member_handler()
+        member_handler = self.hs.get_handlers().room_member_handler
        yield member_handler.send_membership_event(None, event, context)

    @defer.inlineCallbacks
@@ -2224,9 +2181,8 @@ class FederationHandler(BaseHandler):

        builder = self.event_builder_factory.new(event_dict)
        EventValidator().validate_new(builder)
-        event, context = yield self.event_creation_handler.create_new_client_event(
-            builder=builder,
-        )
+        message_handler = self.hs.get_handlers().message_handler
+        event, context = yield message_handler._create_new_client_event(builder=builder)
        defer.returnValue((event, context))

    @defer.inlineCallbacks
--- a/synapse/handlers/groups_local.py
+++ b/synapse/handlers/groups_local.py
@@ -70,9 +70,8 @@ class GroupsLocalHandler(object):

    get_invited_users_in_group = _create_rerouter("get_invited_users_in_group")

-    add_room_to_group = _create_rerouter("add_room_to_group")
-    update_room_in_group = _create_rerouter("update_room_in_group")
-    remove_room_from_group = _create_rerouter("remove_room_from_group")
+    update_room_group_association = _create_rerouter("update_room_group_association")
+    delete_room_group_association = _create_rerouter("delete_room_group_association")

    update_group_summary_room = _create_rerouter("update_group_summary_room")
    delete_group_summary_room = _create_rerouter("delete_group_summary_room")
@@ -375,20 +374,13 @@ class GroupsLocalHandler(object):
    def get_publicised_groups_for_user(self, user_id):
        if self.hs.is_mine_id(user_id):
            result = yield self.store.get_publicised_groups_for_user(user_id)
-
-            # Check AS associated groups for this user - this depends on the
-            # RegExps in the AS registration file (under `users`)
-            for app_service in self.store.get_app_services():
-                result.extend(app_service.get_groups_for_user(user_id))
-
            defer.returnValue({"groups": result})
        else:
-            bulk_result = yield self.transport_client.bulk_get_publicised_groups(
-                get_domain_from_id(user_id), [user_id],
+            result = yield self.transport_client.get_publicised_groups_for_user(
+                get_domain_from_id(user_id), user_id
            )
-            result = bulk_result.get("users", {}).get(user_id)
            # TODO: Verify attestations
-            defer.returnValue({"groups": result})
+            defer.returnValue(result)

    @defer.inlineCallbacks
    def bulk_get_publicised_groups(self, user_ids, proxy=True):
@@ -422,9 +414,4 @@ class GroupsLocalHandler(object):
                uid
            )

-            # Check AS associated groups for this user - this depends on the
-            # RegExps in the AS registration file (under `users`)
-            for app_service in self.store.get_app_services():
-                results[uid].extend(app_service.get_groups_for_user(uid))
-
        defer.returnValue({"users": results})
--- a/synapse/handlers/initial_sync.py
+++ b/synapse/handlers/initial_sync.py
@@ -27,7 +27,7 @@ from synapse.types import (
 from synapse.util import unwrapFirstError
 from synapse.util.async import concurrently_execute
 from synapse.util.caches.snapshot_cache import SnapshotCache
-from synapse.util.logcontext import make_deferred_yieldable, preserve_fn
+from synapse.util.logcontext import preserve_fn, preserve_context_over_deferred
 from synapse.visibility import filter_events_for_client

 from ._base import BaseHandler
@@ -163,7 +163,7 @@ class InitialSyncHandler(BaseHandler):
                        lambda states: states[event.event_id]
                    )

-                (messages, token), current_state = yield make_deferred_yieldable(
+                (messages, token), current_state = yield preserve_context_over_deferred(
                    defer.gatherResults(
                        [
                            preserve_fn(self.store.get_recent_events_for_room)(
--- a/synapse/handlers/message.py
+++ b/synapse/handlers/message.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 # Copyright 2014 - 2016 OpenMarket Ltd
-# Copyright 2017 - 2018 New Vector Ltd
+# Copyright 2017 New Vector Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,8 +13,7 @@
 # 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.
-from twisted.internet import defer, reactor
-from twisted.python.failure import Failure
+from twisted.internet import defer

 from synapse.api.constants import EventTypes, Membership
 from synapse.api.errors import AuthError, Codes, SynapseError
@@ -25,12 +24,10 @@ from synapse.types import (
    UserID, RoomAlias, RoomStreamToken,
 )
 from synapse.util.async import run_on_reactor, ReadWriteLock, Limiter
-from synapse.util.logcontext import preserve_fn, run_in_background
+from synapse.util.logcontext import preserve_fn
 from synapse.util.metrics import measure_func
 from synapse.util.frozenutils import unfreeze
-from synapse.util.stringutils import random_string
 from synapse.visibility import filter_events_for_client
-from synapse.replication.http.send_event import send_event_to_master

 from ._base import BaseHandler

@@ -38,41 +35,11 @@ from canonicaljson import encode_canonical_json

 import logging
 import random
-import simplejson
+import ujson

 logger = logging.getLogger(__name__)


-class PurgeStatus(object):
-    """Object tracking the status of a purge request
-
-    This class contains information on the progress of a purge request, for
-    return by get_purge_status.
-
-    Attributes:
-        status (int): Tracks whether this request has completed. One of
-            STATUS_{ACTIVE,COMPLETE,FAILED}
-    """
-
-    STATUS_ACTIVE = 0
-    STATUS_COMPLETE = 1
-    STATUS_FAILED = 2
-
-    STATUS_TEXT = {
-        STATUS_ACTIVE: "active",
-        STATUS_COMPLETE: "complete",
-        STATUS_FAILED: "failed",
-    }
-
-    def __init__(self):
-        self.status = PurgeStatus.STATUS_ACTIVE
-
-    def asdict(self):
-        return {
-            "status": PurgeStatus.STATUS_TEXT[self.status]
-        }
-
-
 class MessageHandler(BaseHandler):

    def __init__(self, hs):
@@ -80,89 +47,32 @@ class MessageHandler(BaseHandler):
        self.hs = hs
        self.state = hs.get_state_handler()
        self.clock = hs.get_clock()
+        self.validator = EventValidator()
+        self.profile_handler = hs.get_profile_handler()

        self.pagination_lock = ReadWriteLock()
-        self._purges_in_progress_by_room = set()
-        # map from purge id to PurgeStatus
-        self._purges_by_id = {}

-    def start_purge_history(self, room_id, topological_ordering,
-                            delete_local_events=False):
-        """Start off a history purge on a room.
+        self.pusher_pool = hs.get_pusherpool()

-        Args:
-            room_id (str): The room to purge from
+        # We arbitrarily limit concurrent event creation for a room to 5.
+        # This is to stop us from diverging history *too* much.
+        self.limiter = Limiter(max_count=5)

-            topological_ordering (int): minimum topo ordering to preserve
-            delete_local_events (bool): True to delete local events as well as
-                remote ones
+        self.action_generator = hs.get_action_generator()

-        Returns:
-            str: unique ID for this purge transaction.
-        """
-        if room_id in self._purges_in_progress_by_room:
-            raise SynapseError(
-                400,
-                "History purge already in progress for %s" % (room_id, ),
-            )
-
-        purge_id = random_string(16)
-
-        # we log the purge_id here so that it can be tied back to the
-        # request id in the log lines.
-        logger.info("[purge] starting purge_id %s", purge_id)
-
-        self._purges_by_id[purge_id] = PurgeStatus()
-        run_in_background(
-            self._purge_history,
-            purge_id, room_id, topological_ordering, delete_local_events,
-        )
-        return purge_id
+        self.spam_checker = hs.get_spam_checker()

    @defer.inlineCallbacks
-    def _purge_history(self, purge_id, room_id, topological_ordering,
-                       delete_local_events):
-        """Carry out a history purge on a room.
+    def purge_history(self, room_id, event_id):
+        event = yield self.store.get_event(event_id)

-        Args:
-            purge_id (str): The id for this purge
-            room_id (str): The room to purge from
-            topological_ordering (int): minimum topo ordering to preserve
-            delete_local_events (bool): True to delete local events as well as
-                remote ones
+        if event.room_id != room_id:
+            raise SynapseError(400, "Event is for wrong room.")

-        Returns:
-            Deferred
-        """
-        self._purges_in_progress_by_room.add(room_id)
-        try:
-            with (yield self.pagination_lock.write(room_id)):
-                yield self.store.purge_history(
-                    room_id, topological_ordering, delete_local_events,
-                )
-            logger.info("[purge] complete")
-            self._purges_by_id[purge_id].status = PurgeStatus.STATUS_COMPLETE
-        except Exception:
-            logger.error("[purge] failed: %s", Failure().getTraceback().rstrip())
-            self._purges_by_id[purge_id].status = PurgeStatus.STATUS_FAILED
-        finally:
-            self._purges_in_progress_by_room.discard(room_id)
+        depth = event.depth

-            # remove the purge from the list 24 hours after it completes
-            def clear_purge():
-                del self._purges_by_id[purge_id]
-            reactor.callLater(24 * 3600, clear_purge)
-
-    def get_purge_status(self, purge_id):
-        """Get the current status of an active purge
-
-        Args:
-            purge_id (str): purge_id returned by start_purge_history
-
-        Returns:
-            PurgeStatus|None
-        """
-        return self._purges_by_id.get(purge_id)
+        with (yield self.pagination_lock.write(room_id)):
+            yield self.store.delete_old_state(room_id, depth)

    @defer.inlineCallbacks
    def get_messages(self, requester, room_id=None, pagin_config=None,
@@ -272,6 +182,166 @@ class MessageHandler(BaseHandler):

        defer.returnValue(chunk)

+    @defer.inlineCallbacks
+    def create_event(self, requester, event_dict, token_id=None, txn_id=None,
+                     prev_event_ids=None):
+        """
+        Given a dict from a client, create a new event.
+
+        Creates an FrozenEvent object, filling out auth_events, prev_events,
+        etc.
+
+        Adds display names to Join membership events.
+
+        Args:
+            requester
+            event_dict (dict): An entire event
+            token_id (str)
+            txn_id (str)
+            prev_event_ids (list): The prev event ids to use when creating the event
+
+        Returns:
+            Tuple of created event (FrozenEvent), Context
+        """
+        builder = self.event_builder_factory.new(event_dict)
+
+        with (yield self.limiter.queue(builder.room_id)):
+            self.validator.validate_new(builder)
+
+            if builder.type == EventTypes.Member:
+                membership = builder.content.get("membership", None)
+                target = UserID.from_string(builder.state_key)
+
+                if membership in {Membership.JOIN, Membership.INVITE}:
+                    # If event doesn't include a display name, add one.
+                    profile = self.profile_handler
+                    content = builder.content
+
+                    try:
+                        if "displayname" not in content:
+                            content["displayname"] = yield profile.get_displayname(target)
+                        if "avatar_url" not in content:
+                            content["avatar_url"] = yield profile.get_avatar_url(target)
+                    except Exception as e:
+                        logger.info(
+                            "Failed to get profile information for %r: %s",
+                            target, e
+                        )
+
+            if token_id is not None:
+                builder.internal_metadata.token_id = token_id
+
+            if txn_id is not None:
+                builder.internal_metadata.txn_id = txn_id
+
+            event, context = yield self._create_new_client_event(
+                builder=builder,
+                requester=requester,
+                prev_event_ids=prev_event_ids,
+            )
+
+        defer.returnValue((event, context))
+
+    @defer.inlineCallbacks
+    def send_nonmember_event(self, requester, event, context, ratelimit=True):
+        """
+        Persists and notifies local clients and federation of an event.
+
+        Args:
+            event (FrozenEvent) the event to send.
+            context (Context) the context of the event.
+            ratelimit (bool): Whether to rate limit this send.
+            is_guest (bool): Whether the sender is a guest.
+        """
+        if event.type == EventTypes.Member:
+            raise SynapseError(
+                500,
+                "Tried to send member event through non-member codepath"
+            )
+
+        # We check here if we are currently being rate limited, so that we
+        # don't do unnecessary work. We check again just before we actually
+        # send the event.
+        yield self.ratelimit(requester, update=False)
+
+        user = UserID.from_string(event.sender)
+
+        assert self.hs.is_mine(user), "User must be our own: %s" % (user,)
+
+        if event.is_state():
+            prev_state = yield self.deduplicate_state_event(event, context)
+            if prev_state is not None:
+                defer.returnValue(prev_state)
+
+        yield self.handle_new_client_event(
+            requester=requester,
+            event=event,
+            context=context,
+            ratelimit=ratelimit,
+        )
+
+        if event.type == EventTypes.Message:
+            presence = self.hs.get_presence_handler()
+            # We don't want to block sending messages on any presence code. This
+            # matters as sometimes presence code can take a while.
+            preserve_fn(presence.bump_presence_active_time)(user)
+
+    @defer.inlineCallbacks
+    def deduplicate_state_event(self, event, context):
+        """
+        Checks whether event is in the latest resolved state in context.
+
+        If so, returns the version of the event in context.
+        Otherwise, returns None.
+        """
+        prev_event_id = context.prev_state_ids.get((event.type, event.state_key))
+        prev_event = yield self.store.get_event(prev_event_id, allow_none=True)
+        if not prev_event:
+            return
+
+        if prev_event and event.user_id == prev_event.user_id:
+            prev_content = encode_canonical_json(prev_event.content)
+            next_content = encode_canonical_json(event.content)
+            if prev_content == next_content:
+                defer.returnValue(prev_event)
+        return
+
+    @defer.inlineCallbacks
+    def create_and_send_nonmember_event(
+        self,
+        requester,
+        event_dict,
+        ratelimit=True,
+        txn_id=None
+    ):
+        """
+        Creates an event, then sends it.
+
+        See self.create_event and self.send_nonmember_event.
+        """
+        event, context = yield self.create_event(
+            requester,
+            event_dict,
+            token_id=requester.access_token_id,
+            txn_id=txn_id
+        )
+
+        spam_error = self.spam_checker.check_event_for_spam(event)
+        if spam_error:
+            if not isinstance(spam_error, basestring):
+                spam_error = "Spam is not permitted here"
+            raise SynapseError(
+                403, spam_error, Codes.FORBIDDEN
+            )
+
+        yield self.send_nonmember_event(
+            requester,
+            event,
+            context,
+            ratelimit=ratelimit,
+        )
+        defer.returnValue(event)
+
    @defer.inlineCallbacks
    def get_room_data(self, user_id=None, room_id=None,
                      event_type=None, state_key="", is_guest=False):
@@ -400,189 +470,9 @@ class MessageHandler(BaseHandler):
            for user_id, profile in users_with_profile.iteritems()
        })

-
-class EventCreationHandler(object):
-    def __init__(self, hs):
-        self.hs = hs
-        self.auth = hs.get_auth()
-        self.store = hs.get_datastore()
-        self.state = hs.get_state_handler()
-        self.clock = hs.get_clock()
-        self.validator = EventValidator()
-        self.profile_handler = hs.get_profile_handler()
-        self.event_builder_factory = hs.get_event_builder_factory()
-        self.server_name = hs.hostname
-        self.ratelimiter = hs.get_ratelimiter()
-        self.notifier = hs.get_notifier()
-        self.config = hs.config
-
-        self.http_client = hs.get_simple_http_client()
-
-        # This is only used to get at ratelimit function, and maybe_kick_guest_users
-        self.base_handler = BaseHandler(hs)
-
-        self.pusher_pool = hs.get_pusherpool()
-
-        # We arbitrarily limit concurrent event creation for a room to 5.
-        # This is to stop us from diverging history *too* much.
-        self.limiter = Limiter(max_count=5)
-
-        self.action_generator = hs.get_action_generator()
-
-        self.spam_checker = hs.get_spam_checker()
-
+    @measure_func("_create_new_client_event")
    @defer.inlineCallbacks
-    def create_event(self, requester, event_dict, token_id=None, txn_id=None,
-                     prev_event_ids=None):
-        """
-        Given a dict from a client, create a new event.
-
-        Creates an FrozenEvent object, filling out auth_events, prev_events,
-        etc.
-
-        Adds display names to Join membership events.
-
-        Args:
-            requester
-            event_dict (dict): An entire event
-            token_id (str)
-            txn_id (str)
-            prev_event_ids (list): The prev event ids to use when creating the event
-
-        Returns:
-            Tuple of created event (FrozenEvent), Context
-        """
-        builder = self.event_builder_factory.new(event_dict)
-
-        with (yield self.limiter.queue(builder.room_id)):
-            self.validator.validate_new(builder)
-
-            if builder.type == EventTypes.Member:
-                membership = builder.content.get("membership", None)
-                target = UserID.from_string(builder.state_key)
-
-                if membership in {Membership.JOIN, Membership.INVITE}:
-                    # If event doesn't include a display name, add one.
-                    profile = self.profile_handler
-                    content = builder.content
-
-                    try:
-                        if "displayname" not in content:
-                            content["displayname"] = yield profile.get_displayname(target)
-                        if "avatar_url" not in content:
-                            content["avatar_url"] = yield profile.get_avatar_url(target)
-                    except Exception as e:
-                        logger.info(
-                            "Failed to get profile information for %r: %s",
-                            target, e
-                        )
-
-            if token_id is not None:
-                builder.internal_metadata.token_id = token_id
-
-            if txn_id is not None:
-                builder.internal_metadata.txn_id = txn_id
-
-            event, context = yield self.create_new_client_event(
-                builder=builder,
-                requester=requester,
-                prev_event_ids=prev_event_ids,
-            )
-
-        defer.returnValue((event, context))
-
-    @defer.inlineCallbacks
-    def send_nonmember_event(self, requester, event, context, ratelimit=True):
-        """
-        Persists and notifies local clients and federation of an event.
-
-        Args:
-            event (FrozenEvent) the event to send.
-            context (Context) the context of the event.
-            ratelimit (bool): Whether to rate limit this send.
-            is_guest (bool): Whether the sender is a guest.
-        """
-        if event.type == EventTypes.Member:
-            raise SynapseError(
-                500,
-                "Tried to send member event through non-member codepath"
-            )
-
-        user = UserID.from_string(event.sender)
-
-        assert self.hs.is_mine(user), "User must be our own: %s" % (user,)
-
-        if event.is_state():
-            prev_state = yield self.deduplicate_state_event(event, context)
-            if prev_state is not None:
-                defer.returnValue(prev_state)
-
-        yield self.handle_new_client_event(
-            requester=requester,
-            event=event,
-            context=context,
-            ratelimit=ratelimit,
-        )
-
-    @defer.inlineCallbacks
-    def deduplicate_state_event(self, event, context):
-        """
-        Checks whether event is in the latest resolved state in context.
-
-        If so, returns the version of the event in context.
-        Otherwise, returns None.
-        """
-        prev_event_id = context.prev_state_ids.get((event.type, event.state_key))
-        prev_event = yield self.store.get_event(prev_event_id, allow_none=True)
-        if not prev_event:
-            return
-
-        if prev_event and event.user_id == prev_event.user_id:
-            prev_content = encode_canonical_json(prev_event.content)
-            next_content = encode_canonical_json(event.content)
-            if prev_content == next_content:
-                defer.returnValue(prev_event)
-        return
-
-    @defer.inlineCallbacks
-    def create_and_send_nonmember_event(
-        self,
-        requester,
-        event_dict,
-        ratelimit=True,
-        txn_id=None
-    ):
-        """
-        Creates an event, then sends it.
-
-        See self.create_event and self.send_nonmember_event.
-        """
-        event, context = yield self.create_event(
-            requester,
-            event_dict,
-            token_id=requester.access_token_id,
-            txn_id=txn_id
-        )
-
-        spam_error = self.spam_checker.check_event_for_spam(event)
-        if spam_error:
-            if not isinstance(spam_error, basestring):
-                spam_error = "Spam is not permitted here"
-            raise SynapseError(
-                403, spam_error, Codes.FORBIDDEN
-            )
-
-        yield self.send_nonmember_event(
-            requester,
-            event,
-            context,
-            ratelimit=ratelimit,
-        )
-        defer.returnValue(event)
-
-    @measure_func("create_new_client_event")
-    @defer.inlineCallbacks
-    def create_new_client_event(self, builder, requester=None, prev_event_ids=None):
+    def _create_new_client_event(self, builder, requester=None, prev_event_ids=None):
        if prev_event_ids:
            prev_events = yield self.store.add_event_hashes(prev_event_ids)
            prev_max_depth = yield self.store.get_max_depth_of_events(prev_event_ids)
@@ -619,7 +509,9 @@ class EventCreationHandler(object):
        builder.prev_events = prev_events
        builder.depth = depth

-        context = yield self.state.compute_event_context(builder)
+        state_handler = self.state_handler
+
+        context = yield state_handler.compute_event_context(builder)
        if requester:
            context.app_service = requester.app_service

@@ -654,21 +546,12 @@ class EventCreationHandler(object):
        event,
        context,
        ratelimit=True,
-        extra_users=[],
+        extra_users=[]
    ):
-        """Processes a new event. This includes checking auth, persisting it,
-        notifying users, sending to remote servers, etc.
+        # We now need to go and hit out to wherever we need to hit out to.

-        If called from a worker will hit out to the master process for final
-        processing.
-
-        Args:
-            requester (Requester)
-            event (FrozenEvent)
-            context (EventContext)
-            ratelimit (bool)
-            extra_users (list(UserID)): Any extra users to notify about event
-        """
+        if ratelimit:
+            yield self.ratelimit(requester)

        try:
            yield self.auth.check_from_context(event, context)
@@ -678,64 +561,13 @@ class EventCreationHandler(object):

        # Ensure that we can round trip before trying to persist in db
        try:
-            dump = simplejson.dumps(unfreeze(event.content))
-            simplejson.loads(dump)
+            dump = ujson.dumps(unfreeze(event.content))
+            ujson.loads(dump)
        except Exception:
            logger.exception("Failed to encode content: %r", event.content)
            raise

-        yield self.action_generator.handle_push_actions_for_event(
-            event, context
-        )
-
-        try:
-            # If we're a worker we need to hit out to the master.
-            if self.config.worker_app:
-                yield send_event_to_master(
-                    self.http_client,
-                    host=self.config.worker_replication_host,
-                    port=self.config.worker_replication_http_port,
-                    requester=requester,
-                    event=event,
-                    context=context,
-                    ratelimit=ratelimit,
-                    extra_users=extra_users,
-                )
-                return
-
-            yield self.persist_and_notify_client_event(
-                requester,
-                event,
-                context,
-                ratelimit=ratelimit,
-                extra_users=extra_users,
-            )
-        except:  # noqa: E722, as we reraise the exception this is fine.
-            # Ensure that we actually remove the entries in the push actions
-            # staging area, if we calculated them.
-            preserve_fn(self.store.remove_push_actions_from_staging)(event.event_id)
-            raise
-
-    @defer.inlineCallbacks
-    def persist_and_notify_client_event(
-        self,
-        requester,
-        event,
-        context,
-        ratelimit=True,
-        extra_users=[],
-    ):
-        """Called when we have fully built the event, have already
-        calculated the push actions for the event, and checked auth.
-
-        This should only be run on master.
-        """
-        assert not self.config.worker_app
-
-        if ratelimit:
-            yield self.base_handler.ratelimit(requester)
-
-        yield self.base_handler.maybe_kick_guest_users(event, context)
+        yield self.maybe_kick_guest_users(event, context)

        if event.type == EventTypes.CanonicalAlias:
            # Check the alias is acually valid (at this time at least)
@@ -828,6 +660,10 @@ class EventCreationHandler(object):
                "Changing the room create event is forbidden",
            )

+        yield self.action_generator.handle_push_actions_for_event(
+            event, context
+        )
+
        (event_stream_id, max_stream_id) = yield self.store.persist_event(
            event, context=context
        )
@@ -847,9 +683,3 @@ class EventCreationHandler(object):
            )

        preserve_fn(_notify)()
-
-        if event.type == EventTypes.Message:
-            presence = self.hs.get_presence_handler()
-            # We don't want to block sending messages on any presence code. This
-            # matters as sometimes presence code can take a while.
-            preserve_fn(presence.bump_presence_active_time)(requester.user)
--- a/synapse/handlers/presence.py
+++ b/synapse/handlers/presence.py
@@ -93,30 +93,29 @@ class PresenceHandler(object):
        self.store = hs.get_datastore()
        self.wheel_timer = WheelTimer()
        self.notifier = hs.get_notifier()
+        self.replication = hs.get_replication_layer()
        self.federation = hs.get_federation_sender()

        self.state = hs.get_state_handler()

-        federation_registry = hs.get_federation_registry()
-
-        federation_registry.register_edu_handler(
+        self.replication.register_edu_handler(
            "m.presence", self.incoming_presence
        )
-        federation_registry.register_edu_handler(
+        self.replication.register_edu_handler(
            "m.presence_invite",
            lambda origin, content: self.invite_presence(
                observed_user=UserID.from_string(content["observed_user"]),
                observer_user=UserID.from_string(content["observer_user"]),
            )
        )
-        federation_registry.register_edu_handler(
+        self.replication.register_edu_handler(
            "m.presence_accept",
            lambda origin, content: self.accept_presence(
                observed_user=UserID.from_string(content["observed_user"]),
                observer_user=UserID.from_string(content["observer_user"]),
            )
        )
-        federation_registry.register_edu_handler(
+        self.replication.register_edu_handler(
            "m.presence_deny",
            lambda origin, content: self.deny_presence(
                observed_user=UserID.from_string(content["observed_user"]),
@@ -1200,7 +1199,7 @@ def handle_timeout(state, is_mine, syncing_user_ids, now):
                )
                changed = True
    else:
-        # We expect to be poked occasionally by the other side.
+        # We expect to be poked occaisonally by the other side.
        # This is to protect against forgetful/buggy servers, so that
        # no one gets stuck online forever.
        if now - state.last_federation_update_ts > FEDERATION_TIMEOUT:
--- a/synapse/handlers/profile.py
+++ b/synapse/handlers/profile.py
@@ -17,6 +17,7 @@ import logging

 from twisted.internet import defer

+import synapse.types
 from synapse.api.errors import SynapseError, AuthError, CodeMessageException
 from synapse.types import UserID, get_domain_from_id
 from ._base import BaseHandler
@@ -31,17 +32,12 @@ class ProfileHandler(BaseHandler):
    def __init__(self, hs):
        super(ProfileHandler, self).__init__(hs)

-        self.federation = hs.get_federation_client()
-        hs.get_federation_registry().register_query_handler(
+        self.federation = hs.get_replication_layer()
+        self.federation.register_query_handler(
            "profile", self.on_profile_query
        )

-        self.user_directory_handler = hs.get_user_directory_handler()
-
-        if hs.config.worker_app is None:
-            self.clock.looping_call(
-                self._update_remote_profile_cache, self.PROFILE_UPDATE_MS,
-            )
+        self.clock.looping_call(self._update_remote_profile_cache, self.PROFILE_UPDATE_MS)

    @defer.inlineCallbacks
    def get_profile(self, user_id):
@@ -144,13 +140,7 @@ class ProfileHandler(BaseHandler):
            target_user.localpart, new_displayname
        )

-        if self.hs.config.user_directory_search_all_users:
-            profile = yield self.store.get_profileinfo(target_user.localpart)
-            yield self.user_directory_handler.handle_local_profile_change(
-                target_user.to_string(), profile
-            )
-
-        yield self._update_join_states(requester, target_user)
+        yield self._update_join_states(requester)

    @defer.inlineCallbacks
    def get_avatar_url(self, target_user):
@@ -194,13 +184,7 @@ class ProfileHandler(BaseHandler):
            target_user.localpart, new_avatar_url
        )

-        if self.hs.config.user_directory_search_all_users:
-            profile = yield self.store.get_profileinfo(target_user.localpart)
-            yield self.user_directory_handler.handle_local_profile_change(
-                target_user.to_string(), profile
-            )
-
-        yield self._update_join_states(requester, target_user)
+        yield self._update_join_states(requester)

    @defer.inlineCallbacks
    def on_profile_query(self, args):
@@ -225,24 +209,28 @@ class ProfileHandler(BaseHandler):
        defer.returnValue(response)

    @defer.inlineCallbacks
-    def _update_join_states(self, requester, target_user):
-        if not self.hs.is_mine(target_user):
+    def _update_join_states(self, requester):
+        user = requester.user
+        if not self.hs.is_mine(user):
            return

        yield self.ratelimit(requester)

        room_ids = yield self.store.get_rooms_for_user(
-            target_user.to_string(),
+            user.to_string(),
        )

        for room_id in room_ids:
-            handler = self.hs.get_room_member_handler()
+            handler = self.hs.get_handlers().room_member_handler
            try:
-                # Assume the target_user isn't a guest,
-                # because we don't let guests set profile or avatar data.
+                # Assume the user isn't a guest because we don't let guests set
+                # profile or avatar data.
+                # XXX why are we recreating `requester` here for each room?
+                # what was wrong with the `requester` we were passed?
+                requester = synapse.types.create_requester(user)
                yield handler.update_membership(
                    requester,
-                    target_user,
+                    user,
                    room_id,
                    "join",  # We treat a profile update like a join.
                    ratelimit=False,  # Try to hide that these events aren't atomic.
--- a/synapse/handlers/read_marker.py
+++ b/synapse/handlers/read_marker.py
@@ -41,9 +41,9 @@ class ReadMarkerHandler(BaseHandler):
        """

        with (yield self.read_marker_linearizer.queue((room_id, user_id))):
-            existing_read_marker = yield self.store.get_account_data_for_room_and_type(
-                user_id, room_id, "m.fully_read",
-            )
+            account_data = yield self.store.get_account_data_for_room(user_id, room_id)
+
+            existing_read_marker = account_data.get("m.fully_read", None)

            should_update = True

--- a/synapse/handlers/receipts.py
+++ b/synapse/handlers/receipts.py
@@ -35,7 +35,7 @@ class ReceiptsHandler(BaseHandler):
        self.store = hs.get_datastore()
        self.hs = hs
        self.federation = hs.get_federation_sender()
-        hs.get_federation_registry().register_edu_handler(
+        hs.get_replication_layer().register_edu_handler(
            "m.receipt", self._received_remote_receipt
        )
        self.clock = self.hs.get_clock()
--- a/synapse/handlers/register.py
+++ b/synapse/handlers/register.py
@@ -25,7 +25,6 @@ from synapse.http.client import CaptchaServerHttpClient
 from synapse import types
 from synapse.types import UserID
 from synapse.util.async import run_on_reactor
-from synapse.util.threepids import check_3pid_allowed
 from ._base import BaseHandler

 logger = logging.getLogger(__name__)
@@ -39,7 +38,6 @@ class RegistrationHandler(BaseHandler):
        self.auth = hs.get_auth()
        self._auth_handler = hs.get_auth_handler()
        self.profile_handler = hs.get_profile_handler()
-        self.user_directory_handler = hs.get_user_directory_handler()
        self.captcha_client = CaptchaServerHttpClient(hs)

        self._next_generated_user_id = None
@@ -132,7 +130,7 @@ class RegistrationHandler(BaseHandler):
        yield run_on_reactor()
        password_hash = None
        if password:
-            password_hash = yield self.auth_handler().hash(password)
+            password_hash = self.auth_handler().hash(password)

        if localpart:
            yield self.check_username(localpart, guest_access_token=guest_access_token)
@@ -167,13 +165,6 @@ class RegistrationHandler(BaseHandler):
                ),
                admin=admin,
            )
-
-            if self.hs.config.user_directory_search_all_users:
-                profile = yield self.store.get_profileinfo(localpart)
-                yield self.user_directory_handler.handle_local_profile_change(
-                    user_id, profile
-                )
-
        else:
            # autogen a sequential user ID
            attempts = 0
@@ -294,7 +285,7 @@ class RegistrationHandler(BaseHandler):
        """

        for c in threepidCreds:
-            logger.info("validating threepidcred sid %s on id server %s",
+            logger.info("validating theeepidcred sid %s on id server %s",
                        c['sid'], c['idServer'])
            try:
                identity_handler = self.hs.get_handlers().identity_handler
@@ -308,11 +299,6 @@ class RegistrationHandler(BaseHandler):
            logger.info("got threepid with medium '%s' and address '%s'",
                        threepid['medium'], threepid['address'])

-            if not check_3pid_allowed(self.hs, threepid['medium'], threepid['address']):
-                raise RegistrationError(
-                    403, "Third party identifier is not allowed"
-                )
-
    @defer.inlineCallbacks
    def bind_emails(self, user_id, threepidCreds):
        """Links emails with a user ID and informs an identity server.
@@ -446,34 +432,16 @@ class RegistrationHandler(BaseHandler):
        return self.hs.get_auth_handler()

    @defer.inlineCallbacks
-    def get_or_register_3pid_guest(self, medium, address, inviter_user_id):
-        """Get a guest access token for a 3PID, creating a guest account if
-        one doesn't already exist.
-
-        Args:
-            medium (str)
-            address (str)
-            inviter_user_id (str): The user ID who is trying to invite the
-                3PID
-
-        Returns:
-            Deferred[(str, str)]: A 2-tuple of `(user_id, access_token)` of the
-            3PID guest account.
-        """
+    def guest_access_token_for(self, medium, address, inviter_user_id):
        access_token = yield self.store.get_3pid_guest_access_token(medium, address)
        if access_token:
-            user_info = yield self.auth.get_user_by_access_token(
-                access_token
-            )
+            defer.returnValue(access_token)

-            defer.returnValue((user_info["user"].to_string(), access_token))
-
-        user_id, access_token = yield self.register(
+        _, access_token = yield self.register(
            generate_token=True,
            make_guest=True
        )
        access_token = yield self.store.save_or_get_3pid_guest_access_token(
            medium, address, access_token, inviter_user_id
        )
-
-        defer.returnValue((user_id, access_token))
+        defer.returnValue(access_token)
--- a/synapse/handlers/room.py
+++ b/synapse/handlers/room.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 # Copyright 2014 - 2016 OpenMarket Ltd
-# Copyright 2018 New Vector Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -65,7 +64,6 @@ class RoomCreationHandler(BaseHandler):
        super(RoomCreationHandler, self).__init__(hs)

        self.spam_checker = hs.get_spam_checker()
-        self.event_creation_handler = hs.get_event_creation_handler()

    @defer.inlineCallbacks
    def create_room(self, requester, config, ratelimit=True):
@@ -165,11 +163,13 @@ class RoomCreationHandler(BaseHandler):

        creation_content = config.get("creation_content", {})

-        room_member_handler = self.hs.get_room_member_handler()
+        msg_handler = self.hs.get_handlers().message_handler
+        room_member_handler = self.hs.get_handlers().room_member_handler

        yield self._send_events_for_new_room(
            requester,
            room_id,
+            msg_handler,
            room_member_handler,
            preset_config=preset_config,
            invite_list=invite_list,
@@ -181,7 +181,7 @@ class RoomCreationHandler(BaseHandler):

        if "name" in config:
            name = config["name"]
-            yield self.event_creation_handler.create_and_send_nonmember_event(
+            yield msg_handler.create_and_send_nonmember_event(
                requester,
                {
                    "type": EventTypes.Name,
@@ -194,7 +194,7 @@ class RoomCreationHandler(BaseHandler):

        if "topic" in config:
            topic = config["topic"]
-            yield self.event_creation_handler.create_and_send_nonmember_event(
+            yield msg_handler.create_and_send_nonmember_event(
                requester,
                {
                    "type": EventTypes.Topic,
@@ -205,12 +205,12 @@ class RoomCreationHandler(BaseHandler):
                },
                ratelimit=False)

-        for invitee in invite_list:
-            content = {}
-            is_direct = config.get("is_direct", None)
-            if is_direct:
-                content["is_direct"] = is_direct
+        content = {}
+        is_direct = config.get("is_direct", None)
+        if is_direct:
+            content["is_direct"] = is_direct

+        for invitee in invite_list:
            yield room_member_handler.update_membership(
                requester,
                UserID.from_string(invitee),
@@ -224,7 +224,7 @@ class RoomCreationHandler(BaseHandler):
            id_server = invite_3pid["id_server"]
            address = invite_3pid["address"]
            medium = invite_3pid["medium"]
-            yield self.hs.get_room_member_handler().do_3pid_invite(
+            yield self.hs.get_handlers().room_member_handler.do_3pid_invite(
                room_id,
                requester.user,
                medium,
@@ -249,6 +249,7 @@ class RoomCreationHandler(BaseHandler):
            self,
            creator,  # A Requester object.
            room_id,
+            msg_handler,
            room_member_handler,
            preset_config,
            invite_list,
@@ -271,7 +272,7 @@ class RoomCreationHandler(BaseHandler):
        @defer.inlineCallbacks
        def send(etype, content, **kwargs):
            event = create(etype, content, **kwargs)
-            yield self.event_creation_handler.create_and_send_nonmember_event(
+            yield msg_handler.create_and_send_nonmember_event(
                creator,
                event,
                ratelimit=False
@@ -475,9 +476,12 @@ class RoomEventSource(object):
            user.to_string()
        )
        if app_service:
-            # We no longer support AS users using /sync directly.
-            # See https://github.com/matrix-org/matrix-doc/issues/1144
-            raise NotImplementedError()
+            events, end_key = yield self.store.get_appservice_room_stream(
+                service=app_service,
+                from_key=from_key,
+                to_key=to_key,
+                limit=limit,
+            )
        else:
            room_events = yield self.store.get_membership_changes_for_user(
                user.to_string(), from_key, to_key
--- a/synapse/handlers/room_list.py
+++ b/synapse/handlers/room_list.py
@@ -154,8 +154,6 @@ class RoomListHandler(BaseHandler):
            # We want larger rooms to be first, hence negating num_joined_users
            rooms_to_order_value[room_id] = (-num_joined_users, room_id)

-        logger.info("Getting ordering for %i rooms since %s",
-                    len(room_ids), stream_token)
        yield concurrently_execute(get_order_for_room, room_ids, 10)

        sorted_entries = sorted(rooms_to_order_value.items(), key=lambda e: e[1])
@@ -183,43 +181,34 @@ class RoomListHandler(BaseHandler):
                rooms_to_scan = rooms_to_scan[:since_token.current_limit]
                rooms_to_scan.reverse()

-        logger.info("After sorting and filtering, %i rooms remain",
-                    len(rooms_to_scan))
-
-        # _append_room_entry_to_chunk will append to chunk but will stop if
-        # len(chunk) > limit
-        #
-        # Normally we will generate enough results on the first iteration here,
-        #  but if there is a search filter, _append_room_entry_to_chunk may
-        # filter some results out, in which case we loop again.
-        #
-        # We don't want to scan over the entire range either as that
-        # would potentially waste a lot of work.
-        #
-        # XXX if there is no limit, we may end up DoSing the server with
-        # calls to get_current_state_ids for every single room on the
-        # server. Surely we should cap this somehow?
-        #
-        if limit:
-            step = limit + 1
-        else:
-            # step cannot be zero
-            step = len(rooms_to_scan) if len(rooms_to_scan) != 0 else 1
-
+        # Actually generate the entries. _append_room_entry_to_chunk will append to
+        # chunk but will stop if len(chunk) > limit
        chunk = []
-        for i in xrange(0, len(rooms_to_scan), step):
-            batch = rooms_to_scan[i:i + step]
-            logger.info("Processing %i rooms for result", len(batch))
+        if limit and not search_filter:
+            step = limit + 1
+            for i in xrange(0, len(rooms_to_scan), step):
+                # We iterate here because the vast majority of cases we'll stop
+                # at first iteration, but occaisonally _append_room_entry_to_chunk
+                # won't append to the chunk and so we need to loop again.
+                # We don't want to scan over the entire range either as that
+                # would potentially waste a lot of work.
+                yield concurrently_execute(
+                    lambda r: self._append_room_entry_to_chunk(
+                        r, rooms_to_num_joined[r],
+                        chunk, limit, search_filter
+                    ),
+                    rooms_to_scan[i:i + step], 10
+                )
+                if len(chunk) >= limit + 1:
+                    break
+        else:
            yield concurrently_execute(
                lambda r: self._append_room_entry_to_chunk(
                    r, rooms_to_num_joined[r],
                    chunk, limit, search_filter
                ),
-                batch, 5,
+                rooms_to_scan, 5
            )
-            logger.info("Now %i rooms in result", len(chunk))
-            if len(chunk) >= limit + 1:
-                break

        chunk.sort(key=lambda e: (-e["num_joined_members"], e["room_id"]))

@@ -409,7 +398,7 @@ class RoomListHandler(BaseHandler):
    def _get_remote_list_cached(self, server_name, limit=None, since_token=None,
                                search_filter=None, include_all_networks=False,
                                third_party_instance_id=None,):
-        repl_layer = self.hs.get_federation_client()
+        repl_layer = self.hs.get_replication_layer()
        if search_filter:
            # We can't cache when asking for search
            return repl_layer.get_public_rooms(
--- a/synapse/handlers/room_member.py
+++ b/synapse/handlers/room_member.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 # Copyright 2016 OpenMarket Ltd
-# Copyright 2018 New Vector Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-import abc
+
 import logging

 from signedjson.key import decode_verify_key_bytes
@@ -30,121 +29,32 @@ from synapse.api.errors import AuthError, SynapseError, Codes
 from synapse.types import UserID, RoomID
 from synapse.util.async import Linearizer
 from synapse.util.distributor import user_left_room, user_joined_room
-
+from ._base import BaseHandler

 logger = logging.getLogger(__name__)

 id_server_scheme = "https://"


-class RoomMemberHandler(object):
+class RoomMemberHandler(BaseHandler):
    # TODO(paul): This handler currently contains a messy conflation of
    #   low-level API that works on UserID objects and so on, and REST-level
    #   API that takes ID strings and returns pagination chunks. These concerns
    #   ought to be separated out a lot better.

-    __metaclass__ = abc.ABCMeta
-
    def __init__(self, hs):
-        self.hs = hs
-        self.store = hs.get_datastore()
-        self.auth = hs.get_auth()
-        self.state_handler = hs.get_state_handler()
-        self.config = hs.config
-        self.simple_http_client = hs.get_simple_http_client()
+        super(RoomMemberHandler, self).__init__(hs)

-        self.federation_handler = hs.get_handlers().federation_handler
-        self.directory_handler = hs.get_handlers().directory_handler
-        self.registration_handler = hs.get_handlers().registration_handler
        self.profile_handler = hs.get_profile_handler()
-        self.event_creation_hander = hs.get_event_creation_handler()

        self.member_linearizer = Linearizer(name="member")

        self.clock = hs.get_clock()
        self.spam_checker = hs.get_spam_checker()

-    @abc.abstractmethod
-    def _remote_join(self, requester, remote_room_hosts, room_id, user, content):
-        """Try and join a room that this server is not in
-
-        Args:
-            requester (Requester)
-            remote_room_hosts (list[str]): List of servers that can be used
-                to join via.
-            room_id (str): Room that we are trying to join
-            user (UserID): User who is trying to join
-            content (dict): A dict that should be used as the content of the
-                join event.
-
-        Returns:
-            Deferred
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def _remote_reject_invite(self, remote_room_hosts, room_id, target):
-        """Attempt to reject an invite for a room this server is not in. If we
-        fail to do so we locally mark the invite as rejected.
-
-        Args:
-            requester (Requester)
-            remote_room_hosts (list[str]): List of servers to use to try and
-                reject invite
-            room_id (str)
-            target (UserID): The user rejecting the invite
-
-        Returns:
-            Deferred[dict]: A dictionary to be returned to the client, may
-            include event_id etc, or nothing if we locally rejected
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def get_or_register_3pid_guest(self, requester, medium, address, inviter_user_id):
-        """Get a guest access token for a 3PID, creating a guest account if
-        one doesn't already exist.
-
-        Args:
-            requester (Requester)
-            medium (str)
-            address (str)
-            inviter_user_id (str): The user ID who is trying to invite the
-                3PID
-
-        Returns:
-            Deferred[(str, str)]: A 2-tuple of `(user_id, access_token)` of the
-            3PID guest account.
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def _user_joined_room(self, target, room_id):
-        """Notifies distributor on master process that the user has joined the
-        room.
-
-        Args:
-            target (UserID)
-            room_id (str)
-
-        Returns:
-            Deferred|None
-        """
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def _user_left_room(self, target, room_id):
-        """Notifies distributor on master process that the user has left the
-        room.
-
-        Args:
-            target (UserID)
-            room_id (str)
-
-        Returns:
-            Deferred|None
-        """
-        raise NotImplementedError()
+        self.distributor = hs.get_distributor()
+        self.distributor.declare("user_joined_room")
+        self.distributor.declare("user_left_room")

    @defer.inlineCallbacks
    def _local_membership_update(
@@ -156,12 +66,13 @@ class RoomMemberHandler(object):
    ):
        if content is None:
            content = {}
+        msg_handler = self.hs.get_handlers().message_handler

        content["membership"] = membership
        if requester.is_guest:
            content["kind"] = "guest"

-        event, context = yield self.event_creation_hander.create_event(
+        event, context = yield msg_handler.create_event(
            requester,
            {
                "type": EventTypes.Member,
@@ -179,14 +90,12 @@ class RoomMemberHandler(object):
        )

        # Check if this event matches the previous membership event for the user.
-        duplicate = yield self.event_creation_hander.deduplicate_state_event(
-            event, context,
-        )
+        duplicate = yield msg_handler.deduplicate_state_event(event, context)
        if duplicate is not None:
            # Discard the new event since this membership change is a no-op.
            defer.returnValue(duplicate)

-        yield self.event_creation_hander.handle_new_client_event(
+        yield msg_handler.handle_new_client_event(
            requester,
            event,
            context,
@@ -208,15 +117,32 @@ class RoomMemberHandler(object):
                prev_member_event = yield self.store.get_event(prev_member_event_id)
                newly_joined = prev_member_event.membership != Membership.JOIN
            if newly_joined:
-                yield self._user_joined_room(target, room_id)
+                yield user_joined_room(self.distributor, target, room_id)
        elif event.membership == Membership.LEAVE:
            if prev_member_event_id:
                prev_member_event = yield self.store.get_event(prev_member_event_id)
                if prev_member_event.membership == Membership.JOIN:
-                    yield self._user_left_room(target, room_id)
+                    user_left_room(self.distributor, target, room_id)

        defer.returnValue(event)

+    @defer.inlineCallbacks
+    def remote_join(self, remote_room_hosts, room_id, user, content):
+        if len(remote_room_hosts) == 0:
+            raise SynapseError(404, "No known servers")
+
+        # 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
+        # need to do the invite/join dance.
+        yield self.hs.get_handlers().federation_handler.do_invite_join(
+            remote_room_hosts,
+            room_id,
+            user.to_string(),
+            content,
+        )
+        yield user_joined_room(self.distributor, user, room_id)
+
    @defer.inlineCallbacks
    def update_membership(
            self,
@@ -263,10 +189,6 @@ class RoomMemberHandler(object):
        content_specified = bool(content)
        if content is None:
            content = {}
-        else:
-            # We do a copy here as we potentially change some keys
-            # later on.
-            content = dict(content)

        effective_membership_state = action
        if action in ["kick", "unban"]:
@@ -275,7 +197,8 @@ class RoomMemberHandler(object):
        # if this is a join with a 3pid signature, we may need to turn a 3pid
        # invite into a normal invite before we can handle the join.
        if third_party_signed is not None:
-            yield self.federation_handler.exchange_third_party_invite(
+            replication = self.hs.get_replication_layer()
+            yield replication.exchange_third_party_invite(
                third_party_signed["sender"],
                target.to_string(),
                room_id,
@@ -296,7 +219,7 @@ class RoomMemberHandler(object):
                requester.user,
            )
            if not is_requester_admin:
-                if self.config.block_non_admin_invites:
+                if self.hs.config.block_non_admin_invites:
                    logger.info(
                        "Blocking invite: user is not admin and non-admin "
                        "invites disabled"
@@ -355,7 +278,7 @@ class RoomMemberHandler(object):
                    raise AuthError(403, "Guest access not allowed")

            if not is_host_in_room:
-                inviter = yield self._get_inviter(target.to_string(), room_id)
+                inviter = yield self.get_inviter(target.to_string(), room_id)
                if inviter and not self.hs.is_mine(inviter):
                    remote_room_hosts.append(inviter.domain)

@@ -369,15 +292,15 @@ class RoomMemberHandler(object):
                if requester.is_guest:
                    content["kind"] = "guest"

-                ret = yield self._remote_join(
-                    requester, remote_room_hosts, room_id, target, content
+                ret = yield self.remote_join(
+                    remote_room_hosts, room_id, target, content
                )
                defer.returnValue(ret)

        elif effective_membership_state == Membership.LEAVE:
            if not is_host_in_room:
                # perhaps we've been invited
-                inviter = yield self._get_inviter(target.to_string(), room_id)
+                inviter = yield self.get_inviter(target.to_string(), room_id)
                if not inviter:
                    raise SynapseError(404, "Not a known room")

@@ -391,10 +314,28 @@ class RoomMemberHandler(object):
                else:
                    # send the rejection to the inviter's HS.
                    remote_room_hosts = remote_room_hosts + [inviter.domain]
-                    res = yield self._remote_reject_invite(
-                        requester, remote_room_hosts, room_id, target,
-                    )
-                    defer.returnValue(res)
+                    fed_handler = self.hs.get_handlers().federation_handler
+                    try:
+                        ret = yield fed_handler.do_remotely_reject_invite(
+                            remote_room_hosts,
+                            room_id,
+                            target.to_string(),
+                        )
+                        defer.returnValue(ret)
+                    except Exception as e:
+                        # if we were unable to reject the exception, just mark
+                        # it as rejected on our end and plough ahead.
+                        #
+                        # The 'except' clause is very broad, but we need to
+                        # capture everything from DNS failures upwards
+                        #
+                        logger.warn("Failed to reject invite: %s", e)
+
+                        yield self.store.locally_reject_invite(
+                            target.to_string(), room_id
+                        )
+
+                        defer.returnValue({})

        res = yield self._local_membership_update(
            requester=requester,
@@ -449,9 +390,8 @@ class RoomMemberHandler(object):
        else:
            requester = synapse.types.create_requester(target_user)

-        prev_event = yield self.event_creation_hander.deduplicate_state_event(
-            event, context,
-        )
+        message_handler = self.hs.get_handlers().message_handler
+        prev_event = yield message_handler.deduplicate_state_event(event, context)
        if prev_event is not None:
            return

@@ -468,7 +408,7 @@ class RoomMemberHandler(object):
            if is_blocked:
                raise SynapseError(403, "This room has been blocked on this server")

-        yield self.event_creation_hander.handle_new_client_event(
+        yield message_handler.handle_new_client_event(
            requester,
            event,
            context,
@@ -490,12 +430,12 @@ class RoomMemberHandler(object):
                prev_member_event = yield self.store.get_event(prev_member_event_id)
                newly_joined = prev_member_event.membership != Membership.JOIN
            if newly_joined:
-                yield self._user_joined_room(target_user, room_id)
+                yield user_joined_room(self.distributor, target_user, room_id)
        elif event.membership == Membership.LEAVE:
            if prev_member_event_id:
                prev_member_event = yield self.store.get_event(prev_member_event_id)
                if prev_member_event.membership == Membership.JOIN:
-                    yield self._user_left_room(target_user, room_id)
+                    user_left_room(self.distributor, target_user, room_id)

    @defer.inlineCallbacks
    def _can_guest_join(self, current_state_ids):
@@ -529,7 +469,7 @@ class RoomMemberHandler(object):
        Raises:
            SynapseError if room alias could not be found.
        """
-        directory_handler = self.directory_handler
+        directory_handler = self.hs.get_handlers().directory_handler
        mapping = yield directory_handler.get_association(room_alias)

        if not mapping:
@@ -541,7 +481,7 @@ class RoomMemberHandler(object):
        defer.returnValue((RoomID.from_string(room_id), servers))

    @defer.inlineCallbacks
-    def _get_inviter(self, user_id, room_id):
+    def get_inviter(self, user_id, room_id):
        invite = yield self.store.get_invite_for_user_in_room(
            user_id=user_id,
            room_id=room_id,
@@ -560,7 +500,7 @@ class RoomMemberHandler(object):
            requester,
            txn_id
    ):
-        if self.config.block_non_admin_invites:
+        if self.hs.config.block_non_admin_invites:
            is_requester_admin = yield self.auth.is_server_admin(
                requester.user,
            )
@@ -607,7 +547,7 @@ class RoomMemberHandler(object):
            str: the matrix ID of the 3pid, or None if it is not recognized.
        """
        try:
-            data = yield self.simple_http_client.get_json(
+            data = yield self.hs.get_simple_http_client().get_json(
                "%s%s/_matrix/identity/api/v1/lookup" % (id_server_scheme, id_server,),
                {
                    "medium": medium,
@@ -618,7 +558,7 @@ class RoomMemberHandler(object):
            if "mxid" in data:
                if "signatures" not in data:
                    raise AuthError(401, "No signatures on 3pid binding")
-                yield self._verify_any_signature(data, id_server)
+                self.verify_any_signature(data, id_server)
                defer.returnValue(data["mxid"])

        except IOError as e:
@@ -626,11 +566,11 @@ class RoomMemberHandler(object):
            defer.returnValue(None)

    @defer.inlineCallbacks
-    def _verify_any_signature(self, data, server_hostname):
+    def verify_any_signature(self, data, server_hostname):
        if server_hostname not in data["signatures"]:
            raise AuthError(401, "No signature from server %s" % (server_hostname,))
        for key_name, signature in data["signatures"][server_hostname].items():
-            key_data = yield self.simple_http_client.get_json(
+            key_data = yield self.hs.get_simple_http_client().get_json(
                "%s%s/_matrix/identity/api/v1/pubkey/%s" %
                (id_server_scheme, server_hostname, key_name,),
            )
@@ -655,7 +595,7 @@ class RoomMemberHandler(object):
            user,
            txn_id
    ):
-        room_state = yield self.state_handler.get_current_state(room_id)
+        room_state = yield self.hs.get_state_handler().get_current_state(room_id)

        inviter_display_name = ""
        inviter_avatar_url = ""
@@ -686,7 +626,6 @@ class RoomMemberHandler(object):

        token, public_keys, fallback_public_key, display_name = (
            yield self._ask_id_server_for_third_party_invite(
-                requester=requester,
                id_server=id_server,
                medium=medium,
                address=address,
@@ -701,7 +640,8 @@ class RoomMemberHandler(object):
            )
        )

-        yield self.event_creation_hander.create_and_send_nonmember_event(
+        msg_handler = self.hs.get_handlers().message_handler
+        yield msg_handler.create_and_send_nonmember_event(
            requester,
            {
                "type": EventTypes.ThirdPartyInvite,
@@ -723,7 +663,6 @@ class RoomMemberHandler(object):
    @defer.inlineCallbacks
    def _ask_id_server_for_third_party_invite(
            self,
-            requester,
            id_server,
            medium,
            address,
@@ -740,7 +679,6 @@ class RoomMemberHandler(object):
        Asks an identity server for a third party invite.

        Args:
-            requester (Requester)
            id_server (str): hostname + optional port for the identity server.
            medium (str): The literal string "email".
            address (str): The third party address being invited.
@@ -782,20 +720,24 @@ class RoomMemberHandler(object):
            "sender_avatar_url": inviter_avatar_url,
        }

-        if self.config.invite_3pid_guest:
-            guest_access_token, guest_user_id = yield self.get_or_register_3pid_guest(
-                requester=requester,
+        if self.hs.config.invite_3pid_guest:
+            registration_handler = self.hs.get_handlers().registration_handler
+            guest_access_token = yield registration_handler.guest_access_token_for(
                medium=medium,
                address=address,
                inviter_user_id=inviter_user_id,
            )

+            guest_user_info = yield self.hs.get_auth().get_user_by_access_token(
+                guest_access_token
+            )
+
            invite_config.update({
                "guest_access_token": guest_access_token,
-                "guest_user_id": guest_user_id,
+                "guest_user_id": guest_user_info["user"].to_string(),
            })

-        data = yield self.simple_http_client.post_urlencoded_get_json(
+        data = yield self.hs.get_simple_http_client().post_urlencoded_get_json(
            is_url,
            invite_config
        )
@@ -817,6 +759,27 @@ class RoomMemberHandler(object):
        display_name = data["display_name"]
        defer.returnValue((token, public_keys, fallback_public_key, display_name))

+    @defer.inlineCallbacks
+    def forget(self, user, room_id):
+        user_id = user.to_string()
+
+        member = yield self.state_handler.get_current_state(
+            room_id=room_id,
+            event_type=EventTypes.Member,
+            state_key=user_id
+        )
+        membership = member.membership if member else None
+
+        if membership is not None and membership not in [
+            Membership.LEAVE, Membership.BAN
+        ]:
+            raise SynapseError(400, "User %s in room %s" % (
+                user_id, room_id
+            ))
+
+        if membership:
+            yield self.store.forget(user_id, room_id)
+
    @defer.inlineCallbacks
    def _is_host_in_room(self, current_state_ids):
        # Have we just created the room, and is this about to be the very
@@ -838,94 +801,3 @@ class RoomMemberHandler(object):
                defer.returnValue(True)

        defer.returnValue(False)
-
-
-class RoomMemberMasterHandler(RoomMemberHandler):
-    def __init__(self, hs):
-        super(RoomMemberMasterHandler, self).__init__(hs)
-
-        self.distributor = hs.get_distributor()
-        self.distributor.declare("user_joined_room")
-        self.distributor.declare("user_left_room")
-
-    @defer.inlineCallbacks
-    def _remote_join(self, requester, remote_room_hosts, room_id, user, content):
-        """Implements RoomMemberHandler._remote_join
-        """
-        if len(remote_room_hosts) == 0:
-            raise SynapseError(404, "No known servers")
-
-        # 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
-        # need to do the invite/join dance.
-        yield self.federation_handler.do_invite_join(
-            remote_room_hosts,
-            room_id,
-            user.to_string(),
-            content,
-        )
-        yield self._user_joined_room(user, room_id)
-
-    @defer.inlineCallbacks
-    def _remote_reject_invite(self, requester, remote_room_hosts, room_id, target):
-        """Implements RoomMemberHandler._remote_reject_invite
-        """
-        fed_handler = self.federation_handler
-        try:
-            ret = yield fed_handler.do_remotely_reject_invite(
-                remote_room_hosts,
-                room_id,
-                target.to_string(),
-            )
-            defer.returnValue(ret)
-        except Exception as e:
-            # if we were unable to reject the exception, just mark
-            # it as rejected on our end and plough ahead.
-            #
-            # The 'except' clause is very broad, but we need to
-            # capture everything from DNS failures upwards
-            #
-            logger.warn("Failed to reject invite: %s", e)
-
-            yield self.store.locally_reject_invite(
-                target.to_string(), room_id
-            )
-            defer.returnValue({})
-
-    def get_or_register_3pid_guest(self, requester, medium, address, inviter_user_id):
-        """Implements RoomMemberHandler.get_or_register_3pid_guest
-        """
-        rg = self.registration_handler
-        return rg.get_or_register_3pid_guest(medium, address, inviter_user_id)
-
-    def _user_joined_room(self, target, room_id):
-        """Implements RoomMemberHandler._user_joined_room
-        """
-        return user_joined_room(self.distributor, target, room_id)
-
-    def _user_left_room(self, target, room_id):
-        """Implements RoomMemberHandler._user_left_room
-        """
-        return user_left_room(self.distributor, target, room_id)
-
-    @defer.inlineCallbacks
-    def forget(self, user, room_id):
-        user_id = user.to_string()
-
-        member = yield self.state_handler.get_current_state(
-            room_id=room_id,
-            event_type=EventTypes.Member,
-            state_key=user_id
-        )
-        membership = member.membership if member else None
-
-        if membership is not None and membership not in [
-            Membership.LEAVE, Membership.BAN
-        ]:
-            raise SynapseError(400, "User %s in room %s" % (
-                user_id, room_id
-            ))
-
-        if membership:
-            yield self.store.forget(user_id, room_id)
--- a/synapse/handlers/room_member_worker.py
+++ b/synapse/handlers/room_member_worker.py
@@ -1,102 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2018 New Vector 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 twisted.internet import defer
-
-from synapse.api.errors import SynapseError
-from synapse.handlers.room_member import RoomMemberHandler
-from synapse.replication.http.membership import (
-    remote_join, remote_reject_invite, get_or_register_3pid_guest,
-    notify_user_membership_change,
-)
-
-
-logger = logging.getLogger(__name__)
-
-
-class RoomMemberWorkerHandler(RoomMemberHandler):
-    @defer.inlineCallbacks
-    def _remote_join(self, requester, remote_room_hosts, room_id, user, content):
-        """Implements RoomMemberHandler._remote_join
-        """
-        if len(remote_room_hosts) == 0:
-            raise SynapseError(404, "No known servers")
-
-        ret = yield remote_join(
-            self.simple_http_client,
-            host=self.config.worker_replication_host,
-            port=self.config.worker_replication_http_port,
-            requester=requester,
-            remote_room_hosts=remote_room_hosts,
-            room_id=room_id,
-            user_id=user.to_string(),
-            content=content,
-        )
-
-        yield self._user_joined_room(user, room_id)
-
-        defer.returnValue(ret)
-
-    def _remote_reject_invite(self, requester, remote_room_hosts, room_id, target):
-        """Implements RoomMemberHandler._remote_reject_invite
-        """
-        return remote_reject_invite(
-            self.simple_http_client,
-            host=self.config.worker_replication_host,
-            port=self.config.worker_replication_http_port,
-            requester=requester,
-            remote_room_hosts=remote_room_hosts,
-            room_id=room_id,
-            user_id=target.to_string(),
-        )
-
-    def _user_joined_room(self, target, room_id):
-        """Implements RoomMemberHandler._user_joined_room
-        """
-        return notify_user_membership_change(
-            self.simple_http_client,
-            host=self.config.worker_replication_host,
-            port=self.config.worker_replication_http_port,
-            user_id=target.to_string(),
-            room_id=room_id,
-            change="joined",
-        )
-
-    def _user_left_room(self, target, room_id):
-        """Implements RoomMemberHandler._user_left_room
-        """
-        return notify_user_membership_change(
-            self.simple_http_client,
-            host=self.config.worker_replication_host,
-            port=self.config.worker_replication_http_port,
-            user_id=target.to_string(),
-            room_id=room_id,
-            change="left",
-        )
-
-    def get_or_register_3pid_guest(self, requester, medium, address, inviter_user_id):
-        """Implements RoomMemberHandler.get_or_register_3pid_guest
-        """
-        return get_or_register_3pid_guest(
-            self.simple_http_client,
-            host=self.config.worker_replication_host,
-            port=self.config.worker_replication_http_port,
-            requester=requester,
-            medium=medium,
-            address=address,
-            inviter_user_id=inviter_user_id,
-        )
--- a/synapse/handlers/set_password.py
+++ b/synapse/handlers/set_password.py
@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2017 New Vector 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 twisted.internet import defer
-
-from synapse.api.errors import Codes, StoreError, SynapseError
-from ._base import BaseHandler
-
-logger = logging.getLogger(__name__)
-
-
-class SetPasswordHandler(BaseHandler):
-    """Handler which deals with changing user account passwords"""
-    def __init__(self, hs):
-        super(SetPasswordHandler, self).__init__(hs)
-        self._auth_handler = hs.get_auth_handler()
-        self._device_handler = hs.get_device_handler()
-
-    @defer.inlineCallbacks
-    def set_password(self, user_id, newpassword, requester=None):
-        password_hash = yield self._auth_handler.hash(newpassword)
-
-        except_device_id = requester.device_id if requester else None
-        except_access_token_id = requester.access_token_id if requester else None
-
-        try:
-            yield self.store.user_set_password_hash(user_id, password_hash)
-        except StoreError as e:
-            if e.code == 404:
-                raise SynapseError(404, "Unknown user", Codes.NOT_FOUND)
-            raise e
-
-        # we want to log out all of the user's other sessions. First delete
-        # all his other devices.
-        yield self._device_handler.delete_all_devices_for_user(
-            user_id, except_device_id=except_device_id,
-        )
-
-        # and now delete any access tokens which weren't associated with
-        # devices (or were associated with this device).
-        yield self._auth_handler.delete_access_tokens_for_user(
-            user_id, except_token_id=except_access_token_id,
-        )
--- a/synapse/handlers/sync.py
+++ b/synapse/handlers/sync.py
@@ -235,10 +235,10 @@ class SyncHandler(object):
        defer.returnValue(rules)

    @defer.inlineCallbacks
-    def ephemeral_by_room(self, sync_result_builder, now_token, since_token=None):
+    def ephemeral_by_room(self, sync_config, now_token, since_token=None):
        """Get the ephemeral events for each room the user is in
        Args:
-            sync_result_builder(SyncResultBuilder)
+            sync_config (SyncConfig): The flags, filters and user for the sync.
            now_token (StreamToken): Where the server is currently up to.
            since_token (StreamToken): Where the server was when the client
                last synced.
@@ -248,12 +248,10 @@ class SyncHandler(object):
            typing events for that room.
        """

-        sync_config = sync_result_builder.sync_config
-
        with Measure(self.clock, "ephemeral_by_room"):
            typing_key = since_token.typing_key if since_token else "0"

-            room_ids = sync_result_builder.joined_room_ids
+            room_ids = yield self.store.get_rooms_for_user(sync_config.user.to_string())

            typing_source = self.event_sources.sources["typing"]
            typing, typing_key = yield typing_source.get_new_events(
@@ -567,22 +565,10 @@ class SyncHandler(object):
        # Always use the `now_token` in `SyncResultBuilder`
        now_token = yield self.event_sources.get_current_token()

-        user_id = sync_config.user.to_string()
-        app_service = self.store.get_app_service_by_user_id(user_id)
-        if app_service:
-            # We no longer support AS users using /sync directly.
-            # See https://github.com/matrix-org/matrix-doc/issues/1144
-            raise NotImplementedError()
-        else:
-            joined_room_ids = yield self.get_rooms_for_user_at(
-                user_id, now_token.room_stream_id,
-            )
-
        sync_result_builder = SyncResultBuilder(
            sync_config, full_state,
            since_token=since_token,
            now_token=now_token,
-            joined_room_ids=joined_room_ids,
        )

        account_data_by_room = yield self._generate_sync_entry_for_account_data(
@@ -617,6 +603,7 @@ class SyncHandler(object):
        device_id = sync_config.device_id
        one_time_key_counts = {}
        if device_id:
+            user_id = sync_config.user.to_string()
            one_time_key_counts = yield self.store.count_e2e_one_time_keys(
                user_id, device_id
            )
@@ -904,7 +891,7 @@ class SyncHandler(object):
            ephemeral_by_room = {}
        else:
            now_token, ephemeral_by_room = yield self.ephemeral_by_room(
-                sync_result_builder,
+                sync_result_builder.sync_config,
                now_token=sync_result_builder.now_token,
                since_token=sync_result_builder.since_token,
            )
@@ -1009,8 +996,15 @@ class SyncHandler(object):
        if rooms_changed:
            defer.returnValue(True)

+        app_service = self.store.get_app_service_by_user_id(user_id)
+        if app_service:
+            rooms = yield self.store.get_app_service_rooms(app_service)
+            joined_room_ids = set(r.room_id for r in rooms)
+        else:
+            joined_room_ids = yield self.store.get_rooms_for_user(user_id)
+
        stream_id = RoomStreamToken.parse_stream_token(since_token.room_key).stream
-        for room_id in sync_result_builder.joined_room_ids:
+        for room_id in joined_room_ids:
            if self.store.has_room_changed_since(room_id, stream_id):
                defer.returnValue(True)
        defer.returnValue(False)
@@ -1034,6 +1028,13 @@ class SyncHandler(object):

        assert since_token

+        app_service = self.store.get_app_service_by_user_id(user_id)
+        if app_service:
+            rooms = yield self.store.get_app_service_rooms(app_service)
+            joined_room_ids = set(r.room_id for r in rooms)
+        else:
+            joined_room_ids = yield self.store.get_rooms_for_user(user_id)
+
        # Get a list of membership change events that have happened.
        rooms_changed = yield self.store.get_membership_changes_for_user(
            user_id, since_token.room_key, now_token.room_key
@@ -1056,7 +1057,7 @@ class SyncHandler(object):
            # we do send down the room, and with full state, where necessary

            old_state_ids = None
-            if room_id in sync_result_builder.joined_room_ids and non_joins:
+            if room_id in joined_room_ids and non_joins:
                # Always include if the user (re)joined the room, especially
                # important so that device list changes are calculated correctly.
                # If there are non join member events, but we are still in the room,
@@ -1066,7 +1067,7 @@ class SyncHandler(object):
                # User is in the room so we don't need to do the invite/leave checks
                continue

-            if room_id in sync_result_builder.joined_room_ids or has_join:
+            if room_id in joined_room_ids or has_join:
                old_state_ids = yield self.get_state_at(room_id, since_token)
                old_mem_ev_id = old_state_ids.get((EventTypes.Member, user_id), None)
                old_mem_ev = None
@@ -1078,7 +1079,7 @@ class SyncHandler(object):
                    newly_joined_rooms.append(room_id)

            # If user is in the room then we don't need to do the invite/leave checks
-            if room_id in sync_result_builder.joined_room_ids:
+            if room_id in joined_room_ids:
                continue

            if not non_joins:
@@ -1145,7 +1146,7 @@ class SyncHandler(object):

        # Get all events for rooms we're currently joined to.
        room_to_events = yield self.store.get_room_events_stream_for_rooms(
-            room_ids=sync_result_builder.joined_room_ids,
+            room_ids=joined_room_ids,
            from_key=since_token.room_key,
            to_key=now_token.room_key,
            limit=timeline_limit + 1,
@@ -1153,7 +1154,7 @@ class SyncHandler(object):

        # We loop through all room ids, even if there are no new events, in case
        # there are non room events taht we need to notify about.
-        for room_id in sync_result_builder.joined_room_ids:
+        for room_id in joined_room_ids:
            room_entry = room_to_events.get(room_id, None)

            if room_entry:
@@ -1361,54 +1362,6 @@ class SyncHandler(object):
        else:
            raise Exception("Unrecognized rtype: %r", room_builder.rtype)

-    @defer.inlineCallbacks
-    def get_rooms_for_user_at(self, user_id, stream_ordering):
-        """Get set of joined rooms for a user at the given stream ordering.
-
-        The stream ordering *must* be recent, otherwise this may throw an
-        exception if older than a month. (This function is called with the
-        current token, which should be perfectly fine).
-
-        Args:
-            user_id (str)
-            stream_ordering (int)
-
-        ReturnValue:
-            Deferred[frozenset[str]]: Set of room_ids the user is in at given
-            stream_ordering.
-        """
-        joined_rooms = yield self.store.get_rooms_for_user_with_stream_ordering(
-            user_id,
-        )
-
-        joined_room_ids = set()
-
-        # We need to check that the stream ordering of the join for each room
-        # is before the stream_ordering asked for. This might not be the case
-        # if the user joins a room between us getting the current token and
-        # calling `get_rooms_for_user_with_stream_ordering`.
-        # If the membership's stream ordering is after the given stream
-        # ordering, we need to go and work out if the user was in the room
-        # before.
-        for room_id, membership_stream_ordering in joined_rooms:
-            if membership_stream_ordering <= stream_ordering:
-                joined_room_ids.add(room_id)
-                continue
-
-            logger.info("User joined room after current token: %s", room_id)
-
-            extrems = yield self.store.get_forward_extremeties_for_room(
-                room_id, stream_ordering,
-            )
-            users_in_room = yield self.state.get_current_user_in_room(
-                room_id, extrems,
-            )
-            if user_id in users_in_room:
-                joined_room_ids.add(room_id)
-
-        joined_room_ids = frozenset(joined_room_ids)
-        defer.returnValue(joined_room_ids)
-

 def _action_has_highlight(actions):
    for action in actions:
@@ -1458,8 +1411,7 @@ def _calculate_state(timeline_contains, timeline_start, previous, current):

 class SyncResultBuilder(object):
    "Used to help build up a new SyncResult for a user"
-    def __init__(self, sync_config, full_state, since_token, now_token,
-                 joined_room_ids):
+    def __init__(self, sync_config, full_state, since_token, now_token):
        """
        Args:
            sync_config(SyncConfig)
@@ -1471,7 +1423,6 @@ class SyncResultBuilder(object):
        self.full_state = full_state
        self.since_token = since_token
        self.now_token = now_token
-        self.joined_room_ids = joined_room_ids

        self.presence = []
        self.account_data = []
--- a/synapse/handlers/typing.py
+++ b/synapse/handlers/typing.py
@@ -56,7 +56,7 @@ class TypingHandler(object):

        self.federation = hs.get_federation_sender()

-        hs.get_federation_registry().register_edu_handler("m.typing", self._recv_edu)
+        hs.get_replication_layer().register_edu_handler("m.typing", self._recv_edu)

        hs.get_distributor().observe("user_left_room", self.user_left_room)

--- a/synapse/handlers/user_directory.py
+++ b/synapse/handlers/user_directory.py
@@ -20,13 +20,12 @@ from synapse.api.constants import EventTypes, JoinRules, Membership
 from synapse.storage.roommember import ProfileInfo
 from synapse.util.metrics import Measure
 from synapse.util.async import sleep
-from synapse.types import get_localpart_from_id


 logger = logging.getLogger(__name__)


-class UserDirectoryHandler(object):
+class UserDirectoyHandler(object):
    """Handles querying of and keeping updated the user_directory.

    N.B.: ASSUMES IT IS THE ONLY THING THAT MODIFIES THE USER DIRECTORY
@@ -42,10 +41,9 @@ class UserDirectoryHandler(object):
    one public room.
    """

-    INITIAL_ROOM_SLEEP_MS = 50
-    INITIAL_ROOM_SLEEP_COUNT = 100
-    INITIAL_ROOM_BATCH_SIZE = 100
-    INITIAL_USER_SLEEP_MS = 10
+    INITIAL_SLEEP_MS = 50
+    INITIAL_SLEEP_COUNT = 100
+    INITIAL_BATCH_SIZE = 100

    def __init__(self, hs):
        self.store = hs.get_datastore()
@@ -55,7 +53,6 @@ class UserDirectoryHandler(object):
        self.notifier = hs.get_notifier()
        self.is_mine_id = hs.is_mine_id
        self.update_user_directory = hs.config.update_user_directory
-        self.search_all_users = hs.config.user_directory_search_all_users

        # When start up for the first time we need to populate the user_directory.
        # This is a set of user_id's we've inserted already
@@ -113,15 +110,6 @@ class UserDirectoryHandler(object):
        finally:
            self._is_processing = False

-    @defer.inlineCallbacks
-    def handle_local_profile_change(self, user_id, profile):
-        """Called to update index of our local user profiles when they change
-        irrespective of any rooms the user may be in.
-        """
-        yield self.store.update_profile_in_user_dir(
-            user_id, profile.display_name, profile.avatar_url, None,
-        )
-
    @defer.inlineCallbacks
    def _unsafe_process(self):
        # If self.pos is None then means we haven't fetched it from DB
@@ -160,30 +148,16 @@ class UserDirectoryHandler(object):
        room_ids = yield self.store.get_all_rooms()

        logger.info("Doing initial update of user directory. %d rooms", len(room_ids))
-        num_processed_rooms = 0
+        num_processed_rooms = 1

        for room_id in room_ids:
-            logger.info("Handling room %d/%d", num_processed_rooms + 1, len(room_ids))
-            yield self._handle_initial_room(room_id)
+            logger.info("Handling room %d/%d", num_processed_rooms, len(room_ids))
+            yield self._handle_intial_room(room_id)
            num_processed_rooms += 1
-            yield sleep(self.INITIAL_ROOM_SLEEP_MS / 1000.)
+            yield sleep(self.INITIAL_SLEEP_MS / 1000.)

        logger.info("Processed all rooms.")

-        if self.search_all_users:
-            num_processed_users = 0
-            user_ids = yield self.store.get_all_local_users()
-            logger.info("Doing initial update of user directory. %d users", len(user_ids))
-            for user_id in user_ids:
-                # We add profiles for all users even if they don't match the
-                # include pattern, just in case we want to change it in future
-                logger.info("Handling user %d/%d", num_processed_users + 1, len(user_ids))
-                yield self._handle_local_user(user_id)
-                num_processed_users += 1
-                yield sleep(self.INITIAL_USER_SLEEP_MS / 1000.)
-
-            logger.info("Processed all users")
-
        self.initially_handled_users = None
        self.initially_handled_users_in_public = None
        self.initially_handled_users_share = None
@@ -192,7 +166,7 @@ class UserDirectoryHandler(object):
        yield self.store.update_user_directory_stream_pos(new_pos)

    @defer.inlineCallbacks
-    def _handle_initial_room(self, room_id):
+    def _handle_intial_room(self, room_id):
        """Called when we initially fill out user_directory one room at a time
        """
        is_in_room = yield self.store.is_host_joined(room_id, self.server_name)
@@ -227,8 +201,8 @@ class UserDirectoryHandler(object):
        to_update = set()
        count = 0
        for user_id in user_ids:
-            if count % self.INITIAL_ROOM_SLEEP_COUNT == 0:
-                yield sleep(self.INITIAL_ROOM_SLEEP_MS / 1000.)
+            if count % self.INITIAL_SLEEP_COUNT == 0:
+                yield sleep(self.INITIAL_SLEEP_MS / 1000.)

            if not self.is_mine_id(user_id):
                count += 1
@@ -242,8 +216,8 @@ class UserDirectoryHandler(object):
                if user_id == other_user_id:
                    continue

-                if count % self.INITIAL_ROOM_SLEEP_COUNT == 0:
-                    yield sleep(self.INITIAL_ROOM_SLEEP_MS / 1000.)
+                if count % self.INITIAL_SLEEP_COUNT == 0:
+                    yield sleep(self.INITIAL_SLEEP_MS / 1000.)
                count += 1

                user_set = (user_id, other_user_id)
@@ -263,13 +237,13 @@ class UserDirectoryHandler(object):
                else:
                    self.initially_handled_users_share_private_room.add(user_set)

-                if len(to_insert) > self.INITIAL_ROOM_BATCH_SIZE:
+                if len(to_insert) > self.INITIAL_BATCH_SIZE:
                    yield self.store.add_users_who_share_room(
                        room_id, not is_public, to_insert,
                    )
                    to_insert.clear()

-                if len(to_update) > self.INITIAL_ROOM_BATCH_SIZE:
+                if len(to_update) > self.INITIAL_BATCH_SIZE:
                    yield self.store.update_users_who_share_room(
                        room_id, not is_public, to_update,
                    )
@@ -410,29 +384,15 @@ class UserDirectoryHandler(object):
            for user_id in users:
                yield self._handle_remove_user(room_id, user_id)

-    @defer.inlineCallbacks
-    def _handle_local_user(self, user_id):
-        """Adds a new local roomless user into the user_directory_search table.
-        Used to populate up the user index when we have an
-        user_directory_search_all_users specified.
-        """
-        logger.debug("Adding new local user to dir, %r", user_id)
-
-        profile = yield self.store.get_profileinfo(get_localpart_from_id(user_id))
-
-        row = yield self.store.get_user_in_directory(user_id)
-        if not row:
-            yield self.store.add_profiles_to_user_dir(None, {user_id: profile})
-
    @defer.inlineCallbacks
    def _handle_new_user(self, room_id, user_id, profile):
        """Called when we might need to add user to directory

        Args:
-            room_id (str): room_id that user joined or started being public
+            room_id (str): room_id that user joined or started being public that
            user_id (str)
        """
-        logger.debug("Adding new user to dir, %r", user_id)
+        logger.debug("Adding user to dir, %r", user_id)

        row = yield self.store.get_user_in_directory(user_id)
        if not row:
@@ -447,7 +407,7 @@ class UserDirectoryHandler(object):
            if not row:
                yield self.store.add_users_to_public_room(room_id, [user_id])
        else:
-            logger.debug("Not adding new user to public dir, %r", user_id)
+            logger.debug("Not adding user to public dir, %r", user_id)

        # Now we update users who share rooms with users. We do this by getting
        # all the current users in the room and seeing which aren't already
--- a/synapse/http/client.py
+++ b/synapse/http/client.py
@@ -18,7 +18,6 @@ from OpenSSL.SSL import VERIFY_NONE
 from synapse.api.errors import (
    CodeMessageException, MatrixCodeMessageException, SynapseError, Codes,
 )
-from synapse.util.caches import CACHE_SIZE_FACTOR
 from synapse.util.logcontext import make_deferred_yieldable
 from synapse.util import logcontext
 import synapse.metrics
@@ -31,7 +30,6 @@ from twisted.internet.endpoints import HostnameEndpoint, wrapClientTLS
 from twisted.web.client import (
    BrowserLikeRedirectAgent, ContentDecoderAgent, GzipDecoder, Agent,
    readBody, PartialDownloadError,
-    HTTPConnectionPool,
 )
 from twisted.web.client import FileBodyProducer as TwistedFileBodyProducer
 from twisted.web.http import PotentialDataLoss
@@ -66,23 +64,13 @@ class SimpleHttpClient(object):
    """
    def __init__(self, hs):
        self.hs = hs
-
-        pool = HTTPConnectionPool(reactor)
-
-        # the pusher makes lots of concurrent SSL connections to sygnal, and
-        # tends to do so in batches, so we need to allow the pool to keep lots
-        # of idle connections around.
-        pool.maxPersistentPerHost = max((100 * CACHE_SIZE_FACTOR, 5))
-        pool.cachedConnectionTimeout = 2 * 60
-
        # The default context factory in Twisted 14.0.0 (which we require) is
        # BrowserLikePolicyForHTTPS which will do regular cert validation
        # 'like a browser'
        self.agent = Agent(
            reactor,
            connectTimeout=15,
-            contextFactory=hs.get_http_client_context_factory(),
-            pool=pool,
+            contextFactory=hs.get_http_client_context_factory()
        )
        self.user_agent = hs.version_string
        self.clock = hs.get_clock()
--- a/synapse/http/endpoint.py
+++ b/synapse/http/endpoint.py
@@ -357,14 +357,13 @@ def _get_hosts_for_srv_record(dns_client, host):
    def eb(res, record_type):
        if res.check(DNSNameError):
            return []
-        logger.warn("Error looking up %s for %s: %s", record_type, host, res)
+        logger.warn("Error looking up %s for %s: %s",
+                    record_type, host, res, res.value)
        return res

    # no logcontexts here, so we can safely fire these off and gatherResults
-    d1 = dns_client.lookupAddress(host).addCallbacks(
-        cb, eb, errbackArgs=("A", ))
-    d2 = dns_client.lookupIPV6Address(host).addCallbacks(
-        cb, eb, errbackArgs=("AAAA", ))
+    d1 = dns_client.lookupAddress(host).addCallbacks(cb, eb)
+    d2 = dns_client.lookupIPV6Address(host).addCallbacks(cb, eb)
    results = yield defer.DeferredList(
        [d1, d2], consumeErrors=True)

--- a/synapse/http/matrixfederationclient.py
+++ b/synapse/http/matrixfederationclient.py
@@ -27,7 +27,7 @@ import synapse.metrics
 from canonicaljson import encode_canonical_json

 from synapse.api.errors import (
-    SynapseError, Codes, HttpResponseException, FederationDeniedError,
+    SynapseError, Codes, HttpResponseException,
 )

 from signedjson.sign import sign_json
@@ -123,22 +123,11 @@ class MatrixFederationHttpClient(object):

            Fails with ``HTTPRequestException``: if we get an HTTP response
                code >= 300.
-
            Fails with ``NotRetryingDestination`` if we are not yet ready
                to retry this server.
-
-            Fails with ``FederationDeniedError`` if this destination
-                is not on our federation whitelist
-
            (May also fail with plenty of other Exceptions for things like DNS
                failures, connection failures, SSL failures.)
        """
-        if (
-            self.hs.config.federation_domain_whitelist and
-            destination not in self.hs.config.federation_domain_whitelist
-        ):
-            raise FederationDeniedError(destination)
-
        limiter = yield synapse.util.retryutils.get_retry_limiter(
            destination,
            self.clock,
@@ -319,9 +308,6 @@ class MatrixFederationHttpClient(object):

            Fails with ``NotRetryingDestination`` if we are not yet ready
            to retry this server.
-
-            Fails with ``FederationDeniedError`` if this destination
-            is not on our federation whitelist
        """

        if not json_data_callback:
@@ -382,9 +368,6 @@ class MatrixFederationHttpClient(object):

            Fails with ``NotRetryingDestination`` if we are not yet ready
            to retry this server.
-
-            Fails with ``FederationDeniedError`` if this destination
-            is not on our federation whitelist
        """

        def body_callback(method, url_bytes, headers_dict):
@@ -439,9 +422,6 @@ class MatrixFederationHttpClient(object):

            Fails with ``NotRetryingDestination`` if we are not yet ready
            to retry this server.
-
-            Fails with ``FederationDeniedError`` if this destination
-            is not on our federation whitelist
        """
        logger.debug("get_json args: %s", args)

@@ -495,9 +475,6 @@ class MatrixFederationHttpClient(object):

            Fails with ``NotRetryingDestination`` if we are not yet ready
            to retry this server.
-
-            Fails with ``FederationDeniedError`` if this destination
-            is not on our federation whitelist
        """

        response = yield self._request(
@@ -541,9 +518,6 @@ class MatrixFederationHttpClient(object):

            Fails with ``NotRetryingDestination`` if we are not yet ready
            to retry this server.
-
-            Fails with ``FederationDeniedError`` if this destination
-            is not on our federation whitelist
        """

        encoded_args = {}
--- a/synapse/http/server.py
+++ b/synapse/http/server.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 # Copyright 2014-2016 OpenMarket Ltd
-# Copyright 2018 New Vector Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -29,7 +28,6 @@ from canonicaljson import (
 )

 from twisted.internet import defer
-from twisted.python import failure
 from twisted.web import server, resource
 from twisted.web.server import NOT_DONE_YET
 from twisted.web.util import redirectTo
@@ -37,81 +35,42 @@ from twisted.web.util import redirectTo
 import collections
 import logging
 import urllib
-import simplejson
+import ujson

 logger = logging.getLogger(__name__)

 metrics = synapse.metrics.get_metrics_for(__name__)

-# total number of responses served, split by method/servlet/tag
-response_count = metrics.register_counter(
-    "response_count",
+incoming_requests_counter = metrics.register_counter(
+    "requests",
    labels=["method", "servlet", "tag"],
-    alternative_names=(
-        # the following are all deprecated aliases for the same metric
-        metrics.name_prefix + x for x in (
-            "_requests",
-            "_response_time:count",
-            "_response_ru_utime:count",
-            "_response_ru_stime:count",
-            "_response_db_txn_count:count",
-            "_response_db_txn_duration:count",
-        )
-    )
 )
-
-requests_counter = metrics.register_counter(
-    "requests_received",
-    labels=["method", "servlet", ],
-)
-
 outgoing_responses_counter = metrics.register_counter(
    "responses",
    labels=["method", "code"],
 )

-response_timer = metrics.register_counter(
-    "response_time_seconds",
-    labels=["method", "servlet", "tag"],
-    alternative_names=(
-        metrics.name_prefix + "_response_time:total",
-    ),
+response_timer = metrics.register_distribution(
+    "response_time",
+    labels=["method", "servlet", "tag"]
 )

-response_ru_utime = metrics.register_counter(
-    "response_ru_utime_seconds", labels=["method", "servlet", "tag"],
-    alternative_names=(
-        metrics.name_prefix + "_response_ru_utime:total",
-    ),
+response_ru_utime = metrics.register_distribution(
+    "response_ru_utime", labels=["method", "servlet", "tag"]
 )

-response_ru_stime = metrics.register_counter(
-    "response_ru_stime_seconds", labels=["method", "servlet", "tag"],
-    alternative_names=(
-        metrics.name_prefix + "_response_ru_stime:total",
-    ),
+response_ru_stime = metrics.register_distribution(
+    "response_ru_stime", labels=["method", "servlet", "tag"]
 )

-response_db_txn_count = metrics.register_counter(
-    "response_db_txn_count", labels=["method", "servlet", "tag"],
-    alternative_names=(
-        metrics.name_prefix + "_response_db_txn_count:total",
-    ),
+response_db_txn_count = metrics.register_distribution(
+    "response_db_txn_count", labels=["method", "servlet", "tag"]
 )

-# seconds spent waiting for db txns, excluding scheduling time, when processing
-# this request
-response_db_txn_duration = metrics.register_counter(
-    "response_db_txn_duration_seconds", labels=["method", "servlet", "tag"],
-    alternative_names=(
-        metrics.name_prefix + "_response_db_txn_duration:total",
-    ),
+response_db_txn_duration = metrics.register_distribution(
+    "response_db_txn_duration", labels=["method", "servlet", "tag"]
 )

-# seconds spent waiting for a db connection, when processing this request
-response_db_sched_duration = metrics.register_counter(
-    "response_db_sched_duration_seconds", labels=["method", "servlet", "tag"]
-)

 _next_request_id = 0

@@ -147,12 +106,7 @@ def wrap_request_handler(request_handler, include_metrics=False):
        with LoggingContext(request_id) as request_context:
            with Measure(self.clock, "wrapped_request_handler"):
                request_metrics = RequestMetrics()
-                # we start the request metrics timer here with an initial stab
-                # at the servlet name. For most requests that name will be
-                # JsonResource (or a subclass), and JsonResource._async_render
-                # will update it once it picks a servlet.
-                servlet_name = self.__class__.__name__
-                request_metrics.start(self.clock, name=servlet_name)
+                request_metrics.start(self.clock, name=self.__class__.__name__)

                request_context.request = request_id
                with request.processing():
@@ -161,7 +115,6 @@ def wrap_request_handler(request_handler, include_metrics=False):
                            if include_metrics:
                                yield request_handler(self, request, request_metrics)
                            else:
-                                requests_counter.inc(request.method, servlet_name)
                                yield request_handler(self, request)
                    except CodeMessageException as e:
                        code = e.code
@@ -178,17 +131,12 @@ def wrap_request_handler(request_handler, include_metrics=False):
                            version_string=self.version_string,
                        )
                    except Exception:
-                        # failure.Failure() fishes the original Failure out
-                        # of our stack, and thus gives us a sensible stack
-                        # trace.
-                        f = failure.Failure()
-                        logger.error(
-                            "Failed handle request %s.%s on %r: %r: %s",
+                        logger.exception(
+                            "Failed handle request %s.%s on %r: %r",
                            request_handler.__module__,
                            request_handler.__name__,
                            self,
-                            request,
-                            f.getTraceback().rstrip(),
+                            request
                        )
                        respond_with_json(
                            request,
@@ -237,7 +185,7 @@ class JsonResource(HttpServer, resource.Resource):
    """ This implements the HttpServer interface and provides JSON support for
    Resources.

-    Register callbacks via register_paths()
+    Register callbacks via register_path()

    Callbacks can return a tuple of status code and a dict in which case the
    the dict will automatically be sent to the client as a JSON object.
@@ -284,62 +232,57 @@ class JsonResource(HttpServer, resource.Resource):
            This checks if anyone has registered a callback for that method and
            path.
        """
-        callback, group_dict = self._get_handler_for_request(request)
-
-        servlet_instance = getattr(callback, "__self__", None)
-        if servlet_instance is not None:
-            servlet_classname = servlet_instance.__class__.__name__
-        else:
-            servlet_classname = "%r" % callback
-
-        request_metrics.name = servlet_classname
-        requests_counter.inc(request.method, servlet_classname)
-
-        # Now trigger the callback. If it returns a response, we send it
-        # here. If it throws an exception, that is handled by the wrapper
-        # installed by @request_handler.
-
-        kwargs = intern_dict({
-            name: urllib.unquote(value).decode("UTF-8") if value else value
-            for name, value in group_dict.items()
-        })
-
-        callback_return = yield callback(request, **kwargs)
-        if callback_return is not None:
-            code, response = callback_return
-            self._send_response(request, code, response)
-
-    def _get_handler_for_request(self, request):
-        """Finds a callback method to handle the given request
-
-        Args:
-            request (twisted.web.http.Request):
-
-        Returns:
-            Tuple[Callable, dict[str, str]]: callback method, and the dict
-                mapping keys to path components as specified in the handler's
-                path match regexp.
-
-                The callback will normally be a method registered via
-                register_paths, so will return (possibly via Deferred) either
-                None, or a tuple of (http code, response body).
-        """
        if request.method == "OPTIONS":
-            return _options_handler, {}
+            self._send_response(request, 200, {})
+            return

        # Loop through all the registered callbacks to check if the method
        # and path regex match
        for path_entry in self.path_regexs.get(request.method, []):
            m = path_entry.pattern.match(request.path)
-            if m:
-                # We found a match!
-                return path_entry.callback, m.groupdict()
+            if not m:
+                continue
+
+            # We found a match! Trigger callback and then return the
+            # returned response. We pass both the request and any
+            # matched groups from the regex to the callback.
+
+            callback = path_entry.callback
+
+            kwargs = intern_dict({
+                name: urllib.unquote(value).decode("UTF-8") if value else value
+                for name, value in m.groupdict().items()
+            })
+
+            callback_return = yield callback(request, **kwargs)
+            if callback_return is not None:
+                code, response = callback_return
+                self._send_response(request, code, response)
+
+            servlet_instance = getattr(callback, "__self__", None)
+            if servlet_instance is not None:
+                servlet_classname = servlet_instance.__class__.__name__
+            else:
+                servlet_classname = "%r" % callback
+
+            request_metrics.name = servlet_classname
+
+            return

        # Huh. No one wanted to handle that? Fiiiiiine. Send 400.
-        return _unrecognised_request_handler, {}
+        raise UnrecognizedRequestError()

    def _send_response(self, request, code, response_json_object,
                       response_code_message=None):
+        # could alternatively use request.notifyFinish() and flip a flag when
+        # the Deferred fires, but since the flag is RIGHT THERE it seems like
+        # a waste.
+        if request._disconnected:
+            logger.warn(
+                "Not sending response to request %s, already disconnected.",
+                request)
+            return
+
        outgoing_responses_counter.inc(request.method, str(code))

        # TODO: Only enable CORS for the requests that need it.
@@ -353,34 +296,6 @@ class JsonResource(HttpServer, resource.Resource):
        )


-def _options_handler(request):
-    """Request handler for OPTIONS requests
-
-    This is a request handler suitable for return from
-    _get_handler_for_request. It returns a 200 and an empty body.
-
-    Args:
-        request (twisted.web.http.Request):
-
-    Returns:
-        Tuple[int, dict]: http code, response body.
-    """
-    return 200, {}
-
-
-def _unrecognised_request_handler(request):
-    """Request handler for unrecognised requests
-
-    This is a request handler suitable for return from
-    _get_handler_for_request. It actually just raises an
-    UnrecognizedRequestError.
-
-    Args:
-        request (twisted.web.http.Request):
-    """
-    raise UnrecognizedRequestError()
-
-
 class RequestMetrics(object):
    def start(self, clock, name):
        self.start = clock.time_msec()
@@ -401,7 +316,7 @@ class RequestMetrics(object):
                )
                return

-        response_count.inc(request.method, self.name, tag)
+        incoming_requests_counter.inc(request.method, self.name, tag)

        response_timer.inc_by(
            clock.time_msec() - self.start, request.method,
@@ -420,10 +335,7 @@ class RequestMetrics(object):
            context.db_txn_count, request.method, self.name, tag
        )
        response_db_txn_duration.inc_by(
-            context.db_txn_duration_ms / 1000., request.method, self.name, tag
-        )
-        response_db_sched_duration.inc_by(
-            context.db_sched_duration_ms / 1000., request.method, self.name, tag
+            context.db_txn_duration, request.method, self.name, tag
        )


@@ -446,22 +358,14 @@ class RootRedirect(resource.Resource):
 def respond_with_json(request, code, json_object, send_cors=False,
                      response_code_message=None, pretty_print=False,
                      version_string="", canonical_json=True):
-    # could alternatively use request.notifyFinish() and flip a flag when
-    # the Deferred fires, but since the flag is RIGHT THERE it seems like
-    # a waste.
-    if request._disconnected:
-        logger.warn(
-            "Not sending response to request %s, already disconnected.",
-            request)
-        return
-
    if pretty_print:
        json_bytes = encode_pretty_printed_json(json_object) + "\n"
    else:
        if canonical_json or synapse.events.USE_FROZEN_DICTS:
            json_bytes = encode_canonical_json(json_object)
        else:
-            json_bytes = simplejson.dumps(json_object)
+            # ujson doesn't like frozen_dicts.
+            json_bytes = ujson.dumps(json_object, ensure_ascii=False)

    return respond_with_json_bytes(
        request, code, json_bytes,
--- a/synapse/http/servlet.py
+++ b/synapse/http/servlet.py
@@ -148,13 +148,11 @@ def parse_string_from_args(args, name, default=None, required=False,
            return default


-def parse_json_value_from_request(request, allow_empty_body=False):
+def parse_json_value_from_request(request):
    """Parse a JSON value from the body of a twisted HTTP request.

    Args:
        request: the twisted HTTP request.
-        allow_empty_body (bool): if True, an empty body will be accepted and
-            turned into None

    Returns:
        The JSON value.
@@ -167,36 +165,25 @@ def parse_json_value_from_request(request, allow_empty_body=False):
    except Exception:
        raise SynapseError(400, "Error reading JSON content.")

-    if not content_bytes and allow_empty_body:
-        return None
-
    try:
        content = simplejson.loads(content_bytes)
-    except Exception as e:
-        logger.warn("Unable to parse JSON: %s", e)
+    except simplejson.JSONDecodeError:
        raise SynapseError(400, "Content not JSON.", errcode=Codes.NOT_JSON)

    return content


-def parse_json_object_from_request(request, allow_empty_body=False):
+def parse_json_object_from_request(request):
    """Parse a JSON object from the body of a twisted HTTP request.

    Args:
        request: the twisted HTTP request.
-        allow_empty_body (bool): if True, an empty body will be accepted and
-            turned into an empty dict.

    Raises:
        SynapseError if the request body couldn't be decoded as JSON or
            if it wasn't a JSON object.
    """
-    content = parse_json_value_from_request(
-        request, allow_empty_body=allow_empty_body,
-    )
-
-    if allow_empty_body and content is None:
-        return {}
+    content = parse_json_value_from_request(request)

    if type(content) != dict:
        message = "Content must be a JSON object."
--- a/synapse/http/site.py
+++ b/synapse/http/site.py
@@ -66,15 +66,14 @@ class SynapseRequest(Request):
            context = LoggingContext.current_context()
            ru_utime, ru_stime = context.get_resource_usage()
            db_txn_count = context.db_txn_count
-            db_txn_duration_ms = context.db_txn_duration_ms
-            db_sched_duration_ms = context.db_sched_duration_ms
+            db_txn_duration = context.db_txn_duration
        except Exception:
            ru_utime, ru_stime = (0, 0)
-            db_txn_count, db_txn_duration_ms = (0, 0)
+            db_txn_count, db_txn_duration = (0, 0)

        self.site.access_logger.info(
            "%s - %s - {%s}"
-            " Processed request: %dms (%dms, %dms) (%dms/%dms/%d)"
+            " Processed request: %dms (%dms, %dms) (%dms/%d)"
            " %sB %s \"%s %s %s\" \"%s\"",
            self.getClientIP(),
            self.site.site_tag,
@@ -82,8 +81,7 @@ class SynapseRequest(Request):
            int(time.time() * 1000) - self.start_time,
            int(ru_utime * 1000),
            int(ru_stime * 1000),
-            db_sched_duration_ms,
-            db_txn_duration_ms,
+            int(db_txn_duration * 1000),
            int(db_txn_count),
            self.sentLength,
            self.code,
--- a/synapse/metrics/init.py
+++ b/synapse/metrics/init.py
@@ -57,31 +57,15 @@ class Metrics(object):
        return metric

    def register_counter(self, *args, **kwargs):
-        """
-        Returns:
-            CounterMetric
-        """
        return self._register(CounterMetric, *args, **kwargs)

    def register_callback(self, *args, **kwargs):
-        """
-        Returns:
-            CallbackMetric
-        """
        return self._register(CallbackMetric, *args, **kwargs)

    def register_distribution(self, *args, **kwargs):
-        """
-        Returns:
-            DistributionMetric
-        """
        return self._register(DistributionMetric, *args, **kwargs)

    def register_cache(self, *args, **kwargs):
-        """
-        Returns:
-            CacheMetric
-        """
        return self._register(CacheMetric, *args, **kwargs)


@@ -162,15 +146,10 @@ def runUntilCurrentTimer(func):
            num_pending += 1

        num_pending += len(reactor.threadCallQueue)
+
        start = time.time() * 1000
        ret = func(*args, **kwargs)
        end = time.time() * 1000
-
-        # record the amount of wallclock time spent running pending calls.
-        # This is a proxy for the actual amount of time between reactor polls,
-        # since about 25% of time is actually spent running things triggered by
-        # I/O events, but that is harder to capture without rewriting half the
-        # reactor.
        tick_time.inc_by(end - start)
        pending_calls_metric.inc_by(num_pending)

--- a/synapse/metrics/metric.py
+++ b/synapse/metrics/metric.py
@@ -15,38 +15,18 @@


 from itertools import chain
-import logging
-
-logger = logging.getLogger(__name__)


-def flatten(items):
-    """Flatten a list of lists
-
-    Args:
-        items: iterable[iterable[X]]
-
-    Returns:
-        list[X]: flattened list
-    """
-    return list(chain.from_iterable(items))
+# TODO(paul): I can't believe Python doesn't have one of these
+def map_concat(func, items):
+    # flatten a list-of-lists
+    return list(chain.from_iterable(map(func, items)))


 class BaseMetric(object):
-    """Base class for metrics which report a single value per label set
-    """

-    def __init__(self, name, labels=[], alternative_names=[]):
-        """
-        Args:
-            name (str): principal name for this metric
-            labels (list(str)): names of the labels which will be reported
-                for this metric
-            alternative_names (iterable(str)): list of alternative names for
-                 this metric. This can be useful to provide a migration path
-                when renaming metrics.
-        """
-        self._names = [name] + list(alternative_names)
+    def __init__(self, name, labels=[]):
+        self.name = name
        self.labels = labels  # OK not to clone as we never write it

    def dimension(self):
@@ -56,7 +36,7 @@ class BaseMetric(object):
        return not len(self.labels)

    def _render_labelvalue(self, value):
-        # TODO: escape backslashes, quotes and newlines
+        # TODO: some kind of value escape
        return '"%s"' % (value)

    def _render_key(self, values):
@@ -67,60 +47,19 @@ class BaseMetric(object):
                      for k, v in zip(self.labels, values)])
        )

-    def _render_for_labels(self, label_values, value):
-        """Render this metric for a single set of labels
-
-        Args:
-            label_values (list[str]): values for each of the labels
-            value: value of the metric at with these labels
-
-        Returns:
-            iterable[str]: rendered metric
-        """
-        rendered_labels = self._render_key(label_values)
-        return (
-            "%s%s %.12g" % (name, rendered_labels, value)
-            for name in self._names
-        )
-
-    def render(self):
-        """Render this metric
-
-        Each metric is rendered as:
-
-            name{label1="val1",label2="val2"} value
-
-        https://prometheus.io/docs/instrumenting/exposition_formats/#text-format-details
-
-        Returns:
-            iterable[str]: rendered metrics
-        """
-        raise NotImplementedError()
-

 class CounterMetric(BaseMetric):
    """The simplest kind of metric; one that stores a monotonically-increasing
-    value that counts events or running totals.
-
-    Example use cases for Counters:
-    - Number of requests processed
-    - Number of items that were inserted into a queue
-    - Total amount of data that a system has processed
-    Counters can only go up (and be reset when the process restarts).
-    """
+    integer that counts events."""

    def __init__(self, *args, **kwargs):
        super(CounterMetric, self).__init__(*args, **kwargs)

-        # dict[list[str]]: value for each set of label values. the keys are the
-        # label values, in the same order as the labels in self.labels.
-        #
-        # (if the metric is a scalar, the (single) key is the empty list).
        self.counts = {}

        # Scalar metrics are never empty
        if self.is_scalar():
-            self.counts[()] = 0.
+            self.counts[()] = 0

    def inc_by(self, incr, *values):
        if len(values) != self.dimension():
@@ -138,11 +77,11 @@ class CounterMetric(BaseMetric):
    def inc(self, *values):
        self.inc_by(1, *values)

+    def render_item(self, k):
+        return ["%s%s %d" % (self.name, self._render_key(k), self.counts[k])]
+
    def render(self):
-        return flatten(
-            self._render_for_labels(k, self.counts[k])
-            for k in sorted(self.counts.keys())
-        )
+        return map_concat(self.render_item, sorted(self.counts.keys()))


 class CallbackMetric(BaseMetric):
@@ -156,19 +95,13 @@ class CallbackMetric(BaseMetric):
        self.callback = callback

    def render(self):
-        try:
-            value = self.callback()
-        except Exception:
-            logger.exception("Failed to render %s", self.name)
-            return ["# FAILED to render " + self.name]
+        value = self.callback()

        if self.is_scalar():
-            return list(self._render_for_labels([], value))
+            return ["%s %.12g" % (self.name, value)]

-        return flatten(
-            self._render_for_labels(k, value[k])
-            for k in sorted(value.keys())
-        )
+        return ["%s%s %.12g" % (self.name, self._render_key(k), value[k])
+                for k in sorted(value.keys())]


 class DistributionMetric(object):
@@ -193,9 +126,7 @@ class DistributionMetric(object):


 class CacheMetric(object):
-    __slots__ = (
-        "name", "cache_name", "hits", "misses", "evicted_size", "size_callback",
-    )
+    __slots__ = ("name", "cache_name", "hits", "misses", "size_callback")

    def __init__(self, name, size_callback, cache_name):
        self.name = name
@@ -203,7 +134,6 @@ class CacheMetric(object):

        self.hits = 0
        self.misses = 0
-        self.evicted_size = 0

        self.size_callback = size_callback

@@ -213,9 +143,6 @@ class CacheMetric(object):
    def inc_misses(self):
        self.misses += 1

-    def inc_evictions(self, size=1):
-        self.evicted_size += size
-
    def render(self):
        size = self.size_callback()
        hits = self.hits
@@ -225,9 +152,6 @@ class CacheMetric(object):
            """%s:hits{name="%s"} %d""" % (self.name, self.cache_name, hits),
            """%s:total{name="%s"} %d""" % (self.name, self.cache_name, total),
            """%s:size{name="%s"} %d""" % (self.name, self.cache_name, size),
-            """%s:evicted_size{name="%s"} %d""" % (
-                self.name, self.cache_name, self.evicted_size
-            ),
        ]


--- a/synapse/module_api/init.py
+++ b/synapse/module_api/init.py
@@ -12,7 +12,6 @@
 # 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.
-from twisted.internet import defer

 from synapse.types import UserID

@@ -82,7 +81,6 @@ class ModuleApi(object):
        reg = self.hs.get_handlers().registration_handler
        return reg.register(localpart=localpart)

-    @defer.inlineCallbacks
    def invalidate_access_token(self, access_token):
        """Invalidate an access token for a user

@@ -96,16 +94,8 @@ class ModuleApi(object):
        Raises:
            synapse.api.errors.AuthError: the access token is invalid
        """
-        # see if the access token corresponds to a device
-        user_info = yield self._auth.get_user_by_access_token(access_token)
-        device_id = user_info.get("device_id")
-        user_id = user_info["user"].to_string()
-        if device_id:
-            # delete the device, which will also delete its access tokens
-            yield self.hs.get_device_handler().delete_device(user_id, device_id)
-        else:
-            # no associated device. Just delete the access token.
-            yield self._auth_handler.delete_access_token(access_token)
+
+        return self._auth_handler.delete_access_token(access_token)

    def run_db_interaction(self, desc, func, *args, **kwargs):
        """Run a function with a database connection
--- a/synapse/notifier.py
+++ b/synapse/notifier.py
@@ -255,7 +255,9 @@ class Notifier(object):
        )

        if self.federation_sender:
-            self.federation_sender.notify_new_events(room_stream_id)
+            preserve_fn(self.federation_sender.notify_new_events)(
+                room_stream_id
+            )

        if event.type == EventTypes.Member and event.membership == Membership.JOIN:
            self._user_joined_room(event.state_key, event.room_id)
@@ -295,7 +297,8 @@ class Notifier(object):
    def on_new_replication_data(self):
        """Used to inform replication listeners that something has happend
        without waking up any of the normal user event streams"""
-        self.notify_replication()
+        with PreserveLoggingContext():
+            self.notify_replication()

    @defer.inlineCallbacks
    def wait_for_events(self, user_id, timeout, callback, room_ids=None,
@@ -513,14 +516,8 @@ class Notifier(object):
            self.replication_deferred = ObservableDeferred(defer.Deferred())
            deferred.callback(None)

-            # the callbacks may well outlast the current request, so we run
-            # them in the sentinel logcontext.
-            #
-            # (ideally it would be up to the callbacks to know if they were
-            # starting off background processes and drop the logcontext
-            # accordingly, but that requires more changes)
-            for cb in self.replication_callbacks:
-                cb()
+        for cb in self.replication_callbacks:
+            preserve_fn(cb)()

    @defer.inlineCallbacks
    def wait_for_replication(self, callback, timeout):
--- a/synapse/push/action_generator.py
+++ b/synapse/push/action_generator.py
@@ -40,6 +40,10 @@ class ActionGenerator(object):
    @defer.inlineCallbacks
    def handle_push_actions_for_event(self, event, context):
        with Measure(self.clock, "action_for_event_by_user"):
-            yield self.bulk_evaluator.action_for_event_by_user(
+            actions_by_user = yield self.bulk_evaluator.action_for_event_by_user(
                event, context
            )
+
+        context.push_actions = [
+            (uid, actions) for uid, actions in actions_by_user.iteritems()
+        ]
--- a/synapse/push/bulk_push_rule_evaluator.py
+++ b/synapse/push/bulk_push_rule_evaluator.py
@@ -137,11 +137,11 @@ class BulkPushRuleEvaluator(object):

    @defer.inlineCallbacks
    def action_for_event_by_user(self, event, context):
-        """Given an event and context, evaluate the push rules and insert the
-        results into the event_push_actions_staging table.
+        """Given an event and context, evaluate the push rules and return
+        the results

        Returns:
-            Deferred
+            dict of user_id -> action
        """
        rules_by_user = yield self._get_rules_for_event(event, context)
        actions_by_user = {}
@@ -190,16 +190,9 @@ class BulkPushRuleEvaluator(object):
                if matches:
                    actions = [x for x in rule['actions'] if x != 'dont_notify']
                    if actions and 'notify' in actions:
-                        # Push rules say we should notify the user of this event
                        actions_by_user[uid] = actions
                    break
-
-        # Mark in the DB staging area the push actions for users who should be
-        # notified for this event. (This will then get handled when we persist
-        # the event)
-        yield self.store.add_push_actions_to_staging(
-            event.event_id, actions_by_user,
-        )
+        defer.returnValue(actions_by_user)


 def _condition_checker(evaluator, conditions, uid, display_name, cache):
--- a/synapse/push/httppusher.py
+++ b/synapse/push/httppusher.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 # Copyright 2015, 2016 OpenMarket Ltd
-# Copyright 2017 New Vector Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,30 +12,21 @@
 # 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 synapse.push import PusherConfigException

 from twisted.internet import defer, reactor
 from twisted.internet.error import AlreadyCalled, AlreadyCancelled

+import logging
 import push_rule_evaluator
 import push_tools
-import synapse
-from synapse.push import PusherConfigException
+
 from synapse.util.logcontext import LoggingContext
 from synapse.util.metrics import Measure

 logger = logging.getLogger(__name__)

-metrics = synapse.metrics.get_metrics_for(__name__)
-
-http_push_processed_counter = metrics.register_counter(
-    "http_pushes_processed",
-)
-
-http_push_failed_counter = metrics.register_counter(
-    "http_pushes_failed",
-)
-

 class HttpPusher(object):
    INITIAL_BACKOFF_SEC = 1  # in seconds because that's what Twisted takes
@@ -161,16 +151,9 @@ class HttpPusher(object):
            self.user_id, self.last_stream_ordering, self.max_stream_ordering
        )

-        logger.info(
-            "Processing %i unprocessed push actions for %s starting at "
-            "stream_ordering %s",
-            len(unprocessed), self.name, self.last_stream_ordering,
-        )
-
        for push_action in unprocessed:
            processed = yield self._process_one(push_action)
            if processed:
-                http_push_processed_counter.inc()
                self.backoff_delay = HttpPusher.INITIAL_BACKOFF_SEC
                self.last_stream_ordering = push_action['stream_ordering']
                yield self.store.update_pusher_last_stream_ordering_and_success(
@@ -185,7 +168,6 @@ class HttpPusher(object):
                        self.failing_since
                    )
            else:
-                http_push_failed_counter.inc()
                if not self.failing_since:
                    self.failing_since = self.clock.time_msec()
                    yield self.store.update_pusher_failing_since(
@@ -313,7 +295,7 @@ class HttpPusher(object):
        if event.type == 'm.room.member':
            d['notification']['membership'] = event.content['membership']
            d['notification']['user_is_target'] = event.state_key == self.user_id
-        if self.hs.config.push_include_content and 'content' in event:
+        if not self.hs.config.push_redact_content and 'content' in event:
            d['notification']['content'] = event.content

        # We no longer send aliases separately, instead, we send the human
@@ -333,10 +315,7 @@ class HttpPusher(object):
        try:
            resp = yield self.http_client.post_json_get_json(self.url, notification_dict)
        except Exception:
-            logger.warn(
-                "Failed to push event %s to %s",
-                event.event_id, self.name, exc_info=True,
-            )
+            logger.warn("Failed to push %s ", self.url)
            defer.returnValue(False)
        rejected = []
        if 'rejected' in resp:
@@ -345,7 +324,7 @@ class HttpPusher(object):

    @defer.inlineCallbacks
    def _send_badge(self, badge):
-        logger.info("Sending updated badge count %d to %s", badge, self.name)
+        logger.info("Sending updated badge count %d to %r", badge, self.user_id)
        d = {
            'notification': {
                'id': '',
@@ -367,10 +346,7 @@ class HttpPusher(object):
        try:
            resp = yield self.http_client.post_json_get_json(self.url, d)
        except Exception:
-            logger.warn(
-                "Failed to send badge count to %s",
-                self.name, exc_info=True,
-            )
+            logger.exception("Failed to push %s ", self.url)
            defer.returnValue(False)
        rejected = []
        if 'rejected' in resp:
--- a/synapse/push/pusherpool.py
+++ b/synapse/push/pusherpool.py
@@ -17,7 +17,7 @@
 from twisted.internet import defer

 from .pusher import PusherFactory
-from synapse.util.logcontext import make_deferred_yieldable, preserve_fn
+from synapse.util.logcontext import preserve_fn, preserve_context_over_deferred
 from synapse.util.async import run_on_reactor

 import logging
@@ -103,25 +103,19 @@ class PusherPool:
                yield self.remove_pusher(p['app_id'], p['pushkey'], p['user_name'])

    @defer.inlineCallbacks
-    def remove_pushers_by_access_token(self, user_id, access_tokens):
-        """Remove the pushers for a given user corresponding to a set of
-        access_tokens.
-
-        Args:
-            user_id (str): user to remove pushers for
-            access_tokens (Iterable[int]): access token *ids* to remove pushers
-                for
-        """
-        tokens = set(access_tokens)
-        for p in (yield self.store.get_pushers_by_user_id(user_id)):
-            if p['access_token'] in tokens:
+    def remove_pushers_by_user(self, user_id, except_access_token_id=None):
+        all = yield self.store.get_all_pushers()
+        logger.info(
+            "Removing all pushers for user %s except access tokens id %r",
+            user_id, except_access_token_id
+        )
+        for p in all:
+            if p['user_name'] == user_id and p['access_token'] != except_access_token_id:
                logger.info(
                    "Removing pusher for app id %s, pushkey %s, user %s",
                    p['app_id'], p['pushkey'], p['user_name']
                )
-                yield self.remove_pusher(
-                    p['app_id'], p['pushkey'], p['user_name'],
-                )
+                yield self.remove_pusher(p['app_id'], p['pushkey'], p['user_name'])

    @defer.inlineCallbacks
    def on_new_notifications(self, min_stream_id, max_stream_id):
@@ -142,7 +136,7 @@ class PusherPool:
                            )
                        )

-            yield make_deferred_yieldable(defer.gatherResults(deferreds))
+            yield preserve_context_over_deferred(defer.gatherResults(deferreds))
        except Exception:
            logger.exception("Exception in pusher on_new_notifications")

@@ -167,7 +161,7 @@ class PusherPool:
                            preserve_fn(p.on_new_receipts)(min_stream_id, max_stream_id)
                        )

-            yield make_deferred_yieldable(defer.gatherResults(deferreds))
+            yield preserve_context_over_deferred(defer.gatherResults(deferreds))
        except Exception:
            logger.exception("Exception in pusher on_new_receipts")

--- a/synapse/python_dependencies.py
+++ b/synapse/python_dependencies.py
@@ -24,19 +24,19 @@ REQUIREMENTS = {
    "unpaddedbase64>=1.1.0": ["unpaddedbase64>=1.1.0"],
    "canonicaljson>=1.0.0": ["canonicaljson>=1.0.0"],
    "signedjson>=1.0.0": ["signedjson>=1.0.0"],
-    "pynacl>=1.2.1": ["nacl>=1.2.1", "nacl.bindings"],
+    "pynacl==0.3.0": ["nacl==0.3.0", "nacl.bindings"],
    "service_identity>=1.0.0": ["service_identity>=1.0.0"],
    "Twisted>=16.0.0": ["twisted>=16.0.0"],
    "pyopenssl>=0.14": ["OpenSSL>=0.14"],
    "pyyaml": ["yaml"],
    "pyasn1": ["pyasn1"],
    "daemonize": ["daemonize"],
-    "bcrypt": ["bcrypt>=3.1.0"],
+    "bcrypt": ["bcrypt"],
    "pillow": ["PIL"],
    "pydenticon": ["pydenticon"],
    "ujson": ["ujson"],
    "blist": ["blist"],
-    "pysaml2>=3.0.0": ["saml2>=3.0.0"],
+    "pysaml2>=3.0.0,<4.0.0": ["saml2>=3.0.0,<4.0.0"],
    "pymacaroons-pynacl": ["pymacaroons"],
    "msgpack-python>=0.3.0": ["msgpack"],
    "phonenumbers>=8.2.0": ["phonenumbers"],
--- a/synapse/replication/http/init.py
+++ b/synapse/replication/http/init.py
@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2018 New Vector 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.
-
-from synapse.http.server import JsonResource
-from synapse.replication.http import membership, send_event
-
-
-REPLICATION_PREFIX = "/_synapse/replication"
-
-
-class ReplicationRestResource(JsonResource):
-    def __init__(self, hs):
-        JsonResource.__init__(self, hs, canonical_json=False)
-        self.register_servlets(hs)
-
-    def register_servlets(self, hs):
-        send_event.register_servlets(hs, self)
-        membership.register_servlets(hs, self)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Luke Barnard	ea14a142cc	flake8	2017-11-06 16:50:33 +00:00
Luke Barnard	b8da5d0790	Use static column name insertion Otherwise we end up trying to ORDER BY "is_admin", the literal string.	2017-11-06 16:16:24 +00:00
Luke Barnard	4e241fad78	WIP: Return admins of a group first in the list of group users This introduces a ORDER BY that can be optionally added to _simple_select_list transactions'	2017-11-06 15:45:20 +00:00