In get_recent_events_for_room, get the full event json rather than just the event_ids so we don't have to do so many db queries

In get_state_groups, get the full event json rather than just the event_ids so we don't have to do so many db queries
2015-01-22 14:01:10 +00:00 · 2015-01-22 13:37:44 +00:00
293 changed files with 6376 additions and 25646 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -26,19 +26,17 @@ htmlcov

 demo/*.db
 demo/*.log
-demo/*.log.*
 demo/*.pid
-demo/media_store.*
 demo/etc

+graph/*.svg
+graph/*.png
+graph/*.dot
+
+**/webclient/config.js
+**/webclient/test/coverage/
+**/webclient/test/environment-protractor.js
+
 uploads

 .idea/
-media_store/
-
-*.tac
-
-build/
-
-localhost-800*/
-static/client/register/register_config.js
--- a/AUTHORS.rst
+++ b/AUTHORS.rst
@@ -1,40 +0,0 @@
-Erik Johnston <erik at matrix.org>
- * HS core
- * Federation API impl
-
-Mark Haines <mark at matrix.org>
- * HS core
- * Crypto
- * Content repository
- * CS v2 API impl
-
-Kegan Dougal <kegan at matrix.org>
- * HS core
- * CS v1 API impl
- * AS API impl
-
-Paul "LeoNerd" Evans <paul at matrix.org>
- * HS core
- * Presence
- * Typing Notifications
- * Performance metrics and caching layer
-
-Dave Baker <dave at matrix.org>
- * Push notifications
- * Auth CS v2 impl
-
-Matthew Hodgson <matthew at matrix.org>
- * General doc & housekeeping
- * Vertobot/vertobridge matrix<->verto PoC
-
-Emmanuel Rohee <manu at matrix.org>
- * Supporting iOS clients (testability and fallback registration)
-  
-Turned to Dust <dwinslow86 at gmail.com>
- * ArchLinux installation instructions
-
-Brabo <brabo at riseup.net>
- * Installation instruction fixes
-
-Ivan Shapovalov <intelfx100 at gmail.com>
- * contrib/systemd: a sample systemd unit file and a logger configuration
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -1,229 +1,54 @@
-Changes in synapse v0.9.1 (2015-05-26)
-======================================
-
-General:
-
-* Add support for backfilling when a client paginates. This allows servers to
-  request history for a room from remote servers when a client tries to
-  paginate history the server does not have - SYN-36
-* Fix bug where you couldn't disable non-default pushrules - SYN-378
-* Fix ``register_new_user`` script - SYN-359
-* Improve performance of fetching events from the database, this improves both
-  initialSync and sending of events.
-* Improve performance of event streams, allowing synapse to handle more
-  simultaneous connected clients.
-
-Federation:
-
-* Fix bug with existing backfill implementation where it returned the wrong
-  selection of events in some circumstances.
-* Improve performance of joining remote rooms.
-
-Configuration:
-
-* Add support for changing the bind host of the metrics listener via the
-  ``metrics_bind_host`` option.
- 
-
-Changes in synapse v0.9.0-r5 (2015-05-21)
-=========================================
-
-* Add more database caches to reduce amount of work done for each pusher. This
-  radically reduces CPU usage when multiple pushers are set up in the same room.
-
-Changes in synapse v0.9.0 (2015-05-07)
-======================================
-
-General:
-
-* Add support for using a PostgreSQL database instead of SQLite. See
-  `docs/postgres.rst`_ for details.
-* Add password change and reset APIs. See `Registration`_ in the spec.
-* Fix memory leak due to not releasing stale notifiers - SYN-339.
-* Fix race in caches that occasionally caused some presence updates to be
-  dropped - SYN-369.
-* Check server name has not changed on restart.
-* Add a sample systemd unit file and a logger configuration in
-  contrib/systemd. Contributed Ivan Shapovalov.
-
-Federation:
-
-* Add key distribution mechanisms for fetching public keys of unavailable
-  remote home servers. See `Retrieving Server Keys`_ in the spec.
-
-Configuration:
-
-* Add support for multiple config files.
-* Add support for dictionaries in config files.
-* Remove support for specifying config options on the command line, except
-  for:
-
-  * ``--daemonize`` - Daemonize the home server.
-  * ``--manhole`` - Turn on the twisted telnet manhole service on the given
-    port.
-  * ``--database-path`` - The path to a sqlite database to use.
-  * ``--verbose`` - The verbosity level.
-  * ``--log-file`` - File to log to.
-  * ``--log-config`` - Python logging config file.
-  * ``--enable-registration`` - Enable registration for new users.
-
-Application services:
-
-* Reliably retry sending of events from Synapse to application services, as per
-  `Application Services`_ spec.
-* Application services can no longer register via the ``/register`` API,
-  instead their configuration should be saved to a file and listed in the
-  synapse ``app_service_config_files`` config option. The AS configuration file
-  has the same format as the old ``/register`` request.
-  See `docs/application_services.rst`_ for more information.
-
-.. _`docs/postgres.rst`: docs/postgres.rst
-.. _`docs/application_services.rst`: docs/application_services.rst
-.. _`Registration`: https://github.com/matrix-org/matrix-doc/blob/master/specification/10_client_server_api.rst#registration
-.. _`Retrieving Server Keys`: https://github.com/matrix-org/matrix-doc/blob/6f2698/specification/30_server_server_api.rst#retrieving-server-keys
-.. _`Application Services`: https://github.com/matrix-org/matrix-doc/blob/0c6bd9/specification/25_application_service_api.rst#home-server---application-service-api
-
-Changes in synapse v0.8.1 (2015-03-18)
-======================================
-
-* Disable registration by default. New users can be added using the command
-  ``register_new_matrix_user`` or by enabling registration in the config.
-* Add metrics to synapse. To enable metrics use config options
-  ``enable_metrics`` and ``metrics_port``.
-* Fix bug where banning only kicked the user.
-
-Changes in synapse v0.8.0 (2015-03-06)
-======================================
-
-General:
-
-* Add support for registration fallback. This is a page hosted on the server
-  which allows a user to register for an account, regardless of what client
-  they are using (e.g. mobile devices).
-
-* Added new default push rules and made them configurable by clients:
-
-  * Suppress all notice messages.
-  * Notify when invited to a new room.
-  * Notify for messages that don't match any rule.
-  * Notify on incoming call.
-
-Federation:
-
-* Added per host server side rate-limiting of incoming federation requests.
-* Added a ``/get_missing_events/`` API to federation to reduce number of
-  ``/events/`` requests.
-
-Configuration:
-
-* Added configuration option to disable registration:
-  ``disable_registration``.
-* Added configuration option to change soft limit of number of open file
-  descriptors: ``soft_file_limit``.
-* Make ``tls_private_key_path`` optional when running with ``no_tls``.
-
-Application services:
-
-* Application services can now poll on the CS API ``/events`` for their events,
-  by providing their application service ``access_token``.
-* Added exclusive namespace support to application services API.
-
-
-Changes in synapse v0.7.1 (2015-02-19)
-======================================
-
-* Initial alpha implementation of parts of the Application Services API.
-  Including:
-
-  - AS Registration / Unregistration
-  - User Query API
-  - Room Alias Query API
-  - Push transport for receiving events.
-  - User/Alias namespace admin control
-
-* Add cache when fetching events from remote servers to stop repeatedly
-  fetching events with bad signatures.
-* Respect the per remote server retry scheme when fetching both events and
-  server keys to reduce the number of times we send requests to dead servers.
-* Inform remote servers when the local server fails to handle a received event.
-* Turn off python bytecode generation due to problems experienced when
-  upgrading from previous versions.
-
-Changes in synapse v0.7.0 (2015-02-12)
-======================================
-
-* Add initial implementation of the query auth federation API, allowing
-  servers to agree on whether an event should be allowed or rejected.
-* Persist events we have rejected from federation, fixing the bug where
-  servers would keep requesting the same events.
-* Various federation performance improvements, including:
-
-  - Add in memory caches on queries such as:
-
-     * Computing the state of a room at a point in time, used for
-       authorization on federation requests.
-     * Fetching events from the database.
-     * User's room membership, used for authorizing presence updates.
-
-  - Upgraded JSON library to improve parsing and serialisation speeds.
-
-* Add default avatars to new user accounts using pydenticon library.
-* Correctly time out federation requests.
-* Retry federation requests against different servers.
-* Add support for push and push rules.
-* Add alpha versions of proposed new CSv2 APIs, including ``/sync`` API.
-
 Changes in synapse 0.6.1 (2015-01-07)
 =====================================

-* Major optimizations to improve performance of initial sync and event sending
-  in large rooms (by up to 10x)
-* Media repository now includes a Content-Length header on media downloads.
-* Improve quality of thumbnails by changing resizing algorithm.
+ * Major optimizations to improve performance of initial sync and event sending
+   in large rooms (by up to 10x)
+ * Media repository now includes a Content-Length header on media downloads.
+ * Improve quality of thumbnails by changing resizing algorithm.

 Changes in synapse 0.6.0 (2014-12-16)
 =====================================

-* Add new API for media upload and download that supports thumbnailing.
-* Replicate media uploads over multiple homeservers so media is always served
-  to clients from their local homeserver.  This obsoletes the
-  --content-addr parameter and confusion over accessing content directly
-  from remote homeservers.
-* Implement exponential backoff when retrying federation requests when
-  sending to remote homeservers which are offline.
-* Implement typing notifications.
-* Fix bugs where we sent events with invalid signatures due to bugs where
-  we incorrectly persisted events.
-* Improve performance of database queries involving retrieving events.
+ * Add new API for media upload and download that supports thumbnailing.
+ * Replicate media uploads over multiple homeservers so media is always served
+   to clients from their local homeserver.  This obsoletes the
+   --content-addr parameter and confusion over accessing content directly
+   from remote homeservers.
+ * Implement exponential backoff when retrying federation requests when
+   sending to remote homeservers which are offline.
+ * Implement typing notifications.
+ * Fix bugs where we sent events with invalid signatures due to bugs where
+   we incorrectly persisted events.
+ * Improve performance of database queries involving retrieving events.

 Changes in synapse 0.5.4a (2014-12-13)
 ======================================

-* Fix bug while generating the error message when a file path specified in
-  the config doesn't exist.
+ * Fix bug while generating the error message when a file path specified in
+   the config doesn't exist.

 Changes in synapse 0.5.4 (2014-12-03)
 =====================================

-* Fix presence bug where some rooms did not display presence updates for
-  remote users.
-* Do not log SQL timing log lines when started with "-v"
-* Fix potential memory leak.
+ * Fix presence bug where some rooms did not display presence updates for
+   remote users.
+ * Do not log SQL timing log lines when started with "-v"
+ * Fix potential memory leak.

 Changes in synapse 0.5.3c (2014-12-02)
 ======================================

-* Change the default value for the `content_addr` option to use the HTTP
-  listener, as by default the HTTPS listener will be using a self-signed
-  certificate.
+ * Change the default value for the `content_addr` option to use the HTTP
+   listener, as by default the HTTPS listener will be using a self-signed
+   certificate.

 Changes in synapse 0.5.3 (2014-11-27)
 =====================================

-* Fix bug that caused joining a remote room to fail if a single event was not
-  signed correctly.
-* Fix bug which caused servers to continuously try and fetch events from other
-  servers.
+ * Fix bug that caused joining a remote room to fail if a single event was not
+   signed correctly.
+ * Fix bug which caused servers to continuously try and fetch events from other
+   servers.

 Changes in synapse 0.5.2 (2014-11-26)
 =====================================
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -1,118 +0,0 @@
-Contributing code to Matrix
-===========================
-
-Everyone is welcome to contribute code to Matrix
-(https://github.com/matrix-org), provided that they are willing to license
-their contributions under the same license as the project itself. We follow a
-simple 'inbound=outbound' model for contributions: the act of submitting an
-'inbound' contribution means that the contributor agrees to license the code
-under the same terms as the project's overall 'outbound' license - in our
-case, this is almost always Apache Software License v2 (see LICENSE).
-
-How to contribute
-~~~~~~~~~~~~~~~~~
-
-The preferred and easiest way to contribute changes to Matrix is to fork the
-relevant project on github, and then create a pull request to ask us to pull
-your changes into our repo
-(https://help.github.com/articles/using-pull-requests/)
-
-**The single biggest thing you need to know is: please base your changes on
-the develop branch - /not/ master.**
-
-We use the master branch to track the most recent release, so that folks who
-blindly clone the repo and automatically check out master get something that
-works. Develop is the unstable branch where all the development actually
-happens: the workflow is that contributors should fork the develop branch to
-make a 'feature' branch for a particular contribution, and then make a pull
-request to merge this back into the matrix.org 'official' develop branch. We
-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 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
-~~~~~~~~~~
-
-All Matrix projects have a well-defined code-style - and sometimes we've even
-got as far as documenting it... For instance, synapse's code style doc lives
-at https://github.com/matrix-org/synapse/tree/master/docs/code_style.rst.
-
-Please ensure your changes match the cosmetic style of the existing project,
-and **never** mix cosmetic and functional changes in the same commit, as it
-makes it horribly hard to review otherwise.
-
-Attribution
-~~~~~~~~~~~
-
-Everyone who contributes anything to Matrix is welcome to be listed in the
-AUTHORS.rst file for the project in question. Please feel free to include a
-change to AUTHORS.rst in your pull request to list yourself and a short
-description of the area(s) you've worked on. Also, we sometimes have swag to
-give away to contributors - if you feel that Matrix-branded apparel is missing
-from your life, please mail us your shipping address to matrix at matrix.org and we'll try to fix it :)
-
-Sign off
-~~~~~~~~
-
-In order to have a concrete record that your contribution is intentional
-and you agree to license it under the same terms as the project's license, we've adopted the
-same lightweight approach that the Linux Kernel
-(https://www.kernel.org/doc/Documentation/SubmittingPatches), Docker
-(https://github.com/docker/docker/blob/master/CONTRIBUTING.md), and many other
-projects use: the DCO (Developer Certificate of Origin:
-http://developercertificate.org/). This is a simple declaration that you wrote
-the contribution or otherwise have the right to contribute it to Matrix::
-
-    Developer Certificate of Origin
-    Version 1.1
-
-    Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
-    660 York Street, Suite 102,
-    San Francisco, CA 94110 USA
-
-    Everyone is permitted to copy and distribute verbatim copies of this
-    license document, but changing it is not allowed.
-
-    Developer's Certificate of Origin 1.1
-
-    By making a contribution to this project, I certify that:
-
-    (a) The contribution was created in whole or in part by me and I
-        have the right to submit it under the open source license
-        indicated in the file; or
-
-    (b) The contribution is based upon previous work that, to the best
-        of my knowledge, is covered under an appropriate open source
-        license and I have the right under that license to submit that
-        work with modifications, whether created in whole or in part
-        by me, under the same open source license (unless I am
-        permitted to submit under a different license), as indicated
-        in the file; or
-
-    (c) The contribution was provided directly to me by some other
-        person who certified (a), (b) or (c) and I have not modified
-        it.
-
-    (d) I understand and agree that this project and the contribution
-        are public and that a record of the contribution (including all
-        personal information I submit with it, including my sign-off) is
-        maintained indefinitely and may be redistributed consistent with
-        this project or the open source license(s) involved.
-        
-If you agree to this for your contribution, then all that's needed is to
-include the line in your commit or pull request comment::
-
-    Signed-off-by: Your Name <your@email.example.org>
-    
-...using your real name; unfortunately pseudonyms and anonymous contributions
-can't be accepted. Git makes this trivial - just use the -s flag when you do
-``git commit``, having first set ``user.name`` and ``user.email`` git configs
-(which you should have done anyway :)
-
-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!
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,14 +1,4 @@
-include synctl
-include LICENSE
-include VERSION
-include *.rst
-include demo/README
-
-recursive-include synapse/storage/schema *.sql
-
-recursive-include demo *.dh
-recursive-include demo *.py
-recursive-include demo *.sh
 recursive-include docs *
-recursive-include scripts *
 recursive-include tests *.py
+recursive-include synapse/storage/schema *.sql
+recursive-include syweb/webclient *
--- a/README.rst
+++ b/README.rst
@@ -1,5 +1,3 @@
-.. contents::
-
 Introduction
 ============

@@ -8,7 +6,7 @@ VoIP.  The basics you need to know to get up and running are:

 - Everything in Matrix happens in a room.  Rooms are distributed and do not
  exist on any single server.  Rooms can be located using convenience aliases 
-  like ``#matrix:matrix.org`` or ``#test:localhost:8448``.
+  like ``#matrix:matrix.org`` or ``#test:localhost:8008``.

 - Matrix user IDs look like ``@matthew:matrix.org`` (although in the future
  you will normally refer to yourself and others using a 3PID: email
@@ -20,7 +18,7 @@ The overall architecture is::
             https://somewhere.org/_matrix      https://elsewhere.net/_matrix

 ``#matrix:matrix.org`` is the official support room for Matrix, and can be
-accessed by the web client at http://matrix.org/beta or via an IRC bridge at
+accessed by the web client at http://matrix.org/alpha or via an IRC bridge at
 irc://irc.freenode.net/matrix.

 Synapse is currently in rapid development, but as of version 0.5 we believe it 
@@ -69,30 +67,24 @@ Synapse ships with two basic demo Matrix clients: webclient (a basic group chat
 web client demo implemented in AngularJS) and cmdclient (a basic Python
 command line utility which lets you easily see what the JSON APIs are up to).

-Meanwhile, iOS and Android SDKs and clients are available from:
+Meanwhile, iOS and Android SDKs and clients are currently in development and available from:

 - https://github.com/matrix-org/matrix-ios-sdk
- https://github.com/matrix-org/matrix-ios-kit
- https://github.com/matrix-org/matrix-ios-console
 - https://github.com/matrix-org/matrix-android-sdk

-We'd like to invite you to join #matrix:matrix.org (via
-https://matrix.org/beta), run a homeserver, take a look at the Matrix spec at
-https://matrix.org/docs/spec and API docs at https://matrix.org/docs/api,
-experiment with the APIs and the demo clients, and report any bugs via
-https://matrix.org/jira.
+We'd like to invite you to join #matrix:matrix.org (via http://matrix.org/alpha), run a homeserver, take a look at the Matrix spec at
+http://matrix.org/docs/spec, experiment with the APIs and the demo
+clients, and report any bugs via http://matrix.org/jira.

 Thanks for using Matrix!

 [1] End-to-end encryption is currently in development

-Synapse Installation
-====================
-
-Synapse is the reference python/twisted Matrix homeserver implementation.
+Homeserver Installation
+=======================

 System requirements:
- POSIX-compliant system (tested on Linux & OS X)
+- POSIX-compliant system (tested on Linux & OSX)
 - Python 2.7

 Synapse is written in python but some of the libraries is uses are written in
@@ -103,137 +95,55 @@ Installing prerequisites on Ubuntu or Debian::

    $ sudo apt-get install build-essential python2.7-dev libffi-dev \
                           python-pip python-setuptools sqlite3 \
-                           libssl-dev python-virtualenv libjpeg-dev
-                           
-Installing prerequisites on ArchLinux::
-
-    $ sudo pacman -S base-devel python2 python-pip \
-                     python-setuptools python-virtualenv sqlite3
+                           libssl-dev

 Installing prerequisites on Mac OS X::

    $ xcode-select --install
-    $ sudo pip install virtualenv
    
 To install the synapse homeserver run::

-    $ virtualenv -p python2.7 ~/.synapse
-    $ source ~/.synapse/bin/activate
-    $ pip install --process-dependency-links https://github.com/matrix-org/synapse/tarball/master
+    $ pip install --user --process-dependency-links https://github.com/matrix-org/synapse/tarball/master

-This installs synapse, along with the libraries it uses, into a virtual
-environment under ``~/.synapse``.
+This installs synapse, along with the libraries it uses, into
+``$HOME/.local/lib/`` on Linux or ``$HOME/Library/Python/2.7/lib/`` on OSX.

-Alternatively, Silvio Fricke has contributed a Dockerfile to automate the
-above in Docker at https://registry.hub.docker.com/u/silviof/docker-matrix/.
+Your python may not give priority to locally installed libraries over system
+libraries, in which case you must add your local packages to your python path::

-To set up your homeserver, run (in your virtualenv, as before)::
+    $ # on Linux:
+    $ export PYTHONPATH=$HOME/.local/lib/python2.7/site-packages:$PYTHONPATH

-    $ cd ~/.synapse
-    $ python -m synapse.app.homeserver \
-        --server-name machine.my.domain.name \
-        --config-path homeserver.yaml \
-        --generate-config
-
-Substituting your host and domain name as appropriate.
-
-This will generate you a config file that you can then customise, but it will
-also generate a set of keys for you. These keys will allow your Home Server to
-identify itself to other Home Servers, so don't lose or delete them. It would be
-wise to back them up somewhere safe. If, for whatever reason, you do need to
-change your Home Server's keys, you may find that other Home Servers have the
-old key cached. If you update the signing key, you should change the name of the
-key in the <server name>.signing.key file (the second word, which by default is
-, 'auto') to something different.
-
-By default, registration of new users is disabled. You can either enable
-registration in the config by specifying ``enable_registration: true``
-(it is then recommended to also set up CAPTCHA), or
-you can use the command line to register new users::
-
-    $ source ~/.synapse/bin/activate
-    $ register_new_matrix_user -c homeserver.yaml https://localhost:8448
-    New user localpart: erikj
-    Password:
-    Confirm password:
-    Success!
+    $ # on OSX:
+    $ export PYTHONPATH=$HOME/Library/Python/2.7/lib/python/site-packages:$PYTHONPATH

 For reliable VoIP calls to be routed via this homeserver, you MUST configure
 a TURN server.  See docs/turn-howto.rst for details.

-Using PostgreSQL
-================
+Troubleshooting Installation
+----------------------------

-As of Synapse 0.9, `PostgreSQL <http://www.postgresql.org>`_ is supported as an
-alternative to the `SQLite <http://sqlite.org/>`_ database that Synapse has
-traditionally used for convenience and simplicity.
+Synapse requires pip 1.7 or later, so if your OS provides too old a version and 
+you get errors about ``error: no such option: --process-dependency-links`` you 
+may need to manually upgrade it::

-The advantages of Postgres include:
-
- * significant performance improvements due to the superior threading and
-   caching model, smarter query optimiser
- * allowing the DB to be run on separate hardware
- * allowing basic active/backup high-availability with a "hot spare" synapse
-   pointing at the same DB master, as well as enabling DB replication in
-   synapse itself.
-   
-The only disadvantage is that the code is relatively new as of April 2015 and
-may have a few regressions relative to SQLite.
-
-For information on how to install and use PostgreSQL, please see
-`docs/postgres.rst <docs/postgres.rst>`_.
-
-Running Synapse
-===============
-
-To actually run your new homeserver, pick a working directory for Synapse to run 
-(e.g. ``~/.synapse``), and::
-
-    $ cd ~/.synapse
-    $ source ./bin/activate
-    $ synctl start
-
-Platform Specific Instructions
-==============================
-
-ArchLinux
---------
-
-The quickest way to get up and running with ArchLinux is probably with Ivan
-Shapovalov's AUR package from
-https://aur.archlinux.org/packages/matrix-synapse/, which should pull in all
-the necessary dependencies.
-
-Alternatively, to install using pip a few changes may be needed as ArchLinux
-defaults to python 3, but synapse currently assumes python 2.7 by default:
-
-pip may be outdated (6.0.7-1 and needs to be upgraded to 6.0.8-1 )::
-
-    $ sudo pip2.7 install --upgrade pip
+    $ sudo pip install --upgrade pip
    
-You also may need to explicitly specify python 2.7 again during the install
-request::
+If pip crashes mid-installation for reason (e.g. lost terminal), pip may
+refuse to run until you remove the temporary installation directory it
+created. To reset the installation::

-    $ pip2.7 install --process-dependency-links \
-        https://github.com/matrix-org/synapse/tarball/master
+    $ rm -rf /tmp/pip_install_matrix
    
-If you encounter an error with lib bcrypt causing an Wrong ELF Class:
-ELFCLASS32 (x64 Systems), you may need to reinstall py-bcrypt to correctly
-compile it under the right architecture. (This should not be needed if
-installing under virtualenv)::
+pip seems to leak *lots* of memory during installation.  For instance, a Linux 
+host with 512MB of RAM may run out of memory whilst installing Twisted.  If this 
+happens, you will have to individually install the dependencies which are 
+failing, e.g.::

-    $ sudo pip2.7 uninstall py-bcrypt
-    $ sudo pip2.7 install py-bcrypt
-    
-During setup of Synapse you need to call python2.7 directly again::
+    $ pip install --user twisted

-    $ cd ~/.synapse
-    $ python2.7 -m synapse.app.homeserver \
-      --server-name machine.my.domain.name \
-      --config-path homeserver.yaml \
-      --generate-config
-        
-...substituting your host and domain name as appropriate.
+On OSX, if you encounter clang: error: unknown argument: '-mno-fused-madd' you
+will need to export CFLAGS=-Qunused-arguments.

 Windows Install
 ---------------
@@ -245,7 +155,7 @@ Synapse can be installed on Cygwin. It requires the following Cygwin packages:
 - openssl (and openssl-devel, python-openssl)
 - python
 - python-setuptools
-
+ 
 The content repository requires additional packages and will be unable to process
 uploads without them:
 - libjpeg8
@@ -266,37 +176,29 @@ Troubleshooting:
  you do, you may need to create a symlink to ``libsodium.a`` so ``ld`` can find
  it: ``ln -s /usr/local/lib/libsodium.a /usr/lib/libsodium.a``

-Troubleshooting
-===============
+Running Your Homeserver
+=======================

-Troubleshooting Installation
----------------------------
+To actually run your new homeserver, pick a working directory for Synapse to run 
+(e.g. ``~/.synapse``), and::

-Synapse requires pip 1.7 or later, so if your OS provides too old a version and 
-you get errors about ``error: no such option: --process-dependency-links`` you 
-may need to manually upgrade it::
-
-    $ sudo pip install --upgrade pip
-
-If pip crashes mid-installation for reason (e.g. lost terminal), pip may
-refuse to run until you remove the temporary installation directory it
-created. To reset the installation::
-
-    $ rm -rf /tmp/pip_install_matrix
-
-pip seems to leak *lots* of memory during installation.  For instance, a Linux 
-host with 512MB of RAM may run out of memory whilst installing Twisted.  If this 
-happens, you will have to individually install the dependencies which are 
-failing, e.g.::
-
-    $ pip install twisted
-
-On OSX, if you encounter clang: error: unknown argument: '-mno-fused-madd' you
-will need to export CFLAGS=-Qunused-arguments.
+    $ mkdir ~/.synapse
+    $ cd ~/.synapse
+    
+    $ # on Linux
+    $ ~/.local/bin/synctl start
+    
+    $ # on OSX
+    $ ~/Library/Python/2.7/bin/synctl start

 Troubleshooting Running
 -----------------------

+If ``synctl`` fails with ``pkg_resources.DistributionNotFound`` errors you may 
+need a newer version of setuptools than that provided by your OS.::
+
+    $ sudo pip install setuptools --upgrade
+
 If synapse fails with ``missing "sodium.h"`` crypto errors, you may need 
 to manually upgrade PyNaCL, as synapse uses NaCl (http://nacl.cr.yp.to/) for 
 encryption and digital signatures.
@@ -312,37 +214,26 @@ fix try re-installing from PyPI or directly from
    $ # Install from github
    $ pip install --user https://github.com/pyca/pynacl/tarball/master

-ArchLinux
-~~~~~~~~~

-If running `$ synctl start` fails with 'returned non-zero exit status 1',
-you will need to explicitly call Python2.7 - either running as::
+Homeserver Development
+======================

-    $ python2.7 -m synapse.app.homeserver --daemonize -c homeserver.yaml
-    
-...or by editing synctl with the correct python executable.
-
-Synapse Development
-===================
-
-To check out a synapse for development, clone the git repo into a working
+To check out a homeserver for development, clone the git repo into a working
 directory of your choice::

    $ git clone https://github.com/matrix-org/synapse.git
    $ cd synapse

-Synapse has a number of external dependencies, that are easiest
-to install using pip and a virtualenv::
+The homeserver has a number of external dependencies, that are easiest
+to install by making setup.py do so, in --user mode::

-    $ virtualenv env
-    $ source env/bin/activate
-    $ python synapse/python_dependencies.py | xargs -n1 pip install
-    $ pip install setuptools_trial mock
+    $ python setup.py develop --user

-This will run a process of downloading and installing all the needed
-dependencies into a virtual env.
+This will run a process of downloading and installing into your
+user's .local/lib directory all of the required dependencies that are
+missing.

-Once this is done, you may wish to run Synapse's unit tests, to
+Once this is done, you may wish to run the homeserver's unit tests, to
 check that everything is installed as it should be::

    $ python setup.py test
@@ -354,14 +245,14 @@ This should end with a 'PASSED' result::
    PASSED (successes=143)


-Upgrading an existing Synapse
-=============================
+Upgrading an existing homeserver
+================================

-IMPORTANT: Before upgrading an existing synapse to a new version, please
+IMPORTANT: Before upgrading an existing homeserver to a new version, please
 refer to UPGRADE.rst for any additional instructions.

 Otherwise, simply re-install the new codebase over the current one - e.g.
-by ``pip install --process-dependency-links
+by ``pip install --user --process-dependency-links
 https://github.com/matrix-org/synapse/tarball/master``
 if using pip, or by ``git pull`` if running off a git working copy.

@@ -388,9 +279,9 @@ For the first form, simply pass the required hostname (of the machine) as the

    $ python -m synapse.app.homeserver \
        --server-name machine.my.domain.name \
-        --config-path homeserver.yaml \
+        --config-path homeserver.config \
        --generate-config
-    $ python -m synapse.app.homeserver --config-path homeserver.yaml
+    $ python -m synapse.app.homeserver --config-path homeserver.config

 Alternatively, you can run ``synctl start`` to guide you through the process.

@@ -400,7 +291,7 @@ and port where the server is running.  (At the current time synapse does not
 support clustering multiple servers into a single logical homeserver).  The DNS
 record would then look something like::

-    $ dig -t srv _matrix._tcp.machine.my.domain.name
+    $ dig -t srv _matrix._tcp.machine.my.domaine.name
    _matrix._tcp    IN      SRV     10 0 8448 machine.my.domain.name.


@@ -409,16 +300,21 @@ SRV record, as that is the name other machines will expect it to have::

    $ python -m synapse.app.homeserver \
        --server-name YOURDOMAIN \
-        --config-path homeserver.yaml \
+        --bind-port 8448 \
+        --config-path homeserver.config \
        --generate-config
-    $ python -m synapse.app.homeserver --config-path homeserver.yaml
+    $ python -m synapse.app.homeserver --config-path homeserver.config


 You may additionally want to pass one or more "-v" options, in order to
 increase the verbosity of logging output; at least for initial testing.

-Running a Demo Federation of Synapses
-------------------------------------
+For the initial alpha release, the homeserver is not speaking TLS for
+either client-server or server-server traffic for ease of debugging. We have
+also not spent any time yet getting the homeserver to run behind loadbalancers.
+
+Running a Demo Federation of Homeservers
+----------------------------------------

 If you want to get up and running quickly with a trio of homeservers in a
 private federation (``localhost:8080``, ``localhost:8081`` and
@@ -453,10 +349,7 @@ account. Your name will take the form of::
 Specify your desired localpart in the topmost box of the "Register for an
 account" form, and click the "Register" button. Hostnames can contain ports if
 required due to lack of SRV records (e.g. @matthew:localhost:8448 on an
-internal synapse sandbox running on localhost).
-
-If registration fails, you may need to enable it in the homeserver (see
-`Synapse Installation`_ above)
+internal synapse sandbox running on localhost)


 Logging In To An Existing Account
@@ -482,7 +375,7 @@ track 3PID logins and publish end-user public keys.

 It's currently early days for identity servers as Matrix is not yet using 3PIDs
 as the primary means of identity and E2E encryption is not complete. As such,
-we are running a single identity server (https://matrix.org) at the current
+we are running a single identity server (http://matrix.org:8090) at the current
 time.


--- a/UPGRADE.rst
+++ b/UPGRADE.rst
@@ -1,66 +1,3 @@
-Upgrading to v0.9.0
-===================
-
-Application services have had a breaking API change in this version.
-
-They can no longer register themselves with a home server using the AS HTTP API. This
-decision was made because a compromised application service with free reign to register
-any regex in effect grants full read/write access to the home server if a regex of ``.*``
-is used. An attack where a compromised AS re-registers itself with ``.*`` was deemed too
-big of a security risk to ignore, and so the ability to register with the HS remotely has
-been removed.
-
-It has been replaced by specifying a list of application service registrations in
-``homeserver.yaml``::
-
-  app_service_config_files: ["registration-01.yaml", "registration-02.yaml"]
-  
-Where ``registration-01.yaml`` looks like::
-
-  url: <String>  # e.g. "https://my.application.service.com"
-  as_token: <String>
-  hs_token: <String>
-  sender_localpart: <String>  # This is a new field which denotes the user_id localpart when using the AS token
-  namespaces:
-    users:
-      - exclusive: <Boolean>
-        regex: <String>  # e.g. "@prefix_.*"
-    aliases:
-      - exclusive: <Boolean>
-        regex: <String>
-    rooms:
-      - exclusive: <Boolean>
-        regex: <String>
-
-Upgrading to v0.8.0
-===================
-
-Servers which use captchas will need to add their public key to::
-
-  static/client/register/register_config.js
-
-    window.matrixRegistrationConfig = {
-        recaptcha_public_key: "YOUR_PUBLIC_KEY"
-    };
-
-This is required in order to support registration fallback (typically used on
-mobile devices).
-
-
-Upgrading to v0.7.0
-===================
-
-New dependencies are:
-
- pydenticon
- simplejson
- syutil
- matrix-angular-sdk
-
-To pull in these dependencies in a virtual env, run::
-
-    python synapse/python_dependencies.py | xargs -n 1 pip install
-
 Upgrading to v0.6.0
 ===================

--- a/1
+++ b/1
@@ -0,0 +1 @@
+0.6.1b
--- a/contrib/graph/graph2.py
+++ b/contrib/graph/graph2.py
@@ -21,7 +21,6 @@ import datetime
 import argparse

 from synapse.events import FrozenEvent
-from synapse.util.frozenutils import unfreeze


 def make_graph(db_name, room_id, file_prefix, limit):
@@ -71,7 +70,7 @@ def make_graph(db_name, room_id, file_prefix, limit):
            float(event.origin_server_ts) / 1000
        ).strftime('%Y-%m-%d %H:%M:%S,%f')

-        content = json.dumps(unfreeze(event.get_dict()["content"]))
+        content = json.dumps(event.get_dict()["content"])

        label = (
            "<"
--- a/contrib/jitsimeetbridge/jitsimeetbridge.py
+++ b/contrib/jitsimeetbridge/jitsimeetbridge.py
@@ -39,43 +39,43 @@ ROOMDOMAIN="meet.jit.si"
 #ROOMDOMAIN="conference.jitsi.vuc.me"

 class TrivialMatrixClient:
-    def __init__(self, access_token):
-        self.token = None
-        self.access_token = access_token
+	def __init__(self, access_token):
+		self.token = None
+		self.access_token = access_token

-    def getEvent(self):
-        while True:
-            url = MATRIXBASE+'events?access_token='+self.access_token+"&timeout=60000"
-            if self.token:
-                url += "&from="+self.token
-            req = grequests.get(url)
-            resps = grequests.map([req])
-            obj = json.loads(resps[0].content)
-            print "incoming from matrix",obj
-            if 'end' not in obj:
-                continue
-            self.token = obj['end']
-            if len(obj['chunk']):
-                return obj['chunk'][0]
+	def getEvent(self):
+		while True:
+			url = MATRIXBASE+'events?access_token='+self.access_token+"&timeout=60000"
+			if self.token:
+				url += "&from="+self.token
+			req = grequests.get(url)
+			resps = grequests.map([req])
+			obj = json.loads(resps[0].content)
+			print "incoming from matrix",obj
+			if 'end' not in obj:
+				continue
+			self.token = obj['end']
+			if len(obj['chunk']):
+				return obj['chunk'][0]

-    def joinRoom(self, roomId):
-        url = MATRIXBASE+'rooms/'+roomId+'/join?access_token='+self.access_token
-        print url
-        headers={ 'Content-Type': 'application/json' }
-        req = grequests.post(url, headers=headers, data='{}')
-        resps = grequests.map([req])
-        obj = json.loads(resps[0].content)
-        print "response: ",obj
+	def joinRoom(self, roomId):
+		url = MATRIXBASE+'rooms/'+roomId+'/join?access_token='+self.access_token
+		print url
+		headers={ 'Content-Type': 'application/json' }
+		req = grequests.post(url, headers=headers, data='{}')
+		resps = grequests.map([req])
+		obj = json.loads(resps[0].content)
+		print "response: ",obj

-    def sendEvent(self, roomId, evType, event):
-        url = MATRIXBASE+'rooms/'+roomId+'/send/'+evType+'?access_token='+self.access_token
-        print url
-        print json.dumps(event)
-        headers={ 'Content-Type': 'application/json' }
-        req = grequests.post(url, headers=headers, data=json.dumps(event))
-        resps = grequests.map([req])
-        obj = json.loads(resps[0].content)
-        print "response: ",obj
+	def sendEvent(self, roomId, evType, event):
+		url = MATRIXBASE+'rooms/'+roomId+'/send/'+evType+'?access_token='+self.access_token
+		print url
+		print json.dumps(event)
+		headers={ 'Content-Type': 'application/json' }
+		req = grequests.post(url, headers=headers, data=json.dumps(event))
+		resps = grequests.map([req])
+		obj = json.loads(resps[0].content)
+		print "response: ",obj



@@ -83,178 +83,178 @@ xmppClients = {}


 def matrixLoop():
-    while True:
-        ev = matrixCli.getEvent()
-        print ev
-        if ev['type'] == 'm.room.member':
-            print 'membership event'
-            if ev['membership'] == 'invite' and ev['state_key'] == MYUSERNAME:
-                roomId = ev['room_id']
-                print "joining room %s" % (roomId)
-                matrixCli.joinRoom(roomId)
-        elif ev['type'] == 'm.room.message':
-            if ev['room_id'] in xmppClients:
-                print "already have a bridge for that user, ignoring"
-                continue
-            print "got message, connecting"
-            xmppClients[ev['room_id']] = TrivialXmppClient(ev['room_id'], ev['user_id'])
-            gevent.spawn(xmppClients[ev['room_id']].xmppLoop)
-        elif ev['type'] == 'm.call.invite':
-            print "Incoming call"
-            #sdp = ev['content']['offer']['sdp']
-            #print "sdp: %s" % (sdp)
-            #xmppClients[ev['room_id']] = TrivialXmppClient(ev['room_id'], ev['user_id'])
-            #gevent.spawn(xmppClients[ev['room_id']].xmppLoop)
-        elif ev['type'] == 'm.call.answer':
-            print "Call answered"
-            sdp = ev['content']['answer']['sdp']
-            if ev['room_id'] not in xmppClients:
-                print "We didn't have a call for that room"
-                continue
-            # should probably check call ID too
-            xmppCli = xmppClients[ev['room_id']]
-            xmppCli.sendAnswer(sdp)
-        elif ev['type'] == 'm.call.hangup':
-            if ev['room_id'] in xmppClients:
-                xmppClients[ev['room_id']].stop()
-                del xmppClients[ev['room_id']]
-
+	while True:
+		ev = matrixCli.getEvent()
+		print ev
+		if ev['type'] == 'm.room.member':
+			print 'membership event'
+			if ev['membership'] == 'invite' and ev['state_key'] == MYUSERNAME:
+				roomId = ev['room_id']
+				print "joining room %s" % (roomId)
+				matrixCli.joinRoom(roomId)
+		elif ev['type'] == 'm.room.message':
+			if ev['room_id'] in xmppClients:
+				print "already have a bridge for that user, ignoring"
+				continue
+			print "got message, connecting"
+			xmppClients[ev['room_id']] = TrivialXmppClient(ev['room_id'], ev['user_id'])
+			gevent.spawn(xmppClients[ev['room_id']].xmppLoop)
+		elif ev['type'] == 'm.call.invite':
+			print "Incoming call"
+			#sdp = ev['content']['offer']['sdp']
+			#print "sdp: %s" % (sdp)
+			#xmppClients[ev['room_id']] = TrivialXmppClient(ev['room_id'], ev['user_id'])
+			#gevent.spawn(xmppClients[ev['room_id']].xmppLoop)
+		elif ev['type'] == 'm.call.answer':
+			print "Call answered"
+			sdp = ev['content']['answer']['sdp']
+			if ev['room_id'] not in xmppClients:
+				print "We didn't have a call for that room"
+				continue
+			# should probably check call ID too
+			xmppCli = xmppClients[ev['room_id']]
+			xmppCli.sendAnswer(sdp)
+		elif ev['type'] == 'm.call.hangup':
+			if ev['room_id'] in xmppClients:
+				xmppClients[ev['room_id']].stop()
+				del xmppClients[ev['room_id']]
+			
 class TrivialXmppClient:
-    def __init__(self, matrixRoom, userId):
-        self.rid = 0
-        self.matrixRoom = matrixRoom
-        self.userId = userId
-        self.running = True
+	def __init__(self, matrixRoom, userId):
+		self.rid = 0
+		self.matrixRoom = matrixRoom
+		self.userId = userId
+		self.running = True

-    def stop(self):
-        self.running = False
+	def stop(self):
+		self.running = False

-    def nextRid(self):
-        self.rid += 1
-        return '%d' % (self.rid)
+	def nextRid(self):
+		self.rid += 1
+		return '%d' % (self.rid)

-    def sendIq(self, xml):
-        fullXml = "<body rid='%s' xmlns='http://jabber.org/protocol/httpbind' sid='%s'>%s</body>" % (self.nextRid(), self.sid, xml)
-        #print "\t>>>%s" % (fullXml)
-        return self.xmppPoke(fullXml)
+	def sendIq(self, xml):
+		fullXml = "<body rid='%s' xmlns='http://jabber.org/protocol/httpbind' sid='%s'>%s</body>" % (self.nextRid(), self.sid, xml)
+		#print "\t>>>%s" % (fullXml)
+		return self.xmppPoke(fullXml)
+		
+	def xmppPoke(self, xml):
+		headers = {'Content-Type': 'application/xml'}
+		req = grequests.post(HTTPBIND, verify=False, headers=headers, data=xml)
+		resps = grequests.map([req])
+		obj = BeautifulSoup(resps[0].content)
+		return obj

-    def xmppPoke(self, xml):
-        headers = {'Content-Type': 'application/xml'}
-        req = grequests.post(HTTPBIND, verify=False, headers=headers, data=xml)
-        resps = grequests.map([req])
-        obj = BeautifulSoup(resps[0].content)
-        return obj
+	def sendAnswer(self, answer):
+		print "sdp from matrix client",answer
+		p = subprocess.Popen(['node', 'unjingle/unjingle.js', '--sdp'], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+		jingle, out_err = p.communicate(answer)
+		jingle = jingle % {
+			'tojid': self.callfrom,
+			'action': 'session-accept',
+			'initiator': self.callfrom,
+			'responder': self.jid,
+			'sid': self.callsid
+		}
+		print "answer jingle from sdp",jingle
+		res = self.sendIq(jingle)
+		print "reply from answer: ",res
+		
+		self.ssrcs = {}
+		jingleSoup = BeautifulSoup(jingle)
+		for cont in jingleSoup.iq.jingle.findAll('content'):
+			if cont.description:
+				self.ssrcs[cont['name']] = cont.description['ssrc']
+		print "my ssrcs:",self.ssrcs

-    def sendAnswer(self, answer):
-        print "sdp from matrix client",answer
-        p = subprocess.Popen(['node', 'unjingle/unjingle.js', '--sdp'], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
-        jingle, out_err = p.communicate(answer)
-        jingle = jingle % {
-            'tojid': self.callfrom,
-            'action': 'session-accept',
-            'initiator': self.callfrom,
-            'responder': self.jid,
-            'sid': self.callsid
-        }
-        print "answer jingle from sdp",jingle
-        res = self.sendIq(jingle)
-        print "reply from answer: ",res
-
-        self.ssrcs = {}
-        jingleSoup = BeautifulSoup(jingle)
-        for cont in jingleSoup.iq.jingle.findAll('content'):
-            if cont.description:
-                self.ssrcs[cont['name']] = cont.description['ssrc']
-        print "my ssrcs:",self.ssrcs
-
-        gevent.joinall([
-                gevent.spawn(self.advertiseSsrcs)
-        ])
-
-    def advertiseSsrcs(self):
+		gevent.joinall([
+ 		       gevent.spawn(self.advertiseSsrcs)
+		])
+		
+	def advertiseSsrcs(self):
                time.sleep(7)
-        print "SSRC spammer started"
-        while self.running:
-            ssrcMsg = "<presence to='%(tojid)s' xmlns='jabber:client'><x xmlns='http://jabber.org/protocol/muc'/><c xmlns='http://jabber.org/protocol/caps' hash='sha-1' node='http://jitsi.org/jitsimeet' ver='0WkSdhFnAUxrz4ImQQLdB80GFlE='/><nick xmlns='http://jabber.org/protocol/nick'>%(nick)s</nick><stats xmlns='http://jitsi.org/jitmeet/stats'><stat name='bitrate_download' value='175'/><stat name='bitrate_upload' value='176'/><stat name='packetLoss_total' value='0'/><stat name='packetLoss_download' value='0'/><stat name='packetLoss_upload' value='0'/></stats><media xmlns='http://estos.de/ns/mjs'><source type='audio' ssrc='%(assrc)s' direction='sendre'/><source type='video' ssrc='%(vssrc)s' direction='sendre'/></media></presence>" % { 'tojid': "%s@%s/%s" % (ROOMNAME, ROOMDOMAIN, self.shortJid), 'nick': self.userId, 'assrc': self.ssrcs['audio'], 'vssrc': self.ssrcs['video'] }
-            res = self.sendIq(ssrcMsg)
-            print "reply from ssrc announce: ",res
-            time.sleep(10)
+		print "SSRC spammer started"
+		while self.running:
+			ssrcMsg = "<presence to='%(tojid)s' xmlns='jabber:client'><x xmlns='http://jabber.org/protocol/muc'/><c xmlns='http://jabber.org/protocol/caps' hash='sha-1' node='http://jitsi.org/jitsimeet' ver='0WkSdhFnAUxrz4ImQQLdB80GFlE='/><nick xmlns='http://jabber.org/protocol/nick'>%(nick)s</nick><stats xmlns='http://jitsi.org/jitmeet/stats'><stat name='bitrate_download' value='175'/><stat name='bitrate_upload' value='176'/><stat name='packetLoss_total' value='0'/><stat name='packetLoss_download' value='0'/><stat name='packetLoss_upload' value='0'/></stats><media xmlns='http://estos.de/ns/mjs'><source type='audio' ssrc='%(assrc)s' direction='sendre'/><source type='video' ssrc='%(vssrc)s' direction='sendre'/></media></presence>" % { 'tojid': "%s@%s/%s" % (ROOMNAME, ROOMDOMAIN, self.shortJid), 'nick': self.userId, 'assrc': self.ssrcs['audio'], 'vssrc': self.ssrcs['video'] }
+			res = self.sendIq(ssrcMsg)
+			print "reply from ssrc announce: ",res
+			time.sleep(10)
+		
+		

+	def xmppLoop(self):
+		self.matrixCallId = time.time()
+		res = self.xmppPoke("<body rid='%s' xmlns='http://jabber.org/protocol/httpbind' to='%s' xml:lang='en' wait='60' hold='1' content='text/xml; charset=utf-8' ver='1.6' xmpp:version='1.0' xmlns:xmpp='urn:xmpp:xbosh'/>" % (self.nextRid(), HOST))

+		print res
+		self.sid = res.body['sid']
+		print "sid %s" % (self.sid)

-    def xmppLoop(self):
-        self.matrixCallId = time.time()
-        res = self.xmppPoke("<body rid='%s' xmlns='http://jabber.org/protocol/httpbind' to='%s' xml:lang='en' wait='60' hold='1' content='text/xml; charset=utf-8' ver='1.6' xmpp:version='1.0' xmlns:xmpp='urn:xmpp:xbosh'/>" % (self.nextRid(), HOST))
+		res = self.sendIq("<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='ANONYMOUS'/>")

-        print res
-        self.sid = res.body['sid']
-        print "sid %s" % (self.sid)
+		res = self.xmppPoke("<body rid='%s' xmlns='http://jabber.org/protocol/httpbind' sid='%s' to='%s' xml:lang='en' xmpp:restart='true' xmlns:xmpp='urn:xmpp:xbosh'/>" % (self.nextRid(), self.sid, HOST))
+	
+		res = self.sendIq("<iq type='set' id='_bind_auth_2' xmlns='jabber:client'><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/></iq>")
+		print res

-        res = self.sendIq("<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='ANONYMOUS'/>")
+		self.jid = res.body.iq.bind.jid.string
+		print "jid: %s" % (self.jid)
+		self.shortJid = self.jid.split('-')[0]

-        res = self.xmppPoke("<body rid='%s' xmlns='http://jabber.org/protocol/httpbind' sid='%s' to='%s' xml:lang='en' xmpp:restart='true' xmlns:xmpp='urn:xmpp:xbosh'/>" % (self.nextRid(), self.sid, HOST))
+		res = self.sendIq("<iq type='set' id='_session_auth_2' xmlns='jabber:client'><session xmlns='urn:ietf:params:xml:ns:xmpp-session'/></iq>")

-        res = self.sendIq("<iq type='set' id='_bind_auth_2' xmlns='jabber:client'><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/></iq>")
-        print res
+		#randomthing = res.body.iq['to']
+		#whatsitpart = randomthing.split('-')[0]

-        self.jid = res.body.iq.bind.jid.string
-        print "jid: %s" % (self.jid)
-        self.shortJid = self.jid.split('-')[0]
+		#print "other random bind thing: %s" % (randomthing)

-        res = self.sendIq("<iq type='set' id='_session_auth_2' xmlns='jabber:client'><session xmlns='urn:ietf:params:xml:ns:xmpp-session'/></iq>")
+		# advertise preence to the jitsi room, with our nick
+		res = self.sendIq("<iq type='get' to='%s' xmlns='jabber:client' id='1:sendIQ'><services xmlns='urn:xmpp:extdisco:1'><service host='%s'/></services></iq><presence to='%s@%s/d98f6c40' xmlns='jabber:client'><x xmlns='http://jabber.org/protocol/muc'/><c xmlns='http://jabber.org/protocol/caps' hash='sha-1' node='http://jitsi.org/jitsimeet' ver='0WkSdhFnAUxrz4ImQQLdB80GFlE='/><nick xmlns='http://jabber.org/protocol/nick'>%s</nick></presence>" % (HOST, TURNSERVER, ROOMNAME, ROOMDOMAIN, self.userId))
+		self.muc = {'users': []}
+		for p in res.body.findAll('presence'):
+			u = {}
+			u['shortJid'] = p['from'].split('/')[1]
+			if p.c and p.c.nick:
+				u['nick'] = p.c.nick.string
+			self.muc['users'].append(u)
+		print "muc: ",self.muc

-        #randomthing = res.body.iq['to']
-        #whatsitpart = randomthing.split('-')[0]
-
-        #print "other random bind thing: %s" % (randomthing)
-
-        # advertise preence to the jitsi room, with our nick
-        res = self.sendIq("<iq type='get' to='%s' xmlns='jabber:client' id='1:sendIQ'><services xmlns='urn:xmpp:extdisco:1'><service host='%s'/></services></iq><presence to='%s@%s/d98f6c40' xmlns='jabber:client'><x xmlns='http://jabber.org/protocol/muc'/><c xmlns='http://jabber.org/protocol/caps' hash='sha-1' node='http://jitsi.org/jitsimeet' ver='0WkSdhFnAUxrz4ImQQLdB80GFlE='/><nick xmlns='http://jabber.org/protocol/nick'>%s</nick></presence>" % (HOST, TURNSERVER, ROOMNAME, ROOMDOMAIN, self.userId))
-        self.muc = {'users': []}
-        for p in res.body.findAll('presence'):
-            u = {}
-            u['shortJid'] = p['from'].split('/')[1]
-            if p.c and p.c.nick:
-                u['nick'] = p.c.nick.string
-            self.muc['users'].append(u)
-        print "muc: ",self.muc
-
-        # wait for stuff
-        while True:
-            print "waiting..."
-            res = self.sendIq("")
-            print "got from stream: ",res
-            if res.body.iq:
-                jingles = res.body.iq.findAll('jingle')
-                if len(jingles):
-                    self.callfrom = res.body.iq['from']
-                    self.handleInvite(jingles[0])
-            elif 'type' in res.body and res.body['type'] == 'terminate':
-                self.running = False
-                del xmppClients[self.matrixRoom]
-                        return
-
-    def handleInvite(self, jingle):
-        self.initiator = jingle['initiator']
-        self.callsid = jingle['sid']
-        p = subprocess.Popen(['node', 'unjingle/unjingle.js', '--jingle'], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
-        print "raw jingle invite",str(jingle)
-        sdp, out_err = p.communicate(str(jingle))
-        print "transformed remote offer sdp",sdp
-        inviteEvent = {
-            'offer': {
-                'type': 'offer',
-                'sdp': sdp
-            },
-            'call_id': self.matrixCallId,
-            'version': 0,
-            'lifetime': 30000
-        }
-        matrixCli.sendEvent(self.matrixRoom, 'm.call.invite', inviteEvent)
+		# wait for stuff
+		while True:
+			print "waiting..."
+			res = self.sendIq("")
+			print "got from stream: ",res
+			if res.body.iq:
+				jingles = res.body.iq.findAll('jingle')
+				if len(jingles):
+					self.callfrom = res.body.iq['from']
+					self.handleInvite(jingles[0])
+			elif 'type' in res.body and res.body['type'] == 'terminate':
+				self.running = False
+				del xmppClients[self.matrixRoom]
+            			return 

+	def handleInvite(self, jingle):
+		self.initiator = jingle['initiator']
+		self.callsid = jingle['sid']
+		p = subprocess.Popen(['node', 'unjingle/unjingle.js', '--jingle'], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+		print "raw jingle invite",str(jingle)
+		sdp, out_err = p.communicate(str(jingle))
+		print "transformed remote offer sdp",sdp
+		inviteEvent = {
+			'offer': {
+				'type': 'offer',
+				'sdp': sdp
+			},
+			'call_id': self.matrixCallId,
+			'version': 0,
+			'lifetime': 30000
+		}
+		matrixCli.sendEvent(self.matrixRoom, 'm.call.invite', inviteEvent)
+		
 matrixCli = TrivialMatrixClient(ACCESS_TOKEN)

 gevent.joinall([
-    gevent.spawn(matrixLoop)
+	gevent.spawn(matrixLoop)
 ])

--- a/contrib/scripts/kick_users.py
+++ b/contrib/scripts/kick_users.py
@@ -1,93 +0,0 @@
-#!/usr/bin/env python
-from argparse import ArgumentParser
-import json
-import requests
-import sys
-import urllib
-
-def _mkurl(template, kws):
-    for key in kws:
-        template = template.replace(key, kws[key])
-    return template
-
-def main(hs, room_id, access_token, user_id_prefix, why):
-    if not why:
-        why = "Automated kick."
-    print "Kicking members on %s in room %s matching %s" % (hs, room_id, user_id_prefix)
-    room_state_url = _mkurl(
-        "$HS/_matrix/client/api/v1/rooms/$ROOM/state?access_token=$TOKEN",
-        {
-            "$HS": hs,
-            "$ROOM": room_id,
-            "$TOKEN": access_token
-        }
-    )
-    print "Getting room state => %s" % room_state_url
-    res = requests.get(room_state_url)
-    print "HTTP %s" % res.status_code
-    state_events = res.json()
-    if "error" in state_events:
-        print "FATAL"
-        print state_events
-        return
-
-    kick_list = []
-    room_name = room_id
-    for event in state_events:
-        if not event["type"] == "m.room.member":
-            if event["type"] == "m.room.name":
-                room_name = event["content"].get("name")
-            continue
-        if not event["content"].get("membership") == "join":
-            continue
-        if event["state_key"].startswith(user_id_prefix):
-            kick_list.append(event["state_key"])
-
-    if len(kick_list) == 0:
-        print "No user IDs match the prefix '%s'" % user_id_prefix
-        return
-
-    print "The following user IDs will be kicked from %s" % room_name
-    for uid in kick_list:
-        print uid
-    doit = raw_input("Continue? [Y]es\n")
-    if len(doit) > 0 and doit.lower() == 'y':
-        print "Kicking members..."
-        # encode them all
-        kick_list = [urllib.quote(uid) for uid in kick_list]
-        for uid in kick_list:
-            kick_url = _mkurl(
-                "$HS/_matrix/client/api/v1/rooms/$ROOM/state/m.room.member/$UID?access_token=$TOKEN",
-                {
-                    "$HS": hs,
-                    "$UID": uid,
-                    "$ROOM": room_id,
-                    "$TOKEN": access_token
-                }
-            )
-            kick_body = {
-                "membership": "leave",
-                "reason": why
-            }
-            print "Kicking %s" % uid
-            res = requests.put(kick_url, data=json.dumps(kick_body))
-            if res.status_code != 200:
-                print "ERROR: HTTP %s" % res.status_code
-            if res.json().get("error"):
-                print "ERROR: JSON %s" % res.json()
-            
-    
-
-if __name__ == "__main__":
-    parser = ArgumentParser("Kick members in a room matching a certain user ID prefix.")
-    parser.add_argument("-u","--user-id",help="The user ID prefix e.g. '@irc_'")
-    parser.add_argument("-t","--token",help="Your access_token")
-    parser.add_argument("-r","--room",help="The room ID to kick members in")
-    parser.add_argument("-s","--homeserver",help="The base HS url e.g. http://matrix.org")
-    parser.add_argument("-w","--why",help="Reason for the kick. Optional.")
-    args = parser.parse_args()
-    if not args.room or not args.token or not args.user_id or not args.homeserver:
-        parser.print_help()
-        sys.exit(1)
-    else:
-        main(args.homeserver, args.room, args.token, args.user_id, args.why)
--- a/contrib/systemd/log_config.yaml
+++ b/contrib/systemd/log_config.yaml
@@ -1,23 +0,0 @@
-version: 1
-
-# In systemd's journal, loglevel is implicitly stored, so let's omit it
-# from the message text.
-formatters:
-    journal_fmt:
-        format: '%(name)s: [%(request)s] %(message)s'
-
-filters:
-    context:
-        (): synapse.util.logcontext.LoggingContextFilter
-        request: ""
-
-handlers:
-    journal:
-        class: systemd.journal.JournalHandler
-        formatter: journal_fmt
-        filters: [context]
-        SYSLOG_IDENTIFIER: synapse
-
-root:
-    level: INFO
-    handlers: [journal]
--- a/contrib/systemd/synapse.service
+++ b/contrib/systemd/synapse.service
@@ -1,16 +0,0 @@
-# This assumes that Synapse has been installed as a system package
-# (e.g. https://aur.archlinux.org/packages/matrix-synapse/ for ArchLinux)
-# rather than in a user home directory or similar under virtualenv.
-
-[Unit]
-Description=Synapse Matrix homeserver
-
-[Service]
-Type=simple
-User=synapse
-Group=synapse
-WorkingDirectory=/var/lib/synapse
-ExecStart=/usr/bin/python2.7 -m synapse.app.homeserver --config-path=/etc/synapse/homeserver.yaml --log-config=/etc/synapse/log_config.yaml
-
-[Install]
-WantedBy=multi-user.target
--- a/contrib/vertobot/bot.pl
+++ b/contrib/vertobot/bot.pl
@@ -175,12 +175,13 @@ sub on_room_message
 my $verto_connecting = $loop->new_future;
 $bot_verto->connect(
    %{ $CONFIG{"verto-bot"} },
+    on_connected => sub {
+        warn("[Verto] connected to websocket");
+        $verto_connecting->done($bot_verto) if not $verto_connecting->is_done;
+    },
    on_connect_error => sub { die "Cannot connect to verto - $_[-1]" },
    on_resolve_error => sub { die "Cannot resolve to verto - $_[-1]" },        
-)->then( sub { 
-    warn("[Verto] connected to websocket");
-    $verto_connecting->done($bot_verto) if not $verto_connecting->is_done;
-});
+);

 Future->needs_all(
    $bot_matrix->login( %{ $CONFIG{"matrix-bot"} } )->then( sub {
--- a/contrib/vertobot/bridge.pl
+++ b/contrib/vertobot/bridge.pl
@@ -1,493 +0,0 @@
-#!/usr/bin/env perl 
-
-use strict;
-use warnings;
-use 5.010; # //
-use IO::Socket::SSL qw(SSL_VERIFY_NONE);
-use IO::Async::Loop;
-use Net::Async::WebSocket::Client;
-use Net::Async::HTTP;
-use Net::Async::HTTP::Server;
-use JSON;
-use YAML;
-use Data::UUID;
-use Getopt::Long;
-use Data::Dumper;
-use URI::Encode qw(uri_encode uri_decode);
-    
-binmode STDOUT, ":encoding(UTF-8)";
-binmode STDERR, ":encoding(UTF-8)";
-
-my $msisdn_to_matrix = {
-    '447417892400' => '@matthew:matrix.org',
-};
-
-my $matrix_to_msisdn = {};
-foreach (keys %$msisdn_to_matrix) {
-    $matrix_to_msisdn->{$msisdn_to_matrix->{$_}} = $_;
-}
-
-
-my $loop = IO::Async::Loop->new;
-# Net::Async::HTTP + SSL + IO::Poll doesn't play well. See
-#   https://rt.cpan.org/Ticket/Display.html?id=93107
-# ref $loop eq "IO::Async::Loop::Poll" and
-#     warn "Using SSL with IO::Poll causes known memory-leaks!!\n";
-
-GetOptions(
-   'C|config=s' => \my $CONFIG,
-   'eval-from=s' => \my $EVAL_FROM,
-) or exit 1;
-
-if( defined $EVAL_FROM ) {
-    # An emergency 'eval() this file' hack
-    $SIG{HUP} = sub {
-        my $code = do {
-            open my $fh, "<", $EVAL_FROM or warn( "Cannot read - $!" ), return;
-            local $/; <$fh>
-        };
-
-        eval $code or warn "Cannot eval() - $@";
-    };
-}
-
-defined $CONFIG or die "Must supply --config\n";
-
-my %CONFIG = %{ YAML::LoadFile( $CONFIG ) };
-
-my %MATRIX_CONFIG = %{ $CONFIG{matrix} };
-# No harm in always applying this
-$MATRIX_CONFIG{SSL_verify_mode} = SSL_VERIFY_NONE;
-
-my $bridgestate = {};
-my $roomid_by_callid = {};
-    
-my $sessid = lc new Data::UUID->create_str();    
-my $as_token = $CONFIG{"matrix-bot"}->{as_token};
-my $hs_domain = $CONFIG{"matrix-bot"}->{domain};
-
-my $http = Net::Async::HTTP->new();
-$loop->add( $http );
-
-sub create_virtual_user
-{
-    my ($localpart) = @_;
-    my ( $response ) = $http->do_request(
-        method => "POST",
-        uri => URI->new(
-            $CONFIG{"matrix"}->{server}.
-                "/_matrix/client/api/v1/register?".
-                "access_token=$as_token&user_id=$localpart"
-        ),
-        content_type => "application/json",
-        content => <<EOT
-{
-    "type": "m.login.application_service",
-    "user": "$localpart"
-}
-EOT
-    )->get;
-    warn $response->as_string if ($response->code != 200);
-}
-    
-my $http_server =  Net::Async::HTTP::Server->new(
-    on_request => sub {
-        my $self = shift;
-        my ( $req ) = @_;
-
-        my $response;
-        my $path = uri_decode($req->path);
-        warn("request: $path");
-        if ($path =~ m#/users/\@(\+.*)#) {
-            # when queried about virtual users, auto-create them in the HS
-            my $localpart = $1;
-            create_virtual_user($localpart);
-            $response = HTTP::Response->new( 200 );
-            $response->add_content('{}');
-            $response->content_type( "application/json" );
-        }
-        elsif ($path =~ m#/transactions/(.*)#) {
-            my $event = JSON->new->decode($req->body);
-            print Dumper($event);
-
-            my $room_id = $event->{room_id};
-            my %dp = %{$CONFIG{'verto-dialog-params'}};
-            $dp{callID} = $bridgestate->{$room_id}->{callid};
-
-            if ($event->{type} eq 'm.room.membership') {
-                my $membership = $event->{content}->{membership};
-                my $state_key = $event->{state_key};
-                my $room_id = $event->{state_id};
-                
-                if ($membership eq 'invite') {
-                    # autojoin invites
-                    my ( $response ) = $http->do_request(
-                        method => "POST",
-                        uri => URI->new(
-                            $CONFIG{"matrix"}->{server}.
-                                "/_matrix/client/api/v1/rooms/$room_id/join?".
-                                "access_token=$as_token&user_id=$state_key"
-                        ),
-                        content_type => "application/json",
-                        content => "{}",
-                    )->get;
-                    warn $response->as_string if ($response->code != 200);
-                }
-            }
-            elsif ($event->{type} eq 'm.call.invite') {
-                my $room_id = $event->{room_id};
-                $bridgestate->{$room_id}->{matrix_callid} = $event->{content}->{call_id};
-                $bridgestate->{$room_id}->{callid} = lc new Data::UUID->create_str();
-                $bridgestate->{$room_id}->{sessid} = $sessid;                
-                # $bridgestate->{$room_id}->{offer} = $event->{content}->{offer}->{sdp};
-                my $offer = $event->{content}->{offer}->{sdp};
-                # $bridgestate->{$room_id}->{gathered_candidates} = 0;
-                $roomid_by_callid->{ $bridgestate->{$room_id}->{callid} } = $room_id;
-                # no trickle ICE in verto apparently
-
-                my $f = send_verto_json_request("verto.invite", {
-                    "sdp" => $offer,
-                    "dialogParams" => \%dp,
-                    "sessid" => $bridgestate->{$room_id}->{sessid},
-                });
-                $self->adopt_future($f);
-            }
-            # elsif ($event->{type} eq 'm.call.candidates') {
-            #     # XXX: this could fire for both matrix->verto and verto->matrix calls
-            #     # and races as it collects candidates. much better to just turn off
-            #     # candidate gathering in the webclient entirely for now
-            #     
-            #     my $room_id = $event->{room_id};
-            #     # XXX: compare call IDs
-            #     if (!$bridgestate->{$room_id}->{gathered_candidates}) {
-            #         $bridgestate->{$room_id}->{gathered_candidates} = 1;
-            #         my $offer = $bridgestate->{$room_id}->{offer};
-            #         my $candidate_block = "";
-            #         foreach (@{$event->{content}->{candidates}}) {
-            #             $candidate_block .= "a=" . $_->{candidate} . "\r\n";
-            #         }
-            #         # XXX: collate using the right m= line - for now assume audio call
-            #         $offer =~ s/(a=rtcp.*[\r\n]+)/$1$candidate_block/;
-            #     
-            #         my $f = send_verto_json_request("verto.invite", {
-            #             "sdp" => $offer,
-            #             "dialogParams" => \%dp,
-            #             "sessid" => $bridgestate->{$room_id}->{sessid},
-            #         });
-            #         $self->adopt_future($f);
-            #     }
-            #     else {
-            #         # ignore them, as no trickle ICE, although we might as well
-            #         # batch them up
-            #         # foreach (@{$event->{content}->{candidates}}) {
-            #         #     push @{$bridgestate->{$room_id}->{candidates}}, $_;
-            #         # }
-            #     }
-            # }
-            elsif ($event->{type} eq 'm.call.answer') {
-                # grab the answer and relay it to verto as a verto.answer
-                my $room_id = $event->{room_id};
-                
-                my $answer = $event->{content}->{answer}->{sdp};
-                my $f = send_verto_json_request("verto.answer", {
-                    "sdp" => $answer,
-                    "dialogParams" => \%dp,
-                    "sessid" => $bridgestate->{$room_id}->{sessid},
-                });
-                $self->adopt_future($f);
-            }
-            elsif ($event->{type} eq 'm.call.hangup') {
-                my $room_id = $event->{room_id};
-                if ($bridgestate->{$room_id}->{matrix_callid} eq $event->{content}->{call_id}) {
-                    my $f = send_verto_json_request("verto.bye", {
-                        "dialogParams" => \%dp,
-                        "sessid" => $bridgestate->{$room_id}->{sessid},
-                    });
-                    $self->adopt_future($f);
-                }
-                else {
-                    warn "Ignoring unrecognised callid: ".$event->{content}->{call_id};
-                }
-            }
-            else {
-                warn "Unhandled event: $event->{type}";
-            }
-            
-            $response = HTTP::Response->new( 200 );
-            $response->add_content('{}');
-            $response->content_type( "application/json" );            
-        }
-        else {
-            warn "Unhandled path: $path";
-            $response = HTTP::Response->new( 404 );
-        }
-
-        $req->respond( $response );
-    },
-);
-$loop->add( $http_server );
-
-$http_server->listen(
-    addr => { family => "inet", socktype => "stream", port => 8009 },
-    on_listen_error => sub { die "Cannot listen - $_[-1]\n" },
-);
-
-my $bot_verto = Net::Async::WebSocket::Client->new(
-    on_frame => sub {
-          my ( $self, $frame ) = @_;
-          warn "[Verto] receiving $frame";
-          on_verto_json($frame);
-    },
-);
-$loop->add( $bot_verto );
-
-my $verto_connecting = $loop->new_future;
-$bot_verto->connect(
-    %{ $CONFIG{"verto-bot"} },
-    on_connected => sub {
-        warn("[Verto] connected to websocket");
-        if (not $verto_connecting->is_done) {
-            $verto_connecting->done($bot_verto);
-
-            send_verto_json_request("login", {
-                'login' => $CONFIG{'verto-dialog-params'}{'login'},
-                'passwd' => $CONFIG{'verto-config'}{'passwd'},
-                'sessid' => $sessid,
-            });
-        }
-    },
-    on_connect_error => sub { die "Cannot connect to verto - $_[-1]" },
-    on_resolve_error => sub { die "Cannot resolve to verto - $_[-1]" },        
-);
-
-# die Dumper($verto_connecting);
-
-my $as_url = $CONFIG{"matrix-bot"}->{as_url};
-
-Future->needs_all(
-    $http->do_request(
-            method => "POST",
-            uri => URI->new( $CONFIG{"matrix"}->{server}."/_matrix/appservice/v1/register" ),
-            content_type => "application/json",
-            content => <<EOT
-{
-    "as_token": "$as_token",
-    "url": "$as_url",
-    "namespaces": { "users": [ { "regex": "\@\\\\+.*", "exclusive": false } ] }
-}
-EOT
-    )->then( sub{
-        my ($response) = (@_);
-        warn $response->as_string if ($response->code != 200);
-        return Future->done;
-    }),
-    $verto_connecting,
-)->get;
-
-$loop->attach_signal(
-    PIPE => sub { warn "pipe\n" }
-);
-$loop->attach_signal(
-    INT => sub { $loop->stop },
-);
-$loop->attach_signal(
-    TERM => sub { $loop->stop },
-);
-
-eval {
-   $loop->run;
-} or my $e = $@;
-
-die $e if $e;
-
-exit 0;
-
-{    
-    my $json_id;
-    my $requests;
-
-    sub send_verto_json_request
-    {
-        $json_id ||= 1;
-        
-        my ($method, $params) = @_;
-        my $json = {
-            jsonrpc => "2.0",
-            method  => $method,
-            params  => $params,
-            id      => $json_id,
-        };
-        my $text = JSON->new->encode( $json );
-        warn "[Verto] sending $text";
-        $bot_verto->send_frame ( $text );
-        my $request = $loop->new_future;
-        $requests->{$json_id} = $request;
-        $json_id++;
-        return $request;
-    }
-    
-    sub send_verto_json_response
-    {
-        my ($result, $id) = @_;
-        my $json = {
-            jsonrpc => "2.0",
-            result  => $result,
-            id      => $id,
-        };
-        my $text = JSON->new->encode( $json );
-        warn "[Verto] sending $text";
-        $bot_verto->send_frame ( $text );
-    }
-    
-    sub on_verto_json
-    {
-        my $json = JSON->new->decode( $_[0] );
-        if ($json->{method}) {
-            if (($json->{method} eq 'verto.answer' && $json->{params}->{sdp}) ||
-                $json->{method} eq 'verto.media') {
-
-                my $caller = $json->{dialogParams}->{caller_id_number};
-                my $callee = $json->{dialogParams}->{destination_number};
-                my $caller_user = '@+' . $caller . ':' . $hs_domain;
-                my $callee_user = $msisdn_to_matrix->{$callee} || warn "unrecogised callee: $callee";                                
-                my $room_id = $roomid_by_callid->{$json->{params}->{callID}};
-
-                if ($json->{params}->{sdp}) {
-                    $http->do_request(
-                        method => "POST",
-                        uri => URI->new(
-                            $CONFIG{"matrix"}->{server}.
-                                "/_matrix/client/api/v1/send/m.call.answer?".
-                                "access_token=$as_token&user_id=$caller_user"
-                        ),
-                        content_type => "application/json",
-                        content => JSON->new->encode({
-                            call_id => $bridgestate->{$room_id}->{matrix_callid},
-                            version => 0,
-                            answer  => {
-                                sdp => $json->{params}->{sdp},
-                                type => "answer",
-                            },
-                        }),
-                    )->then( sub {
-                        send_verto_json_response( {
-                            method => $json->{method},
-                        }, $json->{id});
-                    })->get;
-                }
-            }
-            elsif ($json->{method} eq 'verto.invite') {
-                my $caller = $json->{dialogParams}->{caller_id_number};
-                my $callee = $json->{dialogParams}->{destination_number};
-                my $caller_user = '@+' . $caller . ':' . $hs_domain;
-                my $callee_user = $msisdn_to_matrix->{$callee} || warn "unrecogised callee: $callee";
-                    
-                my $alias = ($caller lt $callee) ? ($caller.'-'.$callee) : ($callee.'-'.$caller);
-                my $room_id;
-
-                # create a virtual user for the caller if needed.
-                create_virtual_user($caller);
-                
-                # create a room of form #peer-peer and invite the callee
-                $http->do_request(
-                    method => "POST",
-                    uri => URI->new(
-                        $CONFIG{"matrix"}->{server}.
-                            "/_matrix/client/api/v1/createRoom?".
-                            "access_token=$as_token&user_id=$caller_user"
-                    ),
-                    content_type => "application/json",
-                    content => JSON->new->encode({
-                        room_alias_name => $alias,
-                        invite => [ $callee_user ],
-                    }),
-                )->then( sub {
-                    my ( $response ) = @_;
-                    my $resp = JSON->new->decode($response->content);
-                    $room_id = $resp->{room_id};
-                    $roomid_by_callid->{$json->{params}->{callID}} = $room_id;
-                })->get;
-
-                # join it
-                my ($response) = $http->do_request(
-                    method => "POST",
-                    uri => URI->new(
-                        $CONFIG{"matrix"}->{server}.
-                            "/_matrix/client/api/v1/join/$room_id?".
-                            "access_token=$as_token&user_id=$caller_user"
-                    ),
-                    content_type => "application/json",
-                    content => '{}',
-                )->get;
-
-                $bridgestate->{$room_id}->{matrix_callid} = lc new Data::UUID->create_str();
-                $bridgestate->{$room_id}->{callid} = $json->{dialogParams}->{callID};
-                $bridgestate->{$room_id}->{sessid} = $sessid;
-
-                # put the m.call.invite in there
-                $http->do_request(
-                    method => "POST",
-                    uri => URI->new(
-                        $CONFIG{"matrix"}->{server}.
-                            "/_matrix/client/api/v1/send/m.call.invite?".
-                            "access_token=$as_token&user_id=$caller_user"
-                    ),
-                    content_type => "application/json",
-                    content => JSON->new->encode({
-                        call_id => $bridgestate->{$room_id}->{matrix_callid},
-                        version => 0,
-                        answer  => {
-                            sdp => $json->{params}->{sdp},
-                            type => "offer",
-                        },
-                    }),
-                )->then( sub {
-                    # acknowledge the verto
-                    send_verto_json_response( {
-                        method => $json->{method},
-                    }, $json->{id});
-                })->get;
-            }
-            elsif ($json->{method} eq 'verto.bye') {
-                my $caller = $json->{dialogParams}->{caller_id_number};
-                my $callee = $json->{dialogParams}->{destination_number};
-                my $caller_user = '@+' . $caller . ':' . $hs_domain;
-                my $callee_user = $msisdn_to_matrix->{$callee} || warn "unrecogised callee: $callee";                                
-                my $room_id = $roomid_by_callid->{$json->{params}->{callID}};
-                
-                # put the m.call.hangup into the room
-                $http->do_request(
-                    method => "POST",
-                    uri => URI->new(
-                        $CONFIG{"matrix"}->{server}.
-                            "/_matrix/client/api/v1/send/m.call.hangup?".
-                            "access_token=$as_token&user_id=$caller_user"
-                    ),
-                    content_type => "application/json",
-                    content => JSON->new->encode({
-                        call_id => $bridgestate->{$room_id}->{matrix_callid},
-                        version => 0,
-                    }),
-                )->then( sub {
-                    # acknowledge the verto
-                    send_verto_json_response( {
-                        method => $json->{method},
-                    }, $json->{id});
-                })->get;
-            }
-            else {
-                warn ("[Verto] unhandled method: " . $json->{method});
-                send_verto_json_response( {
-                    method => $json->{method},
-                }, $json->{id});
-            }
-        }
-        elsif ($json->{result}) {
-            $requests->{$json->{id}}->done($json->{result});
-        }
-        elsif ($json->{error}) {
-            $requests->{$json->{id}}->fail($json->{error}->{message}, $json->{error});
-        }
-    }
-}
-
--- a/contrib/vertobot/config.yaml
+++ b/contrib/vertobot/config.yaml
@@ -7,9 +7,6 @@ matrix:
 matrix-bot:
  user_id: '@vertobot:matrix.org'
  password: ''
-  domain: 'matrix.org"
-  as_url: 'http://localhost:8009'
-  as_token: 'vertobot123'

 verto-bot:
  host: webrtc.freeswitch.org
--- a/demo/start.sh
+++ b/demo/start.sh
@@ -16,31 +16,28 @@ if [ $# -eq 1 ]; then
    fi
 fi

-export PYTHONPATH=$(readlink -f $(pwd))
-
-
-echo $PYTHONPATH
-
 for port in 8080 8081 8082; do
    echo "Starting server on port $port... "

    https_port=$((port + 400))
-    mkdir -p demo/$port
-    pushd demo/$port

-    #rm $DIR/etc/$port.config
    python -m synapse.app.homeserver \
        --generate-config \
-        --enable_registration \
+        --config-path "demo/etc/$port.config" \
+        -p "$https_port" \
+        --unsecure-port "$port" \
        -H "localhost:$https_port" \
-        --config-path "$DIR/etc/$port.config" \
+        -f "$DIR/$port.log" \
+        -d "$DIR/$port.db" \
+        -D --pid-file "$DIR/$port.pid" \
+        --manhole $((port + 1000)) \
+        --tls-dh-params-path "demo/demo.tls.dh" \
+		$PARAMS $SYNAPSE_PARAMS

    python -m synapse.app.homeserver \
-        --config-path "$DIR/etc/$port.config" \
-        -D \
+        --config-path "demo/etc/$port.config" \
        -vv \

-    popd
 done

 cd "$CWD"
--- a/docs/CAPTCHA_SETUP
+++ b/docs/CAPTCHA_SETUP
@@ -1,31 +0,0 @@
-Captcha can be enabled for this home server. This file explains how to do that.
-The captcha mechanism used is Google's ReCaptcha. This requires API keys from Google.
-
-Getting keys
------------
-Requires a public/private key pair from:
-
-https://developers.google.com/recaptcha/
-
-
-Setting ReCaptcha Keys
----------------------
-The keys are a config option on the home server config. If they are not 
-visible, you can generate them via --generate-config. Set the following value:
-
-  recaptcha_public_key: YOUR_PUBLIC_KEY
-  recaptcha_private_key: YOUR_PRIVATE_KEY
-  
-In addition, you MUST enable captchas via:
-
-  enable_registration_captcha: true
-
-Configuring IP used for auth
----------------------------
-The ReCaptcha API requires that the IP address of the user who solved the
-captcha is sent. If the client is connecting through a proxy or load balancer,
-it may be required to use the X-Forwarded-For (XFF) header instead of the origin
-IP address. This can be configured as an option on the home server like so:
-
-  captcha_ip_origin_is_x_forwarded: true
-
--- a/docs/application_services.rst
+++ b/docs/application_services.rst
@@ -1,36 +0,0 @@
-Registering an Application Service
-==================================
-
-The registration of new application services depends on the homeserver used. 
-In synapse, you need to create a new configuration file for your AS and add it
-to the list specified under the ``app_service_config_files`` config
-option in your synapse config.
-
-For example:
-
-.. code-block:: yaml
-
-  app_service_config_files:
-  - /home/matrix/.synapse/<your-AS>.yaml
-
-
-The format of the AS configuration file is as follows:
-
-..  code-block:: yaml
-
-    url: <base url of AS>
-    as_token: <token AS will add to requests to HS>
-    hs_token: <token HS will add to requests to AS>
-    sender_localpart: <localpart of AS user>
-    namespaces:
-      users:  # List of users we're interested in
-        - exclusive: <bool>
-          regex: <regex>
-        - ...
-      aliases: []  # List of aliases we're interested in
-      rooms: [] # List of room ids we're interested in
-
-See the spec_ for further details on how application services work.
-
-.. _spec: https://github.com/matrix-org/matrix-doc/blob/master/specification/25_application_service_api.rst#application-service-api
-
--- a/docs/metrics-howto.rst
+++ b/docs/metrics-howto.rst
@@ -1,50 +0,0 @@
-How to monitor Synapse metrics using Prometheus
-===============================================
-
-1: Install prometheus:
-  Follow instructions at http://prometheus.io/docs/introduction/install/
-
-2: Enable synapse metrics:
-  Simply setting a (local) port number will enable it. Pick a port.
-  prometheus itself defaults to 9090, so starting just above that for
-  locally monitored services seems reasonable. E.g. 9092:
-
-  Add to homeserver.yaml
-
-    metrics_port: 9092
-
-  Restart synapse
-
-3: Check out synapse-prometheus-config
-  https://github.com/matrix-org/synapse-prometheus-config
-
-4: Add ``synapse.html`` and ``synapse.rules``
-  The ``.html`` file needs to appear in prometheus's ``consoles`` directory,
-  and the ``.rules`` file needs to be invoked somewhere in the main config
-  file. A symlink to each from the git checkout into the prometheus directory
-  might be easiest to ensure ``git pull`` keeps it updated.
-
-5: Add a prometheus target for synapse
-  This is easiest if prometheus runs on the same machine as synapse, as it can
-  then just use localhost::
-
-    global: {
-      rule_file: "synapse.rules"
-    }
-
-    job: {
-      name: "synapse"
-
-      target_group: {
-        target: "http://localhost:9092/"
-      }
-    }
-
-6: Start prometheus::
-
-   ./prometheus -config.file=prometheus.conf
-
-7: Wait a few seconds for it to start and perform the first scrape,
-   then visit the console:
-
-    http://server-where-prometheus-runs:9090/consoles/synapse.html
--- a/docs/postgres.rst
+++ b/docs/postgres.rst
@@ -1,110 +0,0 @@
-Using Postgres
--------------
-
-Set up database
-===============
-
-The PostgreSQL database used *must* have the correct encoding set, otherwise
-would not be able to store UTF8 strings. To create a database with the correct
-encoding use, e.g.::
-
- CREATE DATABASE synapse
-  ENCODING 'UTF8'
-  LC_COLLATE='C'
-  LC_CTYPE='C'
-  template=template0
-  OWNER synapse_user;
-
-This would create an appropriate database named ``synapse`` owned by the
-``synapse_user`` user (which must already exist).
-
-Set up client
-=============
-
-Postgres support depends on the postgres python connector ``psycopg2``. In the
-virtual env::
-
-    sudo apt-get install libpq-dev
-    pip install psycopg2
-
-
-Synapse config
-==============
-
-When you are ready to start using PostgreSQL, add the following line to your
-config file::
-
-    database:
-        name: psycopg2
-        args:
-            user: <user>
-            password: <pass>
-            database: <db>
-            host: <host>
-            cp_min: 5
-            cp_max: 10
-
-All key, values in ``args`` are passed to the ``psycopg2.connect(..)``
-function, except keys beginning with ``cp_``, which are consumed by the twisted
-adbapi connection pool.
-
-
-Porting from SQLite
-===================
-
-Overview
-~~~~~~~~
-
-The script ``port_from_sqlite_to_postgres.py`` allows porting an existing
-synapse server backed by SQLite to using PostgreSQL. This is done in as a two
-phase process:
-
-1. Copy the existing SQLite database to a separate location (while the server
-   is down) and running the port script against that offline database.
-2. Shut down the server. Rerun the port script to port any data that has come
-   in since taking the first snapshot. Restart server against the PostgreSQL
-   database.
-
-The port script is designed to be run repeatedly against newer snapshots of the
-SQLite database file. This makes it safe to repeat step 1 if there was a delay
-between taking the previous snapshot and being ready to do step 2.
-
-It is safe to at any time kill the port script and restart it.
-
-Using the port script
-~~~~~~~~~~~~~~~~~~~~~
-
-Firstly, shut down the currently running synapse server and copy its database
-file (typically ``homeserver.db``) to another location. Once the copy is
-complete, restart synapse.  For instance::
-
-    ./synctl stop
-    cp homeserver.db homeserver.db.snapshot
-    ./synctl start
-
-Assuming your new config file (as described in the section *Synapse config*)
-is named ``homeserver-postgres.yaml`` and the SQLite snapshot is at
-``homeserver.db.snapshot`` then simply run::
-
-    python scripts/port_from_sqlite_to_postgres.py \
-        --sqlite-database homeserver.db.snapshot \
-        --postgres-config homeserver-postgres.yaml
-
-The flag ``--curses`` displays a coloured curses progress UI.
-
-If the script took a long time to complete, or time has otherwise passed since
-the original snapshot was taken, repeat the previous steps with a newer
-snapshot.
-
-To complete the conversion shut down the synapse server and run the port
-script one last time, e.g. if the SQLite database is at  ``homeserver.db``
-run::
-
-    python scripts/port_from_sqlite_to_postgres.py \
-        --sqlite-database homeserver.db \
-        --postgres-config database_config.yaml
-
-Once that has completed, change the synapse config to point at the PostgreSQL
-database configuration file using the ``database_config`` parameter (see
-`Synapse Config`_) and restart synapse. Synapse should now be running against
-PostgreSQL.
--- a/docs/turn-howto.rst
+++ b/docs/turn-howto.rst
@@ -81,7 +81,7 @@ Your home server configuration file needs the following extra keys:
 As an example, here is the relevant section of the config file for
 matrix.org::

-    turn_uris: [ "turn:turn.matrix.org:3478?transport=udp", "turn:turn.matrix.org:3478?transport=tcp" ]
+    turn_uris: turn:turn.matrix.org:3478?transport=udp,turn:turn.matrix.org:3478?transport=tcp
    turn_shared_secret: n0t4ctuAllymatr1Xd0TorgSshar3d5ecret4obvIousreAsons
    turn_user_lifetime: 86400000

--- a/scripts-dev/check_auth.py
+++ b/scripts-dev/check_auth.py
@@ -1,65 +0,0 @@
-from synapse.events import FrozenEvent
-from synapse.api.auth import Auth
-
-from mock import Mock
-
-import argparse
-import itertools
-import json
-import sys
-
-
-def check_auth(auth, auth_chain, events):
-    auth_chain.sort(key=lambda e: e.depth)
-
-    auth_map = {
-        e.event_id: e
-        for e in auth_chain
-    }
-
-    create_events = {}
-    for e in auth_chain:
-        if e.type == "m.room.create":
-            create_events[e.room_id] = e
-
-    for e in itertools.chain(auth_chain, events):
-        auth_events_list = [auth_map[i] for i, _ in e.auth_events]
-
-        auth_events = {
-            (e.type, e.state_key): e
-            for e in auth_events_list
-        }
-
-        auth_events[("m.room.create", "")] = create_events[e.room_id]
-
-        try:
-            auth.check(e, auth_events=auth_events)
-        except Exception as ex:
-            print "Failed:", e.event_id, e.type, e.state_key
-            print "Auth_events:", auth_events
-            print ex
-            print json.dumps(e.get_dict(), sort_keys=True, indent=4)
-            # raise
-        print "Success:", e.event_id, e.type, e.state_key
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        'json',
-        nargs='?',
-        type=argparse.FileType('r'),
-        default=sys.stdin,
-    )
-
-    args = parser.parse_args()
-
-    js = json.load(args.json)
-
-
-    auth = Auth(Mock())
-    check_auth(
-        auth,
-        [FrozenEvent(d) for d in js["auth_chain"]],
-        [FrozenEvent(d) for d in js["pdus"]],
-    )
--- a/scripts-dev/convert_server_keys.py
+++ b/scripts-dev/convert_server_keys.py
@@ -1,116 +0,0 @@
-import psycopg2
-import yaml
-import sys
-import json
-import time
-import hashlib
-from syutil.base64util import encode_base64
-from syutil.crypto.signing_key import read_signing_keys
-from syutil.crypto.jsonsign import sign_json
-from syutil.jsonutil import encode_canonical_json
-
-
-def select_v1_keys(connection):
-    cursor = connection.cursor()
-    cursor.execute("SELECT server_name, key_id, verify_key FROM server_signature_keys")
-    rows = cursor.fetchall()
-    cursor.close()
-    results = {}
-    for server_name, key_id, verify_key in rows:
-        results.setdefault(server_name, {})[key_id] = encode_base64(verify_key)
-    return results
-
-
-def select_v1_certs(connection):
-    cursor = connection.cursor()
-    cursor.execute("SELECT server_name, tls_certificate FROM server_tls_certificates")
-    rows = cursor.fetchall()
-    cursor.close()
-    results = {}
-    for server_name, tls_certificate in rows:
-        results[server_name] = tls_certificate
-    return results
-
-
-def select_v2_json(connection):
-    cursor = connection.cursor()
-    cursor.execute("SELECT server_name, key_id, key_json FROM server_keys_json")
-    rows = cursor.fetchall()
-    cursor.close()
-    results = {}
-    for server_name, key_id, key_json in rows:
-        results.setdefault(server_name, {})[key_id] = json.loads(str(key_json).decode("utf-8"))
-    return results
-
-
-def convert_v1_to_v2(server_name, valid_until, keys, certificate):
-    return {
-        "old_verify_keys": {},
-        "server_name": server_name,
-        "verify_keys": {
-            key_id: {"key": key}
-            for key_id, key in keys.items()
-        },
-        "valid_until_ts": valid_until,
-        "tls_fingerprints": [fingerprint(certificate)],
-    }
-
-
-def fingerprint(certificate):
-    finger = hashlib.sha256(certificate)
-    return {"sha256": encode_base64(finger.digest())}
-
-
-def rows_v2(server, json):
-    valid_until = json["valid_until_ts"]
-    key_json = encode_canonical_json(json)
-    for key_id in json["verify_keys"]:
-        yield (server, key_id, "-", valid_until, valid_until, buffer(key_json))
-
-
-def main():
-    config = yaml.load(open(sys.argv[1]))
-    valid_until = int(time.time() / (3600 * 24)) * 1000 * 3600 * 24
-
-    server_name = config["server_name"]
-    signing_key = read_signing_keys(open(config["signing_key_path"]))[0]
-
-    database = config["database"]
-    assert database["name"] == "psycopg2", "Can only convert for postgresql"
-    args = database["args"]
-    args.pop("cp_max")
-    args.pop("cp_min")
-    connection = psycopg2.connect(**args)
-    keys = select_v1_keys(connection)
-    certificates = select_v1_certs(connection)
-    json = select_v2_json(connection)
-
-    result = {}
-    for server in keys:
-        if not server in json:
-            v2_json = convert_v1_to_v2(
-                server, valid_until, keys[server], certificates[server]
-            )
-            v2_json = sign_json(v2_json, server_name, signing_key)
-            result[server] = v2_json
-
-    yaml.safe_dump(result, sys.stdout, default_flow_style=False)
-
-    rows = list(
-        row for server, json in result.items()
-        for row in rows_v2(server, json)
-    )
-
-    cursor = connection.cursor()
-    cursor.executemany(
-        "INSERT INTO server_keys_json ("
-        " server_name, key_id, from_server,"
-        " ts_added_ms, ts_valid_until_ms, key_json"
-        ") VALUES (%s, %s, %s, %s, %s, %s)",
-        rows
-    )
-    connection.commit()
-
-
-if __name__ == '__main__':
-    main()
--- a/scripts-dev/make_identicons.pl
+++ b/scripts-dev/make_identicons.pl
@@ -1,39 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-use warnings;
-
-use DBI;
-use DBD::SQLite;
-use JSON;
-use Getopt::Long;
-
-my $db; # = "homeserver.db";
-my $server = "http://localhost:8008";
-my $size = 320;
-
-GetOptions("db|d=s",     \$db,
-           "server|s=s", \$server,
-           "width|w=i",  \$size) or usage();
-
-usage() unless $db;
-
-my $dbh = DBI->connect("dbi:SQLite:dbname=$db","","") || die $DBI::errstr;
-
-my $res = $dbh->selectall_arrayref("select token, name from access_tokens, users where access_tokens.user_id = users.id group by user_id") || die $DBI::errstr;
-
-foreach (@$res) {
-    my ($token, $mxid) = ($_->[0], $_->[1]);
-    my ($user_id) = ($mxid =~ m/@(.*):/);
-    my ($url) = $dbh->selectrow_array("select avatar_url from profiles where user_id=?", undef, $user_id);
-    if (!$url || $url =~ /#auto$/) {
-        `curl -s -o tmp.png "$server/_matrix/media/v1/identicon?name=${mxid}&width=$size&height=$size"`;
-        my $json = `curl -s -X POST -H "Content-Type: image/png" -T "tmp.png" $server/_matrix/media/v1/upload?access_token=$token`;
-        my $content_uri = from_json($json)->{content_uri};
-        `curl -X PUT -H "Content-Type: application/json" --data '{ "avatar_url": "${content_uri}#auto"}' $server/_matrix/client/api/v1/profile/${mxid}/avatar_url?access_token=$token`;
-    }
-}
-
-sub usage {
-    die "usage: ./make-identicons.pl\n\t-d database [e.g. homeserver.db]\n\t-s homeserver (default: http://localhost:8008)\n\t-w identicon size in pixels (default 320)";
-}
--- a/scripts-dev/check_event_hash.py
+++ b/scripts-dev/check_event_hash.py
--- a/scripts-dev/check_signature.py
+++ b/scripts-dev/check_signature.py
--- a/scripts-dev/copyrighter-sql.pl
+++ b/scripts-dev/copyrighter-sql.pl
--- a/scripts-dev/copyrighter.pl
+++ b/scripts-dev/copyrighter.pl
--- a/scripts-dev/database-save.sh
+++ b/scripts-dev/database-save.sh
--- a/scripts-dev/federation_client.py
+++ b/scripts-dev/federation_client.py
@@ -97,11 +97,8 @@ def lookup(destination, path):
    if ":" in destination:
        return "https://%s%s" % (destination, path)
    else:
-        try:
-            srv = srvlookup.lookup("matrix", "tcp", destination)[0]
-            return "https://%s:%d%s" % (srv.host, srv.port, path)
-        except:
-            return "https://%s:%d%s" % (destination, 8448, path)
+        srv = srvlookup.lookup("matrix", "tcp", destination)[0]
+        return "https://%s:%d%s" % (srv.host, srv.port, path)

 def get_json(origin_name, origin_key, destination, path):
    request_json = {
--- a/scripts-dev/hash_history.py
+++ b/scripts-dev/hash_history.py
--- a/scripts-dev/nuke-room-from-db.sh
+++ b/scripts-dev/nuke-room-from-db.sh
--- a/scripts/port_from_sqlite_to_postgres.py
+++ b/scripts/port_from_sqlite_to_postgres.py
@@ -1,760 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-
-from twisted.internet import defer, reactor
-from twisted.enterprise import adbapi
-
-from synapse.storage._base import LoggingTransaction, SQLBaseStore
-from synapse.storage.engines import create_engine
-
-import argparse
-import curses
-import logging
-import sys
-import time
-import traceback
-import yaml
-
-
-logger = logging.getLogger("port_from_sqlite_to_postgres")
-
-
-BOOLEAN_COLUMNS = {
-    "events": ["processed", "outlier"],
-    "rooms": ["is_public"],
-    "event_edges": ["is_state"],
-    "presence_list": ["accepted"],
-}
-
-
-APPEND_ONLY_TABLES = [
-    "event_content_hashes",
-    "event_reference_hashes",
-    "event_signatures",
-    "event_edge_hashes",
-    "events",
-    "event_json",
-    "state_events",
-    "room_memberships",
-    "feedback",
-    "topics",
-    "room_names",
-    "rooms",
-    "local_media_repository",
-    "local_media_repository_thumbnails",
-    "remote_media_cache",
-    "remote_media_cache_thumbnails",
-    "redactions",
-    "event_edges",
-    "event_auth",
-    "received_transactions",
-    "sent_transactions",
-    "transaction_id_to_pdu",
-    "users",
-    "state_groups",
-    "state_groups_state",
-    "event_to_state_groups",
-    "rejections",
-]
-
-
-end_error_exec_info = None
-
-
-class Store(object):
-    """This object is used to pull out some of the convenience API from the
-    Storage layer.
-
-    *All* database interactions should go through this object.
-    """
-    def __init__(self, db_pool, engine):
-        self.db_pool = db_pool
-        self.database_engine = engine
-
-    _simple_insert_txn = SQLBaseStore.__dict__["_simple_insert_txn"]
-    _simple_insert = SQLBaseStore.__dict__["_simple_insert"]
-
-    _simple_select_onecol_txn = SQLBaseStore.__dict__["_simple_select_onecol_txn"]
-    _simple_select_onecol = SQLBaseStore.__dict__["_simple_select_onecol"]
-    _simple_select_one_onecol = SQLBaseStore.__dict__["_simple_select_one_onecol"]
-    _simple_select_one_onecol_txn = SQLBaseStore.__dict__["_simple_select_one_onecol_txn"]
-
-    _simple_update_one = SQLBaseStore.__dict__["_simple_update_one"]
-    _simple_update_one_txn = SQLBaseStore.__dict__["_simple_update_one_txn"]
-
-    _execute_and_decode = SQLBaseStore.__dict__["_execute_and_decode"]
-
-    def runInteraction(self, desc, func, *args, **kwargs):
-        def r(conn):
-            try:
-                i = 0
-                N = 5
-                while True:
-                    try:
-                        txn = conn.cursor()
-                        return func(
-                            LoggingTransaction(txn, desc, self.database_engine, []),
-                            *args, **kwargs
-                        )
-                    except self.database_engine.module.DatabaseError as e:
-                        if self.database_engine.is_deadlock(e):
-                            logger.warn("[TXN DEADLOCK] {%s} %d/%d", desc, i, N)
-                            if i < N:
-                                i += 1
-                                conn.rollback()
-                                continue
-                        raise
-            except Exception as e:
-                logger.debug("[TXN FAIL] {%s} %s", desc, e)
-                raise
-
-        return self.db_pool.runWithConnection(r)
-
-    def execute(self, f, *args, **kwargs):
-        return self.runInteraction(f.__name__, f, *args, **kwargs)
-
-    def execute_sql(self, sql, *args):
-        def r(txn):
-            txn.execute(sql, args)
-            return txn.fetchall()
-        return self.runInteraction("execute_sql", r)
-
-    def insert_many_txn(self, txn, table, headers, rows):
-        sql = "INSERT INTO %s (%s) VALUES (%s)" % (
-            table,
-            ", ".join(k for k in headers),
-            ", ".join("%s" for _ in headers)
-        )
-
-        try:
-            txn.executemany(sql, rows)
-        except:
-            logger.exception(
-                "Failed to insert: %s",
-                table,
-            )
-            raise
-
-
-class Porter(object):
-    def __init__(self, **kwargs):
-        self.__dict__.update(kwargs)
-
-    @defer.inlineCallbacks
-    def setup_table(self, table):
-        if table in APPEND_ONLY_TABLES:
-            # It's safe to just carry on inserting.
-            next_chunk = yield self.postgres_store._simple_select_one_onecol(
-                table="port_from_sqlite3",
-                keyvalues={"table_name": table},
-                retcol="rowid",
-                allow_none=True,
-            )
-
-            total_to_port = None
-            if next_chunk is None:
-                if table == "sent_transactions":
-                    next_chunk, already_ported, total_to_port = (
-                        yield self._setup_sent_transactions()
-                    )
-                else:
-                    yield self.postgres_store._simple_insert(
-                        table="port_from_sqlite3",
-                        values={"table_name": table, "rowid": 1}
-                    )
-
-                    next_chunk = 1
-                    already_ported = 0
-
-            if total_to_port is None:
-                already_ported, total_to_port = yield self._get_total_count_to_port(
-                    table, next_chunk
-                )
-        else:
-            def delete_all(txn):
-                txn.execute(
-                    "DELETE FROM port_from_sqlite3 WHERE table_name = %s",
-                    (table,)
-                )
-                txn.execute("TRUNCATE %s CASCADE" % (table,))
-
-            yield self.postgres_store.execute(delete_all)
-
-            yield self.postgres_store._simple_insert(
-                table="port_from_sqlite3",
-                values={"table_name": table, "rowid": 0}
-            )
-
-            next_chunk = 1
-
-            already_ported, total_to_port = yield self._get_total_count_to_port(
-                table, next_chunk
-            )
-
-        defer.returnValue((table, already_ported, total_to_port, next_chunk))
-
-    @defer.inlineCallbacks
-    def handle_table(self, table, postgres_size, table_size, next_chunk):
-        if not table_size:
-            return
-
-        self.progress.add_table(table, postgres_size, table_size)
-
-        select = (
-            "SELECT rowid, * FROM %s WHERE rowid >= ? ORDER BY rowid LIMIT ?"
-            % (table,)
-        )
-
-        while True:
-            def r(txn):
-                txn.execute(select, (next_chunk, self.batch_size,))
-                rows = txn.fetchall()
-                headers = [column[0] for column in txn.description]
-
-                return headers, rows
-
-            headers, rows = yield self.sqlite_store.runInteraction("select", r)
-
-            if rows:
-                next_chunk = rows[-1][0] + 1
-
-                self._convert_rows(table, headers, rows)
-
-                def insert(txn):
-                    self.postgres_store.insert_many_txn(
-                        txn, table, headers[1:], rows
-                    )
-
-                    self.postgres_store._simple_update_one_txn(
-                        txn,
-                        table="port_from_sqlite3",
-                        keyvalues={"table_name": table},
-                        updatevalues={"rowid": next_chunk},
-                    )
-
-                yield self.postgres_store.execute(insert)
-
-                postgres_size += len(rows)
-
-                self.progress.update(table, postgres_size)
-            else:
-                return
-
-    def setup_db(self, db_config, database_engine):
-        db_conn = database_engine.module.connect(
-            **{
-                k: v for k, v in db_config.get("args", {}).items()
-                if not k.startswith("cp_")
-            }
-        )
-
-        database_engine.prepare_database(db_conn)
-
-        db_conn.commit()
-
-    @defer.inlineCallbacks
-    def run(self):
-        try:
-            sqlite_db_pool = adbapi.ConnectionPool(
-                self.sqlite_config["name"],
-                **self.sqlite_config["args"]
-            )
-
-            postgres_db_pool = adbapi.ConnectionPool(
-                self.postgres_config["name"],
-                **self.postgres_config["args"]
-            )
-
-            sqlite_engine = create_engine("sqlite3")
-            postgres_engine = create_engine("psycopg2")
-
-            self.sqlite_store = Store(sqlite_db_pool, sqlite_engine)
-            self.postgres_store = Store(postgres_db_pool, postgres_engine)
-
-            yield self.postgres_store.execute(
-                postgres_engine.check_database
-            )
-
-            # Step 1. Set up databases.
-            self.progress.set_state("Preparing SQLite3")
-            self.setup_db(sqlite_config, sqlite_engine)
-
-            self.progress.set_state("Preparing PostgreSQL")
-            self.setup_db(postgres_config, postgres_engine)
-
-            # Step 2. Get tables.
-            self.progress.set_state("Fetching tables")
-            sqlite_tables = yield self.sqlite_store._simple_select_onecol(
-                table="sqlite_master",
-                keyvalues={
-                    "type": "table",
-                },
-                retcol="name",
-            )
-
-            postgres_tables = yield self.postgres_store._simple_select_onecol(
-                table="information_schema.tables",
-                keyvalues={
-                    "table_schema": "public",
-                },
-                retcol="distinct table_name",
-            )
-
-            tables = set(sqlite_tables) & set(postgres_tables)
-
-            self.progress.set_state("Creating tables")
-
-            logger.info("Found %d tables", len(tables))
-
-            def create_port_table(txn):
-                txn.execute(
-                    "CREATE TABLE port_from_sqlite3 ("
-                    " table_name varchar(100) NOT NULL UNIQUE,"
-                    " rowid bigint NOT NULL"
-                    ")"
-                )
-
-            try:
-                yield self.postgres_store.runInteraction(
-                    "create_port_table", create_port_table
-                )
-            except Exception as e:
-                logger.info("Failed to create port table: %s", e)
-
-            self.progress.set_state("Setting up")
-
-            # Set up tables.
-            setup_res = yield defer.gatherResults(
-                [
-                    self.setup_table(table)
-                    for table in tables
-                    if table not in ["schema_version", "applied_schema_deltas"]
-                    and not table.startswith("sqlite_")
-                ],
-                consumeErrors=True,
-            )
-
-            # Process tables.
-            yield defer.gatherResults(
-                [
-                    self.handle_table(*res)
-                    for res in setup_res
-                ],
-                consumeErrors=True,
-            )
-
-            self.progress.done()
-        except:
-            global end_error_exec_info
-            end_error_exec_info = sys.exc_info()
-            logger.exception("")
-        finally:
-            reactor.stop()
-
-    def _convert_rows(self, table, headers, rows):
-        bool_col_names = BOOLEAN_COLUMNS.get(table, [])
-
-        bool_cols = [
-            i for i, h in enumerate(headers) if h in bool_col_names
-        ]
-
-        def conv(j, col):
-            if j in bool_cols:
-                return bool(col)
-            return col
-
-        for i, row in enumerate(rows):
-            rows[i] = tuple(
-                conv(j, col)
-                for j, col in enumerate(row)
-                if j > 0
-            )
-
-    @defer.inlineCallbacks
-    def _setup_sent_transactions(self):
-        # Only save things from the last day
-        yesterday = int(time.time()*1000) - 86400000
-
-        # And save the max transaction id from each destination
-        select = (
-            "SELECT rowid, * FROM sent_transactions WHERE rowid IN ("
-            "SELECT max(rowid) FROM sent_transactions"
-            " GROUP BY destination"
-            ")"
-        )
-
-        def r(txn):
-            txn.execute(select)
-            rows = txn.fetchall()
-            headers = [column[0] for column in txn.description]
-
-            ts_ind = headers.index('ts')
-
-            return headers, [r for r in rows if r[ts_ind] < yesterday]
-
-        headers, rows = yield self.sqlite_store.runInteraction(
-            "select", r,
-        )
-
-        self._convert_rows("sent_transactions", headers, rows)
-
-        inserted_rows = len(rows)
-        max_inserted_rowid = max(r[0] for r in rows)
-
-        def insert(txn):
-            self.postgres_store.insert_many_txn(
-                txn, "sent_transactions", headers[1:], rows
-            )
-
-        yield self.postgres_store.execute(insert)
-
-        def get_start_id(txn):
-            txn.execute(
-                "SELECT rowid FROM sent_transactions WHERE ts >= ?"
-                " ORDER BY rowid ASC LIMIT 1",
-                (yesterday,)
-            )
-
-            rows = txn.fetchall()
-            if rows:
-                return rows[0][0]
-            else:
-                return 1
-
-        next_chunk = yield self.sqlite_store.execute(get_start_id)
-        next_chunk = max(max_inserted_rowid + 1, next_chunk)
-
-        yield self.postgres_store._simple_insert(
-            table="port_from_sqlite3",
-            values={"table_name": "sent_transactions", "rowid": next_chunk}
-        )
-
-        def get_sent_table_size(txn):
-            txn.execute(
-                "SELECT count(*) FROM sent_transactions"
-                " WHERE ts >= ?",
-                (yesterday,)
-            )
-            size, = txn.fetchone()
-            return int(size)
-
-        remaining_count = yield self.sqlite_store.execute(
-            get_sent_table_size
-        )
-
-        total_count = remaining_count + inserted_rows
-
-        defer.returnValue((next_chunk, inserted_rows, total_count))
-
-    @defer.inlineCallbacks
-    def _get_remaining_count_to_port(self, table, next_chunk):
-        rows = yield self.sqlite_store.execute_sql(
-            "SELECT count(*) FROM %s WHERE rowid >= ?" % (table,),
-            next_chunk,
-        )
-
-        defer.returnValue(rows[0][0])
-
-    @defer.inlineCallbacks
-    def _get_already_ported_count(self, table):
-        rows = yield self.postgres_store.execute_sql(
-            "SELECT count(*) FROM %s" % (table,),
-        )
-
-        defer.returnValue(rows[0][0])
-
-    @defer.inlineCallbacks
-    def _get_total_count_to_port(self, table, next_chunk):
-        remaining, done = yield defer.gatherResults(
-            [
-                self._get_remaining_count_to_port(table, next_chunk),
-                self._get_already_ported_count(table),
-            ],
-            consumeErrors=True,
-        )
-
-        remaining = int(remaining) if remaining else 0
-        done = int(done) if done else 0
-
-        defer.returnValue((done, remaining + done))
-
-
-##############################################
-###### The following is simply UI stuff ######
-##############################################
-
-
-class Progress(object):
-    """Used to report progress of the port
-    """
-    def __init__(self):
-        self.tables = {}
-
-        self.start_time = int(time.time())
-
-    def add_table(self, table, cur, size):
-        self.tables[table] = {
-            "start": cur,
-            "num_done": cur,
-            "total": size,
-            "perc": int(cur * 100 / size),
-        }
-
-    def update(self, table, num_done):
-        data = self.tables[table]
-        data["num_done"] = num_done
-        data["perc"] = int(num_done * 100 / data["total"])
-
-    def done(self):
-        pass
-
-
-class CursesProgress(Progress):
-    """Reports progress to a curses window
-    """
-    def __init__(self, stdscr):
-        self.stdscr = stdscr
-
-        curses.use_default_colors()
-        curses.curs_set(0)
-
-        curses.init_pair(1, curses.COLOR_RED, -1)
-        curses.init_pair(2, curses.COLOR_GREEN, -1)
-
-        self.last_update = 0
-
-        self.finished = False
-
-        self.total_processed = 0
-        self.total_remaining = 0
-
-        super(CursesProgress, self).__init__()
-
-    def update(self, table, num_done):
-        super(CursesProgress, self).update(table, num_done)
-
-        self.total_processed = 0
-        self.total_remaining = 0
-        for table, data in self.tables.items():
-            self.total_processed += data["num_done"] - data["start"]
-            self.total_remaining += data["total"] - data["num_done"]
-
-        self.render()
-
-    def render(self, force=False):
-        now = time.time()
-
-        if not force and now - self.last_update < 0.2:
-            # reactor.callLater(1, self.render)
-            return
-
-        self.stdscr.clear()
-
-        rows, cols = self.stdscr.getmaxyx()
-
-        duration = int(now) - int(self.start_time)
-
-        minutes, seconds = divmod(duration, 60)
-        duration_str = '%02dm %02ds' % (minutes, seconds,)
-
-        if self.finished:
-            status = "Time spent: %s (Done!)" % (duration_str,)
-        else:
-
-            if self.total_processed > 0:
-                left = float(self.total_remaining) / self.total_processed
-
-                est_remaining = (int(now) - self.start_time) * left
-                est_remaining_str = '%02dm %02ds remaining' % divmod(est_remaining, 60)
-            else:
-                est_remaining_str = "Unknown"
-            status = (
-                "Time spent: %s (est. remaining: %s)"
-                % (duration_str, est_remaining_str,)
-            )
-
-        self.stdscr.addstr(
-            0, 0,
-            status,
-            curses.A_BOLD,
-        )
-
-        max_len = max([len(t) for t in self.tables.keys()])
-
-        left_margin = 5
-        middle_space = 1
-
-        items = self.tables.items()
-        items.sort(
-            key=lambda i: (i[1]["perc"], i[0]),
-        )
-
-        for i, (table, data) in enumerate(items):
-            if i + 2 >= rows:
-                break
-
-            perc = data["perc"]
-
-            color = curses.color_pair(2) if perc == 100 else curses.color_pair(1)
-
-            self.stdscr.addstr(
-                i+2, left_margin + max_len - len(table),
-                table,
-                curses.A_BOLD | color,
-            )
-
-            size = 20
-
-            progress = "[%s%s]" % (
-                "#" * int(perc*size/100),
-                " " * (size - int(perc*size/100)),
-            )
-
-            self.stdscr.addstr(
-                i+2, left_margin + max_len + middle_space,
-                "%s %3d%% (%d/%d)" % (progress, perc, data["num_done"], data["total"]),
-            )
-
-        if self.finished:
-            self.stdscr.addstr(
-                rows-1, 0,
-                "Press any key to exit...",
-            )
-
-        self.stdscr.refresh()
-        self.last_update = time.time()
-
-    def done(self):
-        self.finished = True
-        self.render(True)
-        self.stdscr.getch()
-
-    def set_state(self, state):
-        self.stdscr.clear()
-        self.stdscr.addstr(
-            0, 0,
-            state + "...",
-            curses.A_BOLD,
-        )
-        self.stdscr.refresh()
-
-
-class TerminalProgress(Progress):
-    """Just prints progress to the terminal
-    """
-    def update(self, table, num_done):
-        super(TerminalProgress, self).update(table, num_done)
-
-        data = self.tables[table]
-
-        print "%s: %d%% (%d/%d)" % (
-            table, data["perc"],
-            data["num_done"], data["total"],
-        )
-
-    def set_state(self, state):
-        print state + "..."
-
-
-##############################################
-##############################################
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="A script to port an existing synapse SQLite database to"
-                    " a new PostgreSQL database."
-    )
-    parser.add_argument("-v", action='store_true')
-    parser.add_argument(
-        "--sqlite-database", required=True,
-        help="The snapshot of the SQLite database file. This must not be"
-             " currently used by a running synapse server"
-    )
-    parser.add_argument(
-        "--postgres-config", type=argparse.FileType('r'), required=True,
-        help="The database config file for the PostgreSQL database"
-    )
-    parser.add_argument(
-        "--curses", action='store_true',
-        help="display a curses based progress UI"
-    )
-
-    parser.add_argument(
-        "--batch-size", type=int, default=1000,
-        help="The number of rows to select from the SQLite table each"
-             " iteration [default=1000]",
-    )
-
-    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"
-    }
-
-    if args.curses:
-        logging_config["filename"] = "port-synapse.log"
-
-    logging.basicConfig(**logging_config)
-
-    sqlite_config = {
-        "name": "sqlite3",
-        "args": {
-            "database": args.sqlite_database,
-            "cp_min": 1,
-            "cp_max": 1,
-            "check_same_thread": False,
-        },
-    }
-
-    postgres_config = yaml.safe_load(args.postgres_config)
-
-    if "database" in postgres_config:
-        postgres_config = postgres_config["database"]
-
-    if "name" not in postgres_config:
-        sys.stderr.write("Malformed database config: no 'name'")
-        sys.exit(2)
-    if postgres_config["name"] != "psycopg2":
-        sys.stderr.write("Database must use 'psycopg2' connector.")
-        sys.exit(3)
-
-    def start(stdscr=None):
-        if stdscr:
-            progress = CursesProgress(stdscr)
-        else:
-            progress = TerminalProgress()
-
-        porter = Porter(
-            sqlite_config=sqlite_config,
-            postgres_config=postgres_config,
-            progress=progress,
-            batch_size=args.batch_size,
-        )
-
-        reactor.callWhenRunning(porter.run)
-
-        reactor.run()
-
-    if args.curses:
-        curses.wrapper(start)
-    else:
-        start()
-
-    if end_error_exec_info:
-        exc_type, exc_value, exc_traceback = end_error_exec_info
-        traceback.print_exception(exc_type, exc_value, exc_traceback)
--- a/scripts/register_new_matrix_user
+++ b/scripts/register_new_matrix_user
@@ -1,154 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright 2015 OpenMarket Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-import argparse
-import getpass
-import hashlib
-import hmac
-import json
-import sys
-import urllib2
-import yaml
-
-
-def request_registration(user, password, server_location, shared_secret):
-    mac = hmac.new(
-        key=shared_secret,
-        msg=user,
-        digestmod=hashlib.sha1,
-    ).hexdigest()
-
-    data = {
-        "user": user,
-        "password": password,
-        "mac": mac,
-        "type": "org.matrix.login.shared_secret",
-    }
-
-    server_location = server_location.rstrip("/")
-
-    print "Sending registration request..."
-
-    req = urllib2.Request(
-        "%s/_matrix/client/api/v1/register" % (server_location,),
-        data=json.dumps(data),
-        headers={'Content-Type': 'application/json'}
-    )
-    try:
-        if sys.version_info[:3] >= (2, 7, 9):
-            # As of version 2.7.9, urllib2 now checks SSL certs
-            import ssl
-            f = urllib2.urlopen(req, context=ssl.SSLContext(ssl.PROTOCOL_SSLv23))
-        else:
-            f = urllib2.urlopen(req)
-        f.read()
-        f.close()
-        print "Success."
-    except urllib2.HTTPError as e:
-        print "ERROR! Received %d %s" % (e.code, e.reason,)
-        if 400 <= e.code < 500:
-            if e.info().type == "application/json":
-                resp = json.load(e)
-                if "error" in resp:
-                    print resp["error"]
-        sys.exit(1)
-
-
-def register_new_user(user, password, server_location, shared_secret):
-    if not user:
-        try:
-            default_user = getpass.getuser()
-        except:
-            default_user = None
-
-        if default_user:
-            user = raw_input("New user localpart [%s]: " % (default_user,))
-            if not user:
-                user = default_user
-        else:
-            user = raw_input("New user localpart: ")
-
-    if not user:
-        print "Invalid user name"
-        sys.exit(1)
-
-    if not password:
-        password = getpass.getpass("Password: ")
-
-        if not password:
-            print "Password cannot be blank."
-            sys.exit(1)
-
-        confirm_password = getpass.getpass("Confirm password: ")
-
-        if password != confirm_password:
-            print "Passwords do not match"
-            sys.exit(1)
-
-    request_registration(user, password, server_location, shared_secret)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Used to register new users with a given home server when"
-                    " registration has been disabled. The home server must be"
-                    " configured with the 'registration_shared_secret' option"
-                    " set.",
-    )
-    parser.add_argument(
-        "-u", "--user",
-        default=None,
-        help="Local part of the new user. Will prompt if omitted.",
-    )
-    parser.add_argument(
-        "-p", "--password",
-        default=None,
-        help="New password for user. Will prompt if omitted.",
-    )
-
-    group = parser.add_mutually_exclusive_group(required=True)
-    group.add_argument(
-        "-c", "--config",
-        type=argparse.FileType('r'),
-        help="Path to server config file. Used to read in shared secret.",
-    )
-
-    group.add_argument(
-        "-k", "--shared-secret",
-        help="Shared secret as defined in server config file.",
-    )
-
-    parser.add_argument(
-        "server_url",
-        default="https://localhost:8448",
-        nargs='?',
-        help="URL to use to talk to the home server. Defaults to "
-             " 'https://localhost:8448'.",
-    )
-
-    args = parser.parse_args()
-
-    if "config" in args and args.config:
-        config = yaml.safe_load(args.config)
-        secret = config.get("registration_shared_secret", None)
-        if not secret:
-            print "No 'registration_shared_secret' defined in config."
-            sys.exit(1)
-    else:
-        secret = args.shared_secret
-
-    register_new_user(args.user, args.password, args.server_url, secret)
--- a/scripts-dev/sphinx_api_docs.sh
+++ b/scripts-dev/sphinx_api_docs.sh
--- a/scripts/upgrade_db_to_v0.6.0.py
+++ b/scripts/upgrade_db_to_v0.6.0.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+
 from synapse.storage import SCHEMA_VERSION, read_schema
 from synapse.storage._base import SQLBaseStore
 from synapse.storage.signatures import SignatureStore
--- a/setup.cfg
+++ b/setup.cfg
@@ -8,11 +8,3 @@ test = trial

 [trial]
 test_suite = tests
-
-[check-manifest]
-ignore =
-    contrib
-    contrib/*
-    docs/*
-    pylint.cfg
-    tox.ini
--- a/setup.py
+++ b/setup.py
@@ -14,47 +14,53 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-import glob
 import os
 from setuptools import setup, find_packages


-here = os.path.abspath(os.path.dirname(__file__))
-
-
-def read_file(path_segments):
-    """Read a file from the package. Takes a list of strings to join to
-    make the path"""
-    file_path = os.path.join(here, *path_segments)
-    with open(file_path) as f:
-        return f.read()
-
-
-def exec_file(path_segments):
-    """Execute a single python file to get the variables defined in it"""
-    result = {}
-    code = read_file(path_segments)
-    exec(code, result)
-    return result
-
-version = exec_file(("synapse", "__init__.py"))["__version__"]
-dependencies = exec_file(("synapse", "python_dependencies.py"))
-long_description = read_file(("README.rst",))
+# Utility function to read the README file.
+# Used for the long_description.  It's nice, because now 1) we have a top level
+# README file and 2) it's easier to type in the README file than to put a raw
+# string in below ...
+def read(fname):
+    return open(os.path.join(os.path.dirname(__file__), fname)).read()

 setup(
    name="matrix-synapse",
-    version=version,
+    version=read("VERSION").strip(),
    packages=find_packages(exclude=["tests", "tests.*"]),
    description="Reference Synapse Home Server",
-    install_requires=dependencies['requirements'](include_conditional=True).keys(),
+    install_requires=[
+        "syutil==0.0.2",
+        "matrix_angular_sdk==0.6.0",
+        "Twisted>=14.0.0",
+        "service_identity>=1.0.0",
+        "pyopenssl>=0.14",
+        "pyyaml",
+        "pyasn1",
+        "pynacl",
+        "daemonize",
+        "py-bcrypt",
+        "frozendict>=0.4",
+        "pillow",
+    ],
+    dependency_links=[
+        "https://github.com/matrix-org/syutil/tarball/v0.0.2#egg=syutil-0.0.2",
+        "https://github.com/pyca/pynacl/tarball/d4d3175589b892f6ea7c22f466e0e223853516fa#egg=pynacl-0.3.0",
+        "https://github.com/matrix-org/matrix-angular-sdk/tarball/v0.6.0/#egg=matrix_angular_sdk-0.6.0",
+    ],
    setup_requires=[
-        "Twisted==14.0.2", # Here to override setuptools_trial's dependency on Twisted>=2.4.0
        "setuptools_trial",
+        "setuptools>=1.0.0", # Needs setuptools that supports git+ssh.
+                             # TODO: Do we need this now? we don't use git+ssh.
        "mock"
    ],
-    dependency_links=dependencies["DEPENDENCY_LINKS"],
    include_package_data=True,
    zip_safe=False,
-    long_description=long_description,
-    scripts=["synctl"] + glob.glob("scripts/*"),
+    long_description=read("README.rst"),
+    entry_points="""
+    [console_scripts]
+    synctl=synapse.app.synctl:main
+    synapse-homeserver=synapse.app.homeserver:main
+    """
 )
--- a/static/client/register/index.html
+++ b/static/client/register/index.html
@@ -1,32 +0,0 @@
-<html>
-<head>
-<title> Registration </title>
-<meta name='viewport' content='width=device-width, initial-scale=1, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0'> 
-<link rel="stylesheet" href="style.css">
-<script src="js/jquery-2.1.3.min.js"></script>
-<script src="js/recaptcha_ajax.js"></script>
-<script src="register_config.js"></script>
-<script src="js/register.js"></script>
-</head>
-<body onload="matrixRegistration.onLoad()">
-<form id="registrationForm" onsubmit="matrixRegistration.signUp(); return false;">
-    <div>
-        Create account:<br/>
-        
-        <div style="text-align: center">
-            <input id="desired_user_id" size="32" type="text" placeholder="Matrix ID (e.g. bob)" autocapitalize="off" autocorrect="off" />
-            <br/>
-            <input id="pwd1" size="32" type="password" placeholder="Type a password"/>
-            <br/>
-            <input id="pwd2" size="32" type="password" placeholder="Confirm your password"/>
-            <br/>
-            <span id="feedback" style="color: #f00"></span>
-            <br/>
-            <div id="regcaptcha"></div>
-
-            <button type="submit" style="margin: 10px">Sign up</button>
-        </div>
-    </div>
-</form>
-</body>
-</html>
--- a/static/client/register/js/jquery-2.1.3.min.js
+++ b/static/client/register/js/jquery-2.1.3.min.js
--- a/static/client/register/js/recaptcha_ajax.js
+++ b/static/client/register/js/recaptcha_ajax.js
--- a/static/client/register/js/register.js
+++ b/static/client/register/js/register.js
@@ -1,117 +0,0 @@
-window.matrixRegistration = {
-    endpoint: location.origin + "/_matrix/client/api/v1/register"
-};
-
-var setupCaptcha = function() {
-    if (!window.matrixRegistrationConfig) {
-        return;
-    }
-    $.get(matrixRegistration.endpoint, function(response) {
-        var serverExpectsCaptcha = false;
-        for (var i=0; i<response.flows.length; i++) {
-            var flow = response.flows[i];
-            if ("m.login.recaptcha" === flow.type) {
-                serverExpectsCaptcha = true;
-                break;
-            }
-        }
-        if (!serverExpectsCaptcha) {
-            console.log("This server does not require a captcha.");
-            return;
-        }
-        console.log("Setting up ReCaptcha for "+matrixRegistration.endpoint);
-        var public_key = window.matrixRegistrationConfig.recaptcha_public_key;
-        if (public_key === undefined) {
-            console.error("No public key defined for captcha!");
-            setFeedbackString("Misconfigured captcha for server. Contact server admin.");
-            return;
-        }
-        Recaptcha.create(public_key,
-        "regcaptcha",
-        {
-            theme: "red",
-            callback: Recaptcha.focus_response_field
-        });
-        window.matrixRegistration.isUsingRecaptcha = true;
-    }).error(errorFunc);
-    
-};
-
-var submitCaptcha = function(user, pwd) {
-    var challengeToken = Recaptcha.get_challenge();
-    var captchaEntry = Recaptcha.get_response();
-    var data = {
-        type: "m.login.recaptcha",
-        challenge: challengeToken,
-        response: captchaEntry
-    };
-    console.log("Submitting captcha");
-    $.post(matrixRegistration.endpoint, JSON.stringify(data), function(response) {
-        console.log("Success -> "+JSON.stringify(response));
-        submitPassword(user, pwd, response.session);
-    }).error(function(err) {
-        Recaptcha.reload();
-        errorFunc(err);
-    });
-};
-
-var submitPassword = function(user, pwd, session) {
-    console.log("Registering...");
-    var data = {
-        type: "m.login.password",
-        user: user,
-        password: pwd,
-        session: session
-    };
-    $.post(matrixRegistration.endpoint, JSON.stringify(data), function(response) {
-        matrixRegistration.onRegistered(
-            response.home_server, response.user_id, response.access_token
-        );
-    }).error(errorFunc);
-};
-
-var errorFunc = function(err) {
-    if (err.responseJSON && err.responseJSON.error) {
-        setFeedbackString(err.responseJSON.error + " (" + err.responseJSON.errcode + ")");
-    }
-    else {
-        setFeedbackString("Request failed: " + err.status);
-    }
-};
-
-var setFeedbackString = function(text) {
-    $("#feedback").text(text);
-};
-
-matrixRegistration.onLoad = function() {
-    setupCaptcha();
-};
-
-matrixRegistration.signUp = function() {
-    var user = $("#desired_user_id").val();
-    if (user.length == 0) {
-        setFeedbackString("Must specify a username.");
-        return;
-    }
-    var pwd1 = $("#pwd1").val();
-    var pwd2 = $("#pwd2").val();
-    if (pwd1.length < 6) {
-        setFeedbackString("Password: min. 6 characters.");
-        return;
-    }
-    if (pwd1 != pwd2) {
-        setFeedbackString("Passwords do not match.");
-        return;
-    }
-    if (window.matrixRegistration.isUsingRecaptcha) {
-        submitCaptcha(user, pwd1);
-    }
-    else {
-        submitPassword(user, pwd1);
-    }
-};
-
-matrixRegistration.onRegistered = function(hs_url, user_id, access_token) {
-    // clobber this function
-    console.log("onRegistered - This function should be replaced to proceed.");
-};
--- a/static/client/register/register_config.sample.js
+++ b/static/client/register/register_config.sample.js
@@ -1,3 +0,0 @@
-window.matrixRegistrationConfig = {
-  recaptcha_public_key: "YOUR_PUBLIC_KEY"
-};
--- a/static/client/register/style.css
+++ b/static/client/register/style.css
@@ -1,60 +0,0 @@
-html {
-    height: 100%;
-}
-
-body {
-    height: 100%;
-    font-family: "Myriad Pro", "Myriad", Helvetica, Arial, sans-serif;
-    font-size: 12pt;
-    margin: 0px;
-}
-
-h1 {
-    font-size: 20pt;
-}
-
-a:link    { color: #666; }
-a:visited { color: #666; }
-a:hover   { color: #000; }
-a:active  { color: #000; }
-
-input {
-   width: 100%
-}
-
-textarea, input {
-   font-family: inherit;
-   font-size: inherit;
-}
-
-.smallPrint {
-    color: #888;
-    font-size: 9pt ! important;
-    font-style: italic ! important;
-}
-
-#recaptcha_area { 
-    margin: auto
-}
-
-.g-recaptcha div {
-    margin: auto;
-}
-
-#registrationForm {
-    text-align: left;
-    padding: 5px;
-    margin-bottom: 40px;
-    display: inline-block;
-    
-    -webkit-border-radius: 10px;
-    -moz-border-radius: 10px;
-    border-radius: 10px;
-    
-    -webkit-box-shadow: 0px 0px 20px 0px rgba(0,0,0,0.15);
-    -moz-box-shadow: 0px 0px 20px 0px rgba(0,0,0,0.15);
-    box-shadow: 0px 0px 20px 0px rgba(0,0,0,0.15);
-    
-    background-color: #f8f8f8;
-    border: 1px #ccc solid;
-}
--- a/synapse/init.py
+++ b/synapse/init.py
@@ -16,4 +16,4 @@
 """ This is a reference implementation of a Matrix home server.
 """

-__version__ = "0.9.1"
+__version__ = "0.6.1b"
--- a/synapse/api/auth.py
+++ b/synapse/api/auth.py
@@ -18,28 +18,21 @@
 from twisted.internet import defer

 from synapse.api.constants import EventTypes, Membership, JoinRules
-from synapse.api.errors import AuthError, Codes, SynapseError
+from synapse.api.errors import AuthError, StoreError, Codes, SynapseError
 from synapse.util.logutils import log_function
-from synapse.types import UserID, ClientInfo
+from synapse.util.async import run_on_reactor

 import logging

 logger = logging.getLogger(__name__)


-AuthEventTypes = (
-    EventTypes.Create, EventTypes.Member, EventTypes.PowerLevels,
-    EventTypes.JoinRules,
-)
-
-
 class Auth(object):

    def __init__(self, hs):
        self.hs = hs
        self.store = hs.get_datastore()
        self.state = hs.get_state_handler()
-        self.TOKEN_NOT_FOUND_HTTP_STATUS = 401

    def check(self, event, auth_events):
        """ Checks if this event is correctly authed.
@@ -64,10 +57,7 @@ class Auth(object):
            if event.type == EventTypes.Aliases:
                return True

-            logger.debug(
-                "Auth events: %s",
-                [a.event_id for a in auth_events.values()]
-            )
+            logger.debug("Auth events: %s", auth_events)

            if event.type == EventTypes.Member:
                allowed = self.is_membership_change_allowed(
@@ -98,19 +88,12 @@ class Auth(object):
            raise

    @defer.inlineCallbacks
-    def check_joined_room(self, room_id, user_id, current_state=None):
-        if current_state:
-            member = current_state.get(
-                (EventTypes.Member, user_id),
-                None
-            )
-        else:
-            member = yield self.state.get_current_state(
-                room_id=room_id,
-                event_type=EventTypes.Member,
-                state_key=user_id
-            )
-
+    def check_joined_room(self, room_id, user_id):
+        member = yield self.state.get_current_state(
+            room_id=room_id,
+            event_type=EventTypes.Member,
+            state_key=user_id
+        )
        self._check_joined_room(member, user_id, room_id)
        defer.returnValue(member)

@@ -118,10 +101,10 @@ class Auth(object):
    def check_host_in_room(self, room_id, host):
        curr_state = yield self.state.get_current_state(room_id)

-        for event in curr_state.values():
+        for event in curr_state:
            if event.type == EventTypes.Member:
                try:
-                    if UserID.from_string(event.state_key).domain != host:
+                    if self.hs.parse_userid(event.state_key).domain != host:
                        continue
                except:
                    logger.warn("state_key not user_id: %s", event.state_key)
@@ -175,7 +158,6 @@ class Auth(object):
        target = auth_events.get(key)

        target_in_room = target and target.membership == Membership.JOIN
-        target_banned = target and target.membership == Membership.BAN

        key = (EventTypes.JoinRules, "", )
        join_rule_event = auth_events.get(key)
@@ -186,17 +168,24 @@ class Auth(object):
        else:
            join_rule = JoinRules.INVITE

-        user_level = self._get_user_power_level(event.user_id, auth_events)
+        user_level = self._get_power_level_from_event_state(
+            event,
+            event.user_id,
+            auth_events,
+        )

-        # FIXME (erikj): What should we do here as the default?
-        ban_level = self._get_named_level(auth_events, "ban", 50)
+        ban_level, kick_level, redact_level = (
+            self._get_ops_level_from_event_state(
+                event,
+                auth_events,
+            )
+        )

        logger.debug(
            "is_membership_change_allowed: %s",
            {
                "caller_in_room": caller_in_room,
                "caller_invited": caller_invited,
-                "target_banned": target_banned,
                "target_in_room": target_in_room,
                "membership": membership,
                "join_rule": join_rule,
@@ -205,41 +194,25 @@ class Auth(object):
            }
        )

-        if Membership.JOIN != membership:
-            # JOIN is the only action you can perform if you're not in the room
-            if not caller_in_room:  # caller isn't joined
-                raise AuthError(
-                    403,
-                    "%s not in room %s." % (event.user_id, event.room_id,)
-                )
-
        if Membership.INVITE == membership:
            # TODO (erikj): We should probably handle this more intelligently
            # PRIVATE join rules.

            # Invites are valid iff caller is in the room and target isn't.
-            if target_banned:
+            if not caller_in_room:  # caller isn't joined
                raise AuthError(
-                    403, "%s is banned from the room" % (target_user_id,)
+                    403,
+                    "%s not in room %s." % (event.user_id, event.room_id,)
                )
            elif target_in_room:  # the target is already in the room.
                raise AuthError(403, "%s is already in the room." %
                                     target_user_id)
-            else:
-                invite_level = self._get_named_level(auth_events, "invite", 0)
-
-                if user_level < invite_level:
-                    raise AuthError(
-                        403, "You cannot invite user %s." % target_user_id
-                    )
        elif Membership.JOIN == membership:
            # Joins are valid iff caller == target and they were:
            # invited: They are accepting the invitation
            # joined: It's a NOOP
            if event.user_id != target_user_id:
                raise AuthError(403, "Cannot force another user to join.")
-            elif target_banned:
-                raise AuthError(403, "You are banned from this room")
            elif join_rule == JoinRules.PUBLIC:
                pass
            elif join_rule == JoinRules.INVITE:
@@ -251,18 +224,28 @@ class Auth(object):
                raise AuthError(403, "You are not allowed to join this room")
        elif Membership.LEAVE == membership:
            # TODO (erikj): Implement kicks.
-            if target_banned and user_level < ban_level:
+
+            if not caller_in_room:  # trying to leave a room you aren't joined
                raise AuthError(
-                    403, "You cannot unban user &s." % (target_user_id,)
+                    403,
+                    "%s not in room %s." % (target_user_id, event.room_id,)
                )
            elif target_user_id != event.user_id:
-                kick_level = self._get_named_level(auth_events, "kick", 50)
+                if kick_level:
+                    kick_level = int(kick_level)
+                else:
+                    kick_level = 50  # FIXME (erikj): What should we do here?

                if user_level < kick_level:
                    raise AuthError(
                        403, "You cannot kick user %s." % target_user_id
                    )
        elif Membership.BAN == membership:
+            if ban_level:
+                ban_level = int(ban_level)
+            else:
+                ban_level = 50  # FIXME (erikj): What should we do here?
+
            if user_level < ban_level:
                raise AuthError(403, "You don't have permission to ban")
        else:
@@ -270,42 +253,34 @@ class Auth(object):

        return True

-    def _get_power_level_event(self, auth_events):
+    def _get_power_level_from_event_state(self, event, user_id, auth_events):
        key = (EventTypes.PowerLevels, "", )
-        return auth_events.get(key)
-
-    def _get_user_power_level(self, user_id, auth_events):
-        power_level_event = self._get_power_level_event(auth_events)
-
+        power_level_event = auth_events.get(key)
+        level = None
        if power_level_event:
            level = power_level_event.content.get("users", {}).get(user_id)
            if not level:
                level = power_level_event.content.get("users_default", 0)
-
-            if level is None:
-                return 0
-            else:
-                return int(level)
        else:
            key = (EventTypes.Create, "", )
            create_event = auth_events.get(key)
            if (create_event is not None and
                    create_event.content["creator"] == user_id):
                return 100
-            else:
-                return 0

-    def _get_named_level(self, auth_events, name, default):
-        power_level_event = self._get_power_level_event(auth_events)
+        return level

-        if not power_level_event:
-            return default
+    def _get_ops_level_from_event_state(self, event, auth_events):
+        key = (EventTypes.PowerLevels, "", )
+        power_level_event = auth_events.get(key)

-        level = power_level_event.content.get(name, None)
-        if level is not None:
-            return int(level)
-        else:
-            return default
+        if power_level_event:
+            return (
+                power_level_event.content.get("ban", 50),
+                power_level_event.content.get("kick", 50),
+                power_level_event.content.get("redact", 50),
+            )
+        return None, None, None,

    @defer.inlineCallbacks
    def get_user_by_req(self, request):
@@ -314,47 +289,15 @@ class Auth(object):
        Args:
            request - An HTTP request with an access_token query parameter.
        Returns:
-            tuple : of UserID and device string:
-                User ID object of the user making the request
-                Client ID object of the client instance the user is using
+            UserID : User ID object of the user making the request
        Raises:
            AuthError if no user by that token exists or the token is invalid.
        """
        # Can optionally look elsewhere in the request (e.g. headers)
        try:
            access_token = request.args["access_token"][0]
-
-            # Check for application service tokens with a user_id override
-            try:
-                app_service = yield self.store.get_app_service_by_token(
-                    access_token
-                )
-                if not app_service:
-                    raise KeyError
-
-                user_id = app_service.sender
-                if "user_id" in request.args:
-                    user_id = request.args["user_id"][0]
-                    if not app_service.is_interested_in_user(user_id):
-                        raise AuthError(
-                            403,
-                            "Application service cannot masquerade as this user."
-                        )
-
-                if not user_id:
-                    raise KeyError
-
-                defer.returnValue(
-                    (UserID.from_string(user_id), ClientInfo("", ""))
-                )
-                return
-            except KeyError:
-                pass  # normal users won't have this query parameter set
-
            user_info = yield self.get_user_by_token(access_token)
            user = user_info["user"]
-            device_id = user_info["device_id"]
-            token_id = user_info["token_id"]

            ip_addr = self.hs.get_ip_from_request(request)
            user_agent = request.requestHeaders.getRawHeaders(
@@ -362,7 +305,7 @@ class Auth(object):
                default=[""]
            )[0]
            if user and access_token and ip_addr:
-                self.store.insert_client_ip(
+                yield self.store.insert_client_ip(
                    user=user,
                    access_token=access_token,
                    device_id=user_info["device_id"],
@@ -370,12 +313,9 @@ class Auth(object):
                    user_agent=user_agent
                )

-            defer.returnValue((user, ClientInfo(device_id, token_id)))
+            defer.returnValue(user)
        except KeyError:
-            raise AuthError(
-                self.TOKEN_NOT_FOUND_HTTP_STATUS, "Missing access token.",
-                errcode=Codes.MISSING_TOKEN
-            )
+            raise AuthError(403, "Missing access token.")

    @defer.inlineCallbacks
    def get_user_by_token(self, token):
@@ -389,71 +329,49 @@ class Auth(object):
        Raises:
            AuthError if no user by that token exists or the token is invalid.
        """
-        ret = yield self.store.get_user_by_token(token)
-        if not ret:
-            raise AuthError(
-                self.TOKEN_NOT_FOUND_HTTP_STATUS, "Unrecognised access token.",
-                errcode=Codes.UNKNOWN_TOKEN
-            )
-        user_info = {
-            "admin": bool(ret.get("admin", False)),
-            "device_id": ret.get("device_id"),
-            "user": UserID.from_string(ret.get("name")),
-            "token_id": ret.get("token_id", None),
-        }
-
-        defer.returnValue(user_info)
-
-    @defer.inlineCallbacks
-    def get_appservice_by_req(self, request):
        try:
-            token = request.args["access_token"][0]
-            service = yield self.store.get_app_service_by_token(token)
-            if not service:
-                raise AuthError(
-                    self.TOKEN_NOT_FOUND_HTTP_STATUS,
-                    "Unrecognised access token.",
-                    errcode=Codes.UNKNOWN_TOKEN
-                )
-            defer.returnValue(service)
-        except KeyError:
-            raise AuthError(
-                self.TOKEN_NOT_FOUND_HTTP_STATUS, "Missing access token."
-            )
+            ret = yield self.store.get_user_by_token(token=token)
+            if not ret:
+                raise StoreError()
+
+            user_info = {
+                "admin": bool(ret.get("admin", False)),
+                "device_id": ret.get("device_id"),
+                "user": self.hs.parse_userid(ret.get("name")),
+            }
+
+            defer.returnValue(user_info)
+        except StoreError:
+            raise AuthError(403, "Unrecognised access token.",
+                            errcode=Codes.UNKNOWN_TOKEN)

    def is_server_admin(self, user):
        return self.store.is_server_admin(user)

    @defer.inlineCallbacks
    def add_auth_events(self, builder, context):
-        auth_ids = self.compute_auth_events(builder, context.current_state)
+        yield run_on_reactor()

-        auth_events_entries = yield self.store.add_event_hashes(
-            auth_ids
-        )
-
-        builder.auth_events = auth_events_entries
-
-    def compute_auth_events(self, event, current_state):
-        if event.type == EventTypes.Create:
-            return []
+        if builder.type == EventTypes.Create:
+            builder.auth_events = []
+            return

        auth_ids = []

        key = (EventTypes.PowerLevels, "", )
-        power_level_event = current_state.get(key)
+        power_level_event = context.current_state.get(key)

        if power_level_event:
            auth_ids.append(power_level_event.event_id)

        key = (EventTypes.JoinRules, "", )
-        join_rule_event = current_state.get(key)
+        join_rule_event = context.current_state.get(key)

-        key = (EventTypes.Member, event.user_id, )
-        member_event = current_state.get(key)
+        key = (EventTypes.Member, builder.user_id, )
+        member_event = context.current_state.get(key)

        key = (EventTypes.Create, "", )
-        create_event = current_state.get(key)
+        create_event = context.current_state.get(key)
        if create_event:
            auth_ids.append(create_event.event_id)

@@ -463,8 +381,8 @@ class Auth(object):
        else:
            is_public = False

-        if event.type == EventTypes.Member:
-            e_type = event.content["membership"]
+        if builder.type == EventTypes.Member:
+            e_type = builder.content["membership"]
            if e_type in [Membership.JOIN, Membership.INVITE]:
                if join_rule_event:
                    auth_ids.append(join_rule_event.event_id)
@@ -479,7 +397,17 @@ class Auth(object):
            if member_event.content["membership"] == Membership.JOIN:
                auth_ids.append(member_event.event_id)

-        return auth_ids
+        auth_events_entries = yield self.store.add_event_hashes(
+            auth_ids
+        )
+
+        builder.auth_events = auth_events_entries
+
+        context.auth_events = {
+            k: v
+            for k, v in context.current_state.items()
+            if v.event_id in auth_ids
+        }

    @log_function
    def _can_send_event(self, event, auth_events):
@@ -490,7 +418,7 @@ class Auth(object):
            send_level = send_level_event.content.get("events", {}).get(
                event.type
            )
-            if send_level is None:
+            if not send_level:
                if hasattr(event, "state_key"):
                    send_level = send_level_event.content.get(
                        "state_default", 50
@@ -505,7 +433,16 @@ class Auth(object):
        else:
            send_level = 0

-        user_level = self._get_user_power_level(event.user_id, auth_events)
+        user_level = self._get_power_level_from_event_state(
+            event,
+            event.user_id,
+            auth_events,
+        )
+
+        if user_level:
+            user_level = int(user_level)
+        else:
+            user_level = 0

        if user_level < send_level:
            raise AuthError(
@@ -524,7 +461,7 @@ class Auth(object):
                            "You are not allowed to set others state"
                        )
                    else:
-                        sender_domain = UserID.from_string(
+                        sender_domain = self.hs.parse_userid(
                            event.user_id
                        ).domain

@@ -537,9 +474,16 @@ class Auth(object):
        return True

    def _check_redaction(self, event, auth_events):
-        user_level = self._get_user_power_level(event.user_id, auth_events)
+        user_level = self._get_power_level_from_event_state(
+            event,
+            event.user_id,
+            auth_events,
+        )

-        redact_level = self._get_named_level(auth_events, "redact", 50)
+        _, _, redact_level = self._get_ops_level_from_event_state(
+            event,
+            auth_events,
+        )

        if user_level < redact_level:
            raise AuthError(
@@ -552,7 +496,7 @@ class Auth(object):
        # Validate users
        for k, v in user_list.items():
            try:
-                UserID.from_string(k)
+                self.hs.parse_userid(k)
            except:
                raise SynapseError(400, "Not a valid user_id: %s" % (k,))

@@ -567,7 +511,11 @@ class Auth(object):
        if not current_state:
            return

-        user_level = self._get_user_power_level(event.user_id, auth_events)
+        user_level = self._get_power_level_from_event_state(
+            event,
+            event.user_id,
+            auth_events,
+        )

        # Check other levels:
        levels_to_check = [
@@ -576,7 +524,6 @@ class Auth(object):
            ("ban", []),
            ("redact", []),
            ("kick", []),
-            ("invite", []),
        ]

        old_list = current_state.content.get("users")
--- a/synapse/api/constants.py
+++ b/synapse/api/constants.py
@@ -59,11 +59,6 @@ class LoginType(object):
    EMAIL_URL = u"m.login.email.url"
    EMAIL_IDENTITY = u"m.login.email.identity"
    RECAPTCHA = u"m.login.recaptcha"
-    DUMMY = u"m.login.dummy"
-
-    # Only for C/S API v1
-    APPLICATION_SERVICE = u"m.login.application_service"
-    SHARED_SECRET = u"org.matrix.login.shared_secret"


 class EventTypes(object):
@@ -79,9 +74,3 @@ class EventTypes(object):
    Message = "m.room.message"
    Topic = "m.room.topic"
    Name = "m.room.name"
-
-
-class RejectedReason(object):
-    AUTH_ERROR = "auth_error"
-    REPLACED = "replaced"
-    NOT_ANCESTOR = "not_ancestor"
--- a/synapse/api/errors.py
+++ b/synapse/api/errors.py
@@ -21,7 +21,6 @@ logger = logging.getLogger(__name__)


 class Codes(object):
-    UNRECOGNIZED = "M_UNRECOGNIZED"
    UNAUTHORIZED = "M_UNAUTHORIZED"
    FORBIDDEN = "M_FORBIDDEN"
    BAD_JSON = "M_BAD_JSON"
@@ -31,18 +30,14 @@ class Codes(object):
    BAD_PAGINATION = "M_BAD_PAGINATION"
    UNKNOWN = "M_UNKNOWN"
    NOT_FOUND = "M_NOT_FOUND"
-    MISSING_TOKEN = "M_MISSING_TOKEN"
    UNKNOWN_TOKEN = "M_UNKNOWN_TOKEN"
    LIMIT_EXCEEDED = "M_LIMIT_EXCEEDED"
    CAPTCHA_NEEDED = "M_CAPTCHA_NEEDED"
    CAPTCHA_INVALID = "M_CAPTCHA_INVALID"
-    MISSING_PARAM = "M_MISSING_PARAM"
    TOO_LARGE = "M_TOO_LARGE"
-    EXCLUSIVE = "M_EXCLUSIVE"
-    THREEPID_AUTH_FAILED = "M_THREEPID_AUTH_FAILED"


-class CodeMessageException(RuntimeError):
+class CodeMessageException(Exception):
    """An exception with integer code and message string attributes."""

    def __init__(self, code, msg):
@@ -86,35 +81,6 @@ class RegistrationError(SynapseError):
    pass


-class UnrecognizedRequestError(SynapseError):
-    """An error indicating we don't understand the request you're trying to make"""
-    def __init__(self, *args, **kwargs):
-        if "errcode" not in kwargs:
-            kwargs["errcode"] = Codes.UNRECOGNIZED
-        message = None
-        if len(args) == 0:
-            message = "Unrecognized request"
-        else:
-            message = args[0]
-        super(UnrecognizedRequestError, self).__init__(
-            400,
-            message,
-            **kwargs
-        )
-
-
-class NotFoundError(SynapseError):
-    """An error indicating we can't find the thing you asked for"""
-    def __init__(self, *args, **kwargs):
-        if "errcode" not in kwargs:
-            kwargs["errcode"] = Codes.NOT_FOUND
-        super(NotFoundError, self).__init__(
-            404,
-            "Not found",
-            **kwargs
-        )
-
-
 class AuthError(SynapseError):
    """An error raised when there was a problem authorising an event."""

@@ -230,9 +196,3 @@ class FederationError(RuntimeError):
            "affected": self.affected,
            "source": self.source if self.source else self.affected,
        }
-
-
-class HttpResponseException(CodeMessageException):
-    def __init__(self, code, msg, response):
-        self.response = response
-        super(HttpResponseException, self).__init__(code, msg)
--- a/synapse/api/filtering.py
+++ b/synapse/api/filtering.py
@@ -1,229 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-from synapse.api.errors import SynapseError
-from synapse.types import UserID, RoomID
-
-
-class Filtering(object):
-
-    def __init__(self, hs):
-        super(Filtering, self).__init__()
-        self.store = hs.get_datastore()
-
-    def get_user_filter(self, user_localpart, filter_id):
-        result = self.store.get_user_filter(user_localpart, filter_id)
-        result.addCallback(Filter)
-        return result
-
-    def add_user_filter(self, user_localpart, user_filter):
-        self._check_valid_filter(user_filter)
-        return self.store.add_user_filter(user_localpart, user_filter)
-
-    # TODO(paul): surely we should probably add a delete_user_filter or
-    #   replace_user_filter at some point? There's no REST API specified for
-    #   them however
-
-    def _check_valid_filter(self, user_filter_json):
-        """Check if the provided filter is valid.
-
-        This inspects all definitions contained within the filter.
-
-        Args:
-            user_filter_json(dict): The filter
-        Raises:
-            SynapseError: If the filter is not valid.
-        """
-        # NB: Filters are the complete json blobs. "Definitions" are an
-        # individual top-level key e.g. public_user_data. Filters are made of
-        # many definitions.
-
-        top_level_definitions = [
-            "public_user_data", "private_user_data", "server_data"
-        ]
-
-        room_level_definitions = [
-            "state", "events", "ephemeral"
-        ]
-
-        for key in top_level_definitions:
-            if key in user_filter_json:
-                self._check_definition(user_filter_json[key])
-
-        if "room" in user_filter_json:
-            for key in room_level_definitions:
-                if key in user_filter_json["room"]:
-                    self._check_definition(user_filter_json["room"][key])
-
-    def _check_definition(self, definition):
-        """Check if the provided definition is valid.
-
-        This inspects not only the types but also the values to make sure they
-        make sense.
-
-        Args:
-            definition(dict): The filter definition
-        Raises:
-            SynapseError: If there was a problem with this definition.
-        """
-        # NB: Filters are the complete json blobs. "Definitions" are an
-        # individual top-level key e.g. public_user_data. Filters are made of
-        # many definitions.
-        if type(definition) != dict:
-            raise SynapseError(
-                400, "Expected JSON object, not %s" % (definition,)
-            )
-
-        # check rooms are valid room IDs
-        room_id_keys = ["rooms", "not_rooms"]
-        for key in room_id_keys:
-            if key in definition:
-                if type(definition[key]) != list:
-                    raise SynapseError(400, "Expected %s to be a list." % key)
-                for room_id in definition[key]:
-                    RoomID.from_string(room_id)
-
-        # check senders are valid user IDs
-        user_id_keys = ["senders", "not_senders"]
-        for key in user_id_keys:
-            if key in definition:
-                if type(definition[key]) != list:
-                    raise SynapseError(400, "Expected %s to be a list." % key)
-                for user_id in definition[key]:
-                    UserID.from_string(user_id)
-
-        # TODO: We don't limit event type values but we probably should...
-        # check types are valid event types
-        event_keys = ["types", "not_types"]
-        for key in event_keys:
-            if key in definition:
-                if type(definition[key]) != list:
-                    raise SynapseError(400, "Expected %s to be a list." % key)
-                for event_type in definition[key]:
-                    if not isinstance(event_type, basestring):
-                        raise SynapseError(400, "Event type should be a string")
-
-        if "format" in definition:
-            event_format = definition["format"]
-            if event_format not in ["federation", "events"]:
-                raise SynapseError(400, "Invalid format: %s" % (event_format,))
-
-        if "select" in definition:
-            event_select_list = definition["select"]
-            for select_key in event_select_list:
-                if select_key not in ["event_id", "origin_server_ts",
-                                      "thread_id", "content", "content.body"]:
-                    raise SynapseError(400, "Bad select: %s" % (select_key,))
-
-        if ("bundle_updates" in definition and
-                type(definition["bundle_updates"]) != bool):
-            raise SynapseError(400, "Bad bundle_updates: expected bool.")
-
-
-class Filter(object):
-    def __init__(self, filter_json):
-        self.filter_json = filter_json
-
-    def filter_public_user_data(self, events):
-        return self._filter_on_key(events, ["public_user_data"])
-
-    def filter_private_user_data(self, events):
-        return self._filter_on_key(events, ["private_user_data"])
-
-    def filter_room_state(self, events):
-        return self._filter_on_key(events, ["room", "state"])
-
-    def filter_room_events(self, events):
-        return self._filter_on_key(events, ["room", "events"])
-
-    def filter_room_ephemeral(self, events):
-        return self._filter_on_key(events, ["room", "ephemeral"])
-
-    def _filter_on_key(self, events, keys):
-        filter_json = self.filter_json
-        if not filter_json:
-            return events
-
-        try:
-            # extract the right definition from the filter
-            definition = filter_json
-            for key in keys:
-                definition = definition[key]
-            return self._filter_with_definition(events, definition)
-        except KeyError:
-            # return all events if definition isn't specified.
-            return events
-
-    def _filter_with_definition(self, events, definition):
-        return [e for e in events if self._passes_definition(definition, e)]
-
-    def _passes_definition(self, definition, event):
-        """Check if the event passes through the given definition.
-
-        Args:
-            definition(dict): The definition to check against.
-            event(Event): The event to check.
-        Returns:
-            True if the event passes through the filter.
-        """
-        # Algorithm notes:
-        # For each key in the definition, check the event meets the criteria:
-        #   * For types: Literal match or prefix match (if ends with wildcard)
-        #   * For senders/rooms: Literal match only
-        #   * "not_" checks take presedence (e.g. if "m.*" is in both 'types'
-        #     and 'not_types' then it is treated as only being in 'not_types')
-
-        # room checks
-        if hasattr(event, "room_id"):
-            room_id = event.room_id
-            allow_rooms = definition.get("rooms", None)
-            reject_rooms = definition.get("not_rooms", None)
-            if reject_rooms and room_id in reject_rooms:
-                return False
-            if allow_rooms and room_id not in allow_rooms:
-                return False
-
-        # sender checks
-        if hasattr(event, "sender"):
-            # Should we be including event.state_key for some event types?
-            sender = event.sender
-            allow_senders = definition.get("senders", None)
-            reject_senders = definition.get("not_senders", None)
-            if reject_senders and sender in reject_senders:
-                return False
-            if allow_senders and sender not in allow_senders:
-                return False
-
-        # type checks
-        if "not_types" in definition:
-            for def_type in definition["not_types"]:
-                if self._event_matches_type(event, def_type):
-                    return False
-        if "types" in definition:
-            included = False
-            for def_type in definition["types"]:
-                if self._event_matches_type(event, def_type):
-                    included = True
-                    break
-            if not included:
-                return False
-
-        return True
-
-    def _event_matches_type(self, event, def_type):
-        if def_type.endswith("*"):
-            type_prefix = def_type[:-1]
-            return event.type.startswith(type_prefix)
-        else:
-            return event.type == def_type
--- a/synapse/api/urls.py
+++ b/synapse/api/urls.py
@@ -16,12 +16,8 @@
 """Contains the URL paths to prefix various aspects of the server with. """

 CLIENT_PREFIX = "/_matrix/client/api/v1"
-CLIENT_V2_ALPHA_PREFIX = "/_matrix/client/v2_alpha"
 FEDERATION_PREFIX = "/_matrix/federation/v1"
-STATIC_PREFIX = "/_matrix/static"
 WEB_CLIENT_PREFIX = "/_matrix/client"
 CONTENT_REPO_PREFIX = "/_matrix/content"
 SERVER_KEY_PREFIX = "/_matrix/key/v1"
-SERVER_KEY_V2_PREFIX = "/_matrix/key/v2"
 MEDIA_PREFIX = "/_matrix/media/v1"
-APP_SERVICE_PREFIX = "/_matrix/appservice/v1"
--- a/synapse/app/homeserver.py
+++ b/synapse/app/homeserver.py
@@ -14,45 +14,29 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-import sys
-sys.dont_write_bytecode = True
-from synapse.python_dependencies import check_requirements
-
-if __name__ == '__main__':
-    check_requirements()
-
-from synapse.storage.engines import create_engine, IncorrectDatabaseSetup
-from synapse.storage import (
-    are_all_users_on_domain, UpgradeDatabaseException,
-)
+from synapse.storage import prepare_database, UpgradeDatabaseException

 from synapse.server import HomeServer

+from synapse.python_dependencies import check_requirements

 from twisted.internet import reactor
-from twisted.application import service
 from twisted.enterprise import adbapi
-from twisted.web.resource import Resource, EncodingResourceWrapper
+from twisted.web.resource import Resource
 from twisted.web.static import File
-from twisted.web.server import Site, GzipEncoderFactory
-from twisted.web.http import proxiedLogFormatter, combinedLogFormatter
+from twisted.web.server import Site
 from synapse.http.server import JsonResource, RootRedirect
-from synapse.rest.media.v0.content_repository import ContentRepoResource
-from synapse.rest.media.v1.media_repository import MediaRepositoryResource
-from synapse.rest.key.v1.server_key_resource import LocalKey
-from synapse.rest.key.v2 import KeyApiV2Resource
+from synapse.media.v0.content_repository import ContentRepoResource
+from synapse.media.v1.media_repository import MediaRepositoryResource
+from synapse.http.server_key_resource import LocalKey
 from synapse.http.matrixfederationclient import MatrixFederationHttpClient
 from synapse.api.urls import (
    CLIENT_PREFIX, FEDERATION_PREFIX, WEB_CLIENT_PREFIX, CONTENT_REPO_PREFIX,
-    SERVER_KEY_PREFIX, MEDIA_PREFIX, CLIENT_V2_ALPHA_PREFIX, STATIC_PREFIX,
-    SERVER_KEY_V2_PREFIX,
+    SERVER_KEY_PREFIX, MEDIA_PREFIX
 )
 from synapse.config.homeserver import HomeServerConfig
 from synapse.crypto import context_factory
 from synapse.util.logcontext import LoggingContext
-from synapse.rest.client.v1 import ClientV1RestResource
-from synapse.rest.client.v2_alpha import ClientV2AlphaRestResource
-from synapse.metrics.resource import MetricsResource, METRICS_PREFIX

 from daemonize import Daemonize
 import twisted.manhole.telnet
@@ -62,21 +46,11 @@ import synapse
 import logging
 import os
 import re
-import resource
-import subprocess
+import sys
+import sqlite3
+import syweb

-
-logger = logging.getLogger("synapse.app.homeserver")
-
-
-class GzipFile(File):
-    def getChild(self, path, request):
-        child = File.getChild(self, path, request)
-        return EncodingResourceWrapper(child, [GzipEncoderFactory()])
-
-
-def gz_wrap(r):
-    return EncodingResourceWrapper(r, [GzipEncoderFactory()])
+logger = logging.getLogger(__name__)


 class SynapseHomeServer(HomeServer):
@@ -85,30 +59,16 @@ class SynapseHomeServer(HomeServer):
        return MatrixFederationHttpClient(self)

    def build_resource_for_client(self):
-        return gz_wrap(ClientV1RestResource(self))
-
-    def build_resource_for_client_v2_alpha(self):
-        return gz_wrap(ClientV2AlphaRestResource(self))
+        return JsonResource()

    def build_resource_for_federation(self):
-        return JsonResource(self)
+        return JsonResource()

    def build_resource_for_web_client(self):
-        import syweb
        syweb_path = os.path.dirname(syweb.__file__)
        webclient_path = os.path.join(syweb_path, "webclient")
-        # GZip is disabled here due to
-        # https://twistedmatrix.com/trac/ticket/7678
-        # (It can stay enabled for the API resources: they call
-        # write() with the whole body and then finish() straight
-        # after and so do not trigger the bug.
-        # return GzipFile(webclient_path)  # TODO configurable?
        return File(webclient_path)  # TODO configurable?

-    def build_resource_for_static_content(self):
-        # This is old and should go away: not going to bother adding gzip
-        return File("static")
-
    def build_resource_for_content_repo(self):
        return ContentRepoResource(
            self, self.upload_dir, self.auth, self.content_addr
@@ -120,24 +80,15 @@ class SynapseHomeServer(HomeServer):
    def build_resource_for_server_key(self):
        return LocalKey(self)

-    def build_resource_for_server_key_v2(self):
-        return KeyApiV2Resource(self)
-
-    def build_resource_for_metrics(self):
-        if self.get_config().enable_metrics:
-            return MetricsResource(self)
-        else:
-            return None
-
    def build_db_pool(self):
-        name = self.db_config["name"]
-
        return adbapi.ConnectionPool(
-            name,
-            **self.db_config.get("args", {})
+            "sqlite3", self.get_db_name(),
+            check_same_thread=False,
+            cp_min=1,
+            cp_max=1
        )

-    def create_resource_tree(self, redirect_root_to_web_client):
+    def create_resource_tree(self, web_client, redirect_root_to_web_client):
        """Create the resource tree for this Home Server.

        This in unduly complicated because Twisted does not support putting
@@ -149,22 +100,15 @@ class SynapseHomeServer(HomeServer):
            location of the web client. This does nothing if web_client is not
            True.
        """
-        config = self.get_config()
-        web_client = config.web_client
-
        # list containing (path_str, Resource) e.g:
        # [ ("/aaa/bbb/cc", Resource1), ("/aaa/dummy", Resource2) ]
        desired_tree = [
            (CLIENT_PREFIX, self.get_resource_for_client()),
-            (CLIENT_V2_ALPHA_PREFIX, self.get_resource_for_client_v2_alpha()),
            (FEDERATION_PREFIX, self.get_resource_for_federation()),
            (CONTENT_REPO_PREFIX, self.get_resource_for_content_repo()),
            (SERVER_KEY_PREFIX, self.get_resource_for_server_key()),
-            (SERVER_KEY_V2_PREFIX, self.get_resource_for_server_key_v2()),
            (MEDIA_PREFIX, self.get_resource_for_media_repository()),
-            (STATIC_PREFIX, self.get_resource_for_static_content()),
        ]
-
        if web_client:
            logger.info("Adding the web client.")
            desired_tree.append((WEB_CLIENT_PREFIX,
@@ -175,20 +119,16 @@ class SynapseHomeServer(HomeServer):
        else:
            self.root_resource = Resource()

-        metrics_resource = self.get_resource_for_metrics()
-        if config.metrics_port is None and metrics_resource is not None:
-            desired_tree.append((METRICS_PREFIX, metrics_resource))
-
        # ideally we'd just use getChild and putChild but getChild doesn't work
        # unless you give it a Request object IN ADDITION to the name :/ So
        # instead, we'll store a copy of this mapping so we can actually add
        # extra resources to existing nodes. See self._resource_id for the key.
        resource_mappings = {}
-        for full_path, res in desired_tree:
-            logger.info("Attaching %s to path %s", res, full_path)
+        for (full_path, resource) in desired_tree:
+            logger.info("Attaching %s to path %s", resource, full_path)
            last_resource = self.root_resource
            for path_seg in full_path.split('/')[1:-1]:
-                if path_seg not in last_resource.listNames():
+                if not path_seg in last_resource.listNames():
                    # resource doesn't exist, so make a "dummy resource"
                    child_resource = Resource()
                    last_resource.putChild(path_seg, child_resource)
@@ -216,12 +156,12 @@ class SynapseHomeServer(HomeServer):
                                                     child_name)
                    child_resource = resource_mappings[child_res_id]
                    # steal the children
-                    res.putChild(child_name, child_resource)
+                    resource.putChild(child_name, child_resource)

            # finally, insert the desired resource in the right place
-            last_resource.putChild(last_path_seg, res)
+            last_resource.putChild(last_path_seg, resource)
            res_id = self._resource_id(last_resource, last_path_seg)
-            resource_mappings[res_id] = res
+            resource_mappings[res_id] = resource

        return self.root_resource

@@ -240,180 +180,32 @@ class SynapseHomeServer(HomeServer):
        """
        return "%s-%s" % (resource, path_seg)

-    def start_listening(self):
-        config = self.get_config()
-
-        if not config.no_tls and config.bind_port is not None:
+    def start_listening(self, secure_port, unsecure_port):
+        if secure_port is not None:
            reactor.listenSSL(
-                config.bind_port,
-                SynapseSite(
-                    "synapse.access.https",
-                    config,
-                    self.root_resource,
-                ),
-                self.tls_context_factory,
-                interface=config.bind_host
+                secure_port, Site(self.root_resource), self.tls_context_factory
            )
-            logger.info("Synapse now listening on port %d", config.bind_port)
-
-        if config.unsecure_port is not None:
+            logger.info("Synapse now listening on port %d", secure_port)
+        if unsecure_port is not None:
            reactor.listenTCP(
-                config.unsecure_port,
-                SynapseSite(
-                    "synapse.access.http",
-                    config,
-                    self.root_resource,
-                ),
-                interface=config.bind_host
+                unsecure_port, Site(self.root_resource)
            )
-            logger.info("Synapse now listening on port %d", config.unsecure_port)
-
-        metrics_resource = self.get_resource_for_metrics()
-        if metrics_resource and config.metrics_port is not None:
-            reactor.listenTCP(
-                config.metrics_port,
-                SynapseSite(
-                    "synapse.access.metrics",
-                    config,
-                    metrics_resource,
-                ),
-                interface=config.metrics_bind_host,
-            )
-            logger.info(
-                "Metrics now running on %s port %d",
-                config.metrics_bind_host, config.metrics_port,
-            )
-
-    def run_startup_checks(self, db_conn, database_engine):
-        all_users_native = are_all_users_on_domain(
-            db_conn.cursor(), database_engine, self.hostname
-        )
-        if not all_users_native:
-            quit_with_error(
-                "Found users in database not native to %s!\n"
-                "You cannot changed a synapse server_name after it's been configured"
-                % (self.hostname,)
-            )
-
-        try:
-            database_engine.check_database(db_conn.cursor())
-        except IncorrectDatabaseSetup as e:
-            quit_with_error(e.message)
+            logger.info("Synapse now listening on port %d", unsecure_port)


-def quit_with_error(error_string):
-    message_lines = error_string.split("\n")
-    line_length = max([len(l) for l in message_lines]) + 2
-    sys.stderr.write("*" * line_length + '\n')
-    for line in message_lines:
-        if line.strip():
-            sys.stderr.write(" %s\n" % (line.strip(),))
-    sys.stderr.write("*" * line_length + '\n')
-    sys.exit(1)
-
-
-def get_version_string():
-    try:
-        null = open(os.devnull, 'w')
-        cwd = os.path.dirname(os.path.abspath(__file__))
-        try:
-            git_branch = subprocess.check_output(
-                ['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
-                stderr=null,
-                cwd=cwd,
-            ).strip()
-            git_branch = "b=" + git_branch
-        except subprocess.CalledProcessError:
-            git_branch = ""
-
-        try:
-            git_tag = subprocess.check_output(
-                ['git', 'describe', '--exact-match'],
-                stderr=null,
-                cwd=cwd,
-            ).strip()
-            git_tag = "t=" + git_tag
-        except subprocess.CalledProcessError:
-            git_tag = ""
-
-        try:
-            git_commit = subprocess.check_output(
-                ['git', 'rev-parse', '--short', 'HEAD'],
-                stderr=null,
-                cwd=cwd,
-            ).strip()
-        except subprocess.CalledProcessError:
-            git_commit = ""
-
-        try:
-            dirty_string = "-this_is_a_dirty_checkout"
-            is_dirty = subprocess.check_output(
-                ['git', 'describe', '--dirty=' + dirty_string],
-                stderr=null,
-                cwd=cwd,
-            ).strip().endswith(dirty_string)
-
-            git_dirty = "dirty" if is_dirty else ""
-        except subprocess.CalledProcessError:
-            git_dirty = ""
-
-        if git_branch or git_tag or git_commit or git_dirty:
-            git_version = ",".join(
-                s for s in
-                (git_branch, git_tag, git_commit, git_dirty,)
-                if s
-            )
-
-            return (
-                "Synapse/%s (%s)" % (
-                    synapse.__version__, git_version,
-                )
-            ).encode("ascii")
-    except Exception as e:
-        logger.warn("Failed to check for git repository: %s", e)
-
-    return ("Synapse/%s" % (synapse.__version__,)).encode("ascii")
-
-
-def change_resource_limit(soft_file_no):
-    try:
-        soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
-
-        if not soft_file_no:
-            soft_file_no = hard
-
-        resource.setrlimit(resource.RLIMIT_NOFILE, (soft_file_no, hard))
-
-        logger.info("Set file limit to: %d", soft_file_no)
-    except (ValueError, resource.error) as e:
-        logger.warn("Failed to set file limit: %s", e)
-
-
-def setup(config_options):
-    """
-    Args:
-        config_options_options: The options passed to Synapse. Usually
-            `sys.argv[1:]`.
-        should_run (bool): Whether to start the reactor.
-
-    Returns:
-        HomeServer
-    """
+def setup():
    config = HomeServerConfig.load_config(
        "Synapse Homeserver",
-        config_options,
+        sys.argv[1:],
        generate_section="Homeserver"
    )

    config.setup_logging()

-    # check any extra requirements we have now we have a config
-    check_requirements(config)
-
-    version_string = get_version_string()
+    check_requirements()

    logger.info("Server hostname: %s", config.server_name)
-    logger.info("Server version: %s", version_string)
+    logger.info("Server version: %s", synapse.__version__)

    if re.search(":[0-9]+$", config.server_name):
        domain_with_port = config.server_name
@@ -422,39 +214,30 @@ def setup(config_options):

    tls_context_factory = context_factory.ServerContextFactory(config)

-    database_engine = create_engine(config.database_config["name"])
-    config.database_config["args"]["cp_openfun"] = database_engine.on_new_connection
-
    hs = SynapseHomeServer(
        config.server_name,
        domain_with_port=domain_with_port,
        upload_dir=os.path.abspath("uploads"),
-        db_config=config.database_config,
+        db_name=config.database_path,
        tls_context_factory=tls_context_factory,
        config=config,
        content_addr=config.content_addr,
-        version_string=version_string,
-        database_engine=database_engine,
    )

+    hs.register_servlets()
+
    hs.create_resource_tree(
+        web_client=config.webclient,
        redirect_root_to_web_client=True,
    )

-    logger.info("Preparing database: %r...", config.database_config)
+    db_name = hs.get_db_name()
+
+    logger.info("Preparing database: %s...", db_name)

    try:
-        db_conn = database_engine.module.connect(
-            **{
-                k: v for k, v in config.database_config.get("args", {}).items()
-                if not k.startswith("cp_")
-            }
-        )
-
-        database_engine.prepare_database(db_conn)
-        hs.run_startup_checks(db_conn, database_engine)
-
-        db_conn.commit()
+        with sqlite3.connect(db_name) as db_conn:
+            prepare_database(db_conn)
    except UpgradeDatabaseException:
        sys.stderr.write(
            "\nFailed to upgrade database.\n"
@@ -463,7 +246,15 @@ def setup(config_options):
        )
        sys.exit(1)

-    logger.info("Database prepared in %r.", config.database_config)
+    logger.info("Database prepared in %s.", db_name)
+
+    db_pool = hs.get_db_pool()
+
+    if db_name == ":memory:":
+        # Memory databases will need to be setup each time they are opened.
+        reactor.callWhenRunning(
+            db_pool.runWithConnection, prepare_database
+        )

    if config.manhole:
        f = twisted.manhole.telnet.ShellFactory()
@@ -472,85 +263,17 @@ def setup(config_options):
        f.namespace['hs'] = hs
        reactor.listenTCP(config.manhole, f, interface='127.0.0.1')

-    hs.start_listening()
-
-    hs.get_pusherpool().start()
-    hs.get_state_handler().start_caching()
-    hs.get_datastore().start_profiling()
-    hs.get_replication_layer().start_get_pdu_cache()
-
-    return hs
-
-
-class SynapseService(service.Service):
-    """A twisted Service class that will start synapse. Used to run synapse
-    via twistd and a .tac.
-    """
-    def __init__(self, config):
-        self.config = config
-
-    def startService(self):
-        hs = setup(self.config)
-        change_resource_limit(hs.config.soft_file_limit)
-
-    def stopService(self):
-        return self._port.stopListening()
-
-
-class SynapseSite(Site):
-    """
-    Subclass of a twisted http Site that does access logging with python's
-    standard logging
-    """
-    def __init__(self, logger_name, config, resource, *args, **kwargs):
-        Site.__init__(self, resource, *args, **kwargs)
-        if config.captcha_ip_origin_is_x_forwarded:
-            self._log_formatter = proxiedLogFormatter
-        else:
-            self._log_formatter = combinedLogFormatter
-        self.access_logger = logging.getLogger(logger_name)
-
-    def log(self, request):
-        line = self._log_formatter(self._logDateTime, request)
-        self.access_logger.info(line)
-
-
-def run(hs):
-    PROFILE_SYNAPSE = False
-    if PROFILE_SYNAPSE:
-        def profile(func):
-            from cProfile import Profile
-            from threading import current_thread
-
-            def profiled(*args, **kargs):
-                profile = Profile()
-                profile.enable()
-                func(*args, **kargs)
-                profile.disable()
-                ident = current_thread().ident
-                profile.dump_stats("/tmp/%s.%s.%i.pstat" % (
-                    hs.hostname, func.__name__, ident
-                ))
-
-            return profiled
-
-        from twisted.python.threadpool import ThreadPool
-        ThreadPool._worker = profile(ThreadPool._worker)
-        reactor.run = profile(reactor.run)
-
-    def in_thread():
-        with LoggingContext("run"):
-            change_resource_limit(hs.config.soft_file_limit)
-            reactor.run()
-
-    if hs.config.daemonize:
-
-        print hs.config.pid_file
+    bind_port = config.bind_port
+    if config.no_tls:
+        bind_port = None
+    hs.start_listening(bind_port, config.unsecure_port)

+    if config.daemonize:
+        print config.pid_file
        daemon = Daemonize(
            app="synapse-homeserver",
-            pid=hs.config.pid_file,
-            action=lambda: in_thread(),
+            pid=config.pid_file,
+            action=run,
            auto_close_fds=False,
            verbose=True,
            logger=logger,
@@ -558,15 +281,18 @@ def run(hs):

        daemon.start()
    else:
-        in_thread()
+        reactor.run()
+
+
+def run():
+    with LoggingContext("run"):
+        reactor.run()


 def main():
    with LoggingContext("main"):
-        # check base requirements
        check_requirements()
-        hs = setup(sys.argv[1:])
-        run(hs)
+        setup()


 if __name__ == '__main__':
--- a/synapse/app/synctl.py
+++ b/synapse/app/synctl.py
@@ -18,33 +18,29 @@ import sys
 import os
 import subprocess
 import signal
-import yaml

-SYNAPSE = ["python", "-B", "-m", "synapse.app.homeserver"]
+SYNAPSE = ["python", "-m", "synapse.app.homeserver"]

 CONFIGFILE = "homeserver.yaml"
+PIDFILE = "homeserver.pid"

 GREEN = "\x1b[1;32m"
 NORMAL = "\x1b[m"

-if not os.path.exists(CONFIGFILE):
-    sys.stderr.write(
-        "No config file found\n"
-        "To generate a config file, run '%s -c %s --generate-config"
-        " --server-name=<server name>'\n" % (
-            " ".join(SYNAPSE), CONFIGFILE
-        )
-    )
-    sys.exit(1)
-
-CONFIG = yaml.load(open(CONFIGFILE))
-PIDFILE = CONFIG["pid_file"]
-

 def start():
+    if not os.path.exists(CONFIGFILE):
+        sys.stderr.write(
+            "No config file found\n"
+            "To generate a config file, run '%s -c %s --generate-config"
+            " --server-name=<server name>'\n" % (
+                " ".join(SYNAPSE), CONFIGFILE
+            )
+        )
+        sys.exit(1)
    print "Starting ...",
    args = SYNAPSE
-    args.extend(["--daemonize", "-c", CONFIGFILE])
+    args.extend(["--daemonize", "-c", CONFIGFILE, "--pid-file", PIDFILE])
    subprocess.check_call(args)
    print GREEN + "started" + NORMAL

--- a/synapse/appservice/init.py
+++ b/synapse/appservice/init.py
@@ -1,226 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-from synapse.api.constants import EventTypes
-
-import logging
-import re
-
-logger = logging.getLogger(__name__)
-
-
-class ApplicationServiceState(object):
-    DOWN = "down"
-    UP = "up"
-
-
-class AppServiceTransaction(object):
-    """Represents an application service transaction."""
-
-    def __init__(self, service, id, events):
-        self.service = service
-        self.id = id
-        self.events = events
-
-    def send(self, as_api):
-        """Sends this transaction using the provided AS API interface.
-
-        Args:
-            as_api(ApplicationServiceApi): The API to use to send.
-        Returns:
-            A Deferred which resolves to True if the transaction was sent.
-        """
-        return as_api.push_bulk(
-            service=self.service,
-            events=self.events,
-            txn_id=self.id
-        )
-
-    def complete(self, store):
-        """Completes this transaction as successful.
-
-        Marks this transaction ID on the application service and removes the
-        transaction contents from the database.
-
-        Args:
-            store: The database store to operate on.
-        Returns:
-            A Deferred which resolves to True if the transaction was completed.
-        """
-        return store.complete_appservice_txn(
-            service=self.service,
-            txn_id=self.id
-        )
-
-
-class ApplicationService(object):
-    """Defines an application service. This definition is mostly what is
-    provided to the /register AS API.
-
-    Provides methods to check if this service is "interested" in events.
-    """
-    NS_USERS = "users"
-    NS_ALIASES = "aliases"
-    NS_ROOMS = "rooms"
-    # The ordering here is important as it is used to map database values (which
-    # are stored as ints representing the position in this list) to namespace
-    # values.
-    NS_LIST = [NS_USERS, NS_ALIASES, NS_ROOMS]
-
-    def __init__(self, token, url=None, namespaces=None, hs_token=None,
-                 sender=None, id=None):
-        self.token = token
-        self.url = url
-        self.hs_token = hs_token
-        self.sender = sender
-        self.namespaces = self._check_namespaces(namespaces)
-        self.id = id
-
-    def _check_namespaces(self, namespaces):
-        # Sanity check that it is of the form:
-        # {
-        #   users: [ {regex: "[A-z]+.*", exclusive: true}, ...],
-        #   aliases: [ {regex: "[A-z]+.*", exclusive: true}, ...],
-        #   rooms: [ {regex: "[A-z]+.*", exclusive: true}, ...],
-        # }
-        if not namespaces:
-            namespaces = {}
-
-        for ns in ApplicationService.NS_LIST:
-            if ns not in namespaces:
-                namespaces[ns] = []
-                continue
-
-            if type(namespaces[ns]) != list:
-                raise ValueError("Bad namespace value for '%s'" % ns)
-            for regex_obj in namespaces[ns]:
-                if not isinstance(regex_obj, dict):
-                    raise ValueError("Expected dict regex for ns '%s'" % ns)
-                if not isinstance(regex_obj.get("exclusive"), bool):
-                    raise ValueError(
-                        "Expected bool for 'exclusive' in ns '%s'" % ns
-                    )
-                if not isinstance(regex_obj.get("regex"), basestring):
-                    raise ValueError(
-                        "Expected string for 'regex' in ns '%s'" % ns
-                    )
-        return namespaces
-
-    def _matches_regex(self, test_string, namespace_key, return_obj=False):
-        if not isinstance(test_string, basestring):
-            logger.error(
-                "Expected a string to test regex against, but got %s",
-                test_string
-            )
-            return False
-
-        for regex_obj in self.namespaces[namespace_key]:
-            if re.match(regex_obj["regex"], test_string):
-                if return_obj:
-                    return regex_obj
-                return True
-        return False
-
-    def _is_exclusive(self, ns_key, test_string):
-        regex_obj = self._matches_regex(test_string, ns_key, return_obj=True)
-        if regex_obj:
-            return regex_obj["exclusive"]
-        return False
-
-    def _matches_user(self, event, member_list):
-        if (hasattr(event, "sender") and
-                self.is_interested_in_user(event.sender)):
-            return True
-        # also check m.room.member state key
-        if (hasattr(event, "type") and event.type == EventTypes.Member
-                and hasattr(event, "state_key")
-                and self.is_interested_in_user(event.state_key)):
-            return True
-        # check joined member events
-        for user_id in member_list:
-            if self.is_interested_in_user(user_id):
-                return True
-        return False
-
-    def _matches_room_id(self, event):
-        if hasattr(event, "room_id"):
-            return self.is_interested_in_room(event.room_id)
-        return False
-
-    def _matches_aliases(self, event, alias_list):
-        for alias in alias_list:
-            if self.is_interested_in_alias(alias):
-                return True
-        return False
-
-    def is_interested(self, event, restrict_to=None, aliases_for_event=None,
-                      member_list=None):
-        """Check if this service is interested in this event.
-
-        Args:
-            event(Event): The event to check.
-            restrict_to(str): The namespace to restrict regex tests to.
-            aliases_for_event(list): A list of all the known room aliases for
-            this event.
-            member_list(list): A list of all joined user_ids in this room.
-        Returns:
-            bool: True if this service would like to know about this event.
-        """
-        if aliases_for_event is None:
-            aliases_for_event = []
-        if member_list is None:
-            member_list = []
-
-        if restrict_to and restrict_to not in ApplicationService.NS_LIST:
-            # this is a programming error, so fail early and raise a general
-            # exception
-            raise Exception("Unexpected restrict_to value: %s". restrict_to)
-
-        if not restrict_to:
-            return (self._matches_user(event, member_list)
-                    or self._matches_aliases(event, aliases_for_event)
-                    or self._matches_room_id(event))
-        elif restrict_to == ApplicationService.NS_ALIASES:
-            return self._matches_aliases(event, aliases_for_event)
-        elif restrict_to == ApplicationService.NS_ROOMS:
-            return self._matches_room_id(event)
-        elif restrict_to == ApplicationService.NS_USERS:
-            return self._matches_user(event, member_list)
-
-    def is_interested_in_user(self, user_id):
-        return (
-            self._matches_regex(user_id, ApplicationService.NS_USERS)
-            or user_id == self.sender
-        )
-
-    def is_interested_in_alias(self, alias):
-        return self._matches_regex(alias, ApplicationService.NS_ALIASES)
-
-    def is_interested_in_room(self, room_id):
-        return self._matches_regex(room_id, ApplicationService.NS_ROOMS)
-
-    def is_exclusive_user(self, user_id):
-        return (
-            self._is_exclusive(ApplicationService.NS_USERS, user_id)
-            or user_id == self.sender
-        )
-
-    def is_exclusive_alias(self, alias):
-        return self._is_exclusive(ApplicationService.NS_ALIASES, alias)
-
-    def is_exclusive_room(self, room_id):
-        return self._is_exclusive(ApplicationService.NS_ROOMS, room_id)
-
-    def __str__(self):
-        return "ApplicationService: %s" % (self.__dict__,)
--- a/synapse/appservice/api.py
+++ b/synapse/appservice/api.py
@@ -1,112 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-from twisted.internet import defer
-
-from synapse.api.errors import CodeMessageException
-from synapse.http.client import SimpleHttpClient
-from synapse.events.utils import serialize_event
-
-import logging
-import urllib
-
-logger = logging.getLogger(__name__)
-
-
-class ApplicationServiceApi(SimpleHttpClient):
-    """This class manages HS -> AS communications, including querying and
-    pushing.
-    """
-
-    def __init__(self,  hs):
-        super(ApplicationServiceApi, self).__init__(hs)
-        self.clock = hs.get_clock()
-
-    @defer.inlineCallbacks
-    def query_user(self, service, user_id):
-        uri = service.url + ("/users/%s" % urllib.quote(user_id))
-        response = None
-        try:
-            response = yield self.get_json(uri, {
-                "access_token": service.hs_token
-            })
-            if response is not None:  # just an empty json object
-                defer.returnValue(True)
-        except CodeMessageException as e:
-            if e.code == 404:
-                defer.returnValue(False)
-                return
-            logger.warning("query_user to %s received %s", uri, e.code)
-        except Exception as ex:
-            logger.warning("query_user to %s threw exception %s", uri, ex)
-        defer.returnValue(False)
-
-    @defer.inlineCallbacks
-    def query_alias(self, service, alias):
-        uri = service.url + ("/rooms/%s" % urllib.quote(alias))
-        response = None
-        try:
-            response = yield self.get_json(uri, {
-                "access_token": service.hs_token
-            })
-            if response is not None:  # just an empty json object
-                defer.returnValue(True)
-        except CodeMessageException as e:
-            logger.warning("query_alias to %s received %s", uri, e.code)
-            if e.code == 404:
-                defer.returnValue(False)
-                return
-        except Exception as ex:
-            logger.warning("query_alias to %s threw exception %s", uri, ex)
-        defer.returnValue(False)
-
-    @defer.inlineCallbacks
-    def push_bulk(self, service, events, txn_id=None):
-        events = self._serialize(events)
-
-        if txn_id is None:
-            logger.warning("push_bulk: Missing txn ID sending events to %s",
-                           service.url)
-            txn_id = str(0)
-        txn_id = str(txn_id)
-
-        uri = service.url + ("/transactions/%s" %
-                             urllib.quote(txn_id))
-        try:
-            yield self.put_json(
-                uri=uri,
-                json_body={
-                    "events": events
-                },
-                args={
-                    "access_token": service.hs_token
-                })
-            defer.returnValue(True)
-            return
-        except CodeMessageException as e:
-            logger.warning("push_bulk to %s received %s", uri, e.code)
-        except Exception as ex:
-            logger.warning("push_bulk to %s threw exception %s", uri, ex)
-        defer.returnValue(False)
-
-    @defer.inlineCallbacks
-    def push(self, service, event, txn_id=None):
-        response = yield self.push_bulk(service, [event], txn_id)
-        defer.returnValue(response)
-
-    def _serialize(self, events):
-        time_now = self.clock.time_msec()
-        return [
-            serialize_event(e, time_now, as_client_event=True) for e in events
-        ]
--- a/synapse/appservice/scheduler.py
+++ b/synapse/appservice/scheduler.py
@@ -1,254 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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 module controls the reliability for application service transactions.
-
-The nominal flow through this module looks like:
-              __________
-1---ASa[e]-->|  Service |--> Queue ASa[f]
-2----ASb[e]->|  Queuer  |
-3--ASa[f]--->|__________|-----------+ ASa[e], ASb[e]
-                                    V
-      -````````-            +------------+
-      |````````|<--StoreTxn-|Transaction |
-      |Database|            | Controller |---> SEND TO AS
-      `--------`            +------------+
-What happens on SEND TO AS depends on the state of the Application Service:
- - If the AS is marked as DOWN, do nothing.
- - If the AS is marked as UP, send the transaction.
-     * SUCCESS : Increment where the AS is up to txn-wise and nuke the txn
-                 contents from the db.
-     * FAILURE : Marked AS as DOWN and start Recoverer.
-
-Recoverer attempts to recover ASes who have died. The flow for this looks like:
-                ,--------------------- backoff++ --------------.
-               V                                               |
-  START ---> Wait exp ------> Get oldest txn ID from ----> FAILURE
-             backoff           DB and try to send it
-                                 ^                |___________
-Mark AS as                       |                            V
-UP & quit           +---------- YES                       SUCCESS
-    |               |                                         |
-    NO <--- Have more txns? <------ Mark txn success & nuke <-+
-                                      from db; incr AS pos.
-                                         Reset backoff.
-
-This is all tied together by the AppServiceScheduler which DIs the required
-components.
-"""
-
-from synapse.appservice import ApplicationServiceState
-from twisted.internet import defer
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class AppServiceScheduler(object):
-    """ Public facing API for this module. Does the required DI to tie the
-    components together. This also serves as the "event_pool", which in this
-    case is a simple array.
-    """
-
-    def __init__(self, clock, store, as_api):
-        self.clock = clock
-        self.store = store
-        self.as_api = as_api
-
-        def create_recoverer(service, callback):
-            return _Recoverer(clock, store, as_api, service, callback)
-
-        self.txn_ctrl = _TransactionController(
-            clock, store, as_api, create_recoverer
-        )
-        self.queuer = _ServiceQueuer(self.txn_ctrl)
-
-    @defer.inlineCallbacks
-    def start(self):
-        logger.info("Starting appservice scheduler")
-        # check for any DOWN ASes and start recoverers for them.
-        recoverers = yield _Recoverer.start(
-            self.clock, self.store, self.as_api, self.txn_ctrl.on_recovered
-        )
-        self.txn_ctrl.add_recoverers(recoverers)
-
-    def submit_event_for_as(self, service, event):
-        self.queuer.enqueue(service, event)
-
-
-class _ServiceQueuer(object):
-    """Queues events for the same application service together, sending
-    transactions as soon as possible. Once a transaction is sent successfully,
-    this schedules any other events in the queue to run.
-    """
-
-    def __init__(self, txn_ctrl):
-        self.queued_events = {}  # dict of {service_id: [events]}
-        self.pending_requests = {}  # dict of {service_id: Deferred}
-        self.txn_ctrl = txn_ctrl
-
-    def enqueue(self, service, event):
-        # if this service isn't being sent something
-        if not self.pending_requests.get(service.id):
-            self._send_request(service, [event])
-        else:
-            # add to queue for this service
-            if service.id not in self.queued_events:
-                self.queued_events[service.id] = []
-            self.queued_events[service.id].append(event)
-
-    def _send_request(self, service, events):
-        # send request and add callbacks
-        d = self.txn_ctrl.send(service, events)
-        d.addBoth(self._on_request_finish)
-        d.addErrback(self._on_request_fail)
-        self.pending_requests[service.id] = d
-
-    def _on_request_finish(self, service):
-        self.pending_requests[service.id] = None
-        # if there are queued events, then send them.
-        if (service.id in self.queued_events
-                and len(self.queued_events[service.id]) > 0):
-            self._send_request(service, self.queued_events[service.id])
-            self.queued_events[service.id] = []
-
-    def _on_request_fail(self, err):
-        logger.error("AS request failed: %s", err)
-
-
-class _TransactionController(object):
-
-    def __init__(self, clock, store, as_api, recoverer_fn):
-        self.clock = clock
-        self.store = store
-        self.as_api = as_api
-        self.recoverer_fn = recoverer_fn
-        # keep track of how many recoverers there are
-        self.recoverers = []
-
-    @defer.inlineCallbacks
-    def send(self, service, events):
-        try:
-            txn = yield self.store.create_appservice_txn(
-                service=service,
-                events=events
-            )
-            service_is_up = yield self._is_service_up(service)
-            if service_is_up:
-                sent = yield txn.send(self.as_api)
-                if sent:
-                    txn.complete(self.store)
-                else:
-                    self._start_recoverer(service)
-        except Exception as e:
-            logger.exception(e)
-            self._start_recoverer(service)
-        # request has finished
-        defer.returnValue(service)
-
-    @defer.inlineCallbacks
-    def on_recovered(self, recoverer):
-        self.recoverers.remove(recoverer)
-        logger.info("Successfully recovered application service AS ID %s",
-                    recoverer.service.id)
-        logger.info("Remaining active recoverers: %s", len(self.recoverers))
-        yield self.store.set_appservice_state(
-            recoverer.service,
-            ApplicationServiceState.UP
-        )
-
-    def add_recoverers(self, recoverers):
-        for r in recoverers:
-            self.recoverers.append(r)
-        if len(recoverers) > 0:
-            logger.info("New active recoverers: %s", len(self.recoverers))
-
-    @defer.inlineCallbacks
-    def _start_recoverer(self, service):
-        yield self.store.set_appservice_state(
-            service,
-            ApplicationServiceState.DOWN
-        )
-        logger.info(
-            "Application service falling behind. Starting recoverer. AS ID %s",
-            service.id
-        )
-        recoverer = self.recoverer_fn(service, self.on_recovered)
-        self.add_recoverers([recoverer])
-        recoverer.recover()
-
-    @defer.inlineCallbacks
-    def _is_service_up(self, service):
-        state = yield self.store.get_appservice_state(service)
-        defer.returnValue(state == ApplicationServiceState.UP or state is None)
-
-
-class _Recoverer(object):
-
-    @staticmethod
-    @defer.inlineCallbacks
-    def start(clock, store, as_api, callback):
-        services = yield store.get_appservices_by_state(
-            ApplicationServiceState.DOWN
-        )
-        recoverers = [
-            _Recoverer(clock, store, as_api, s, callback) for s in services
-        ]
-        for r in recoverers:
-            logger.info("Starting recoverer for AS ID %s which was marked as "
-                        "DOWN", r.service.id)
-            r.recover()
-        defer.returnValue(recoverers)
-
-    def __init__(self, clock, store, as_api, service, callback):
-        self.clock = clock
-        self.store = store
-        self.as_api = as_api
-        self.service = service
-        self.callback = callback
-        self.backoff_counter = 1
-
-    def recover(self):
-        self.clock.call_later((2 ** self.backoff_counter), self.retry)
-
-    def _backoff(self):
-        # cap the backoff to be around 18h => (2^16) = 65536 secs
-        if self.backoff_counter < 16:
-            self.backoff_counter += 1
-        self.recover()
-
-    @defer.inlineCallbacks
-    def retry(self):
-        try:
-            txn = yield self.store.get_oldest_unsent_txn(self.service)
-            if txn:
-                logger.info("Retrying transaction %s for AS ID %s",
-                            txn.id, txn.service.id)
-                sent = yield txn.send(self.as_api)
-                if sent:
-                    yield txn.complete(self.store)
-                    # reset the backoff counter and retry immediately
-                    self.backoff_counter = 1
-                    yield self.retry()
-                else:
-                    self._backoff()
-            else:
-                self._set_service_recovered()
-        except Exception as e:
-            logger.exception(e)
-            self._backoff()
-
-    def _set_service_recovered(self):
-        self.callback(self)
--- a/synapse/config/_base.py
+++ b/synapse/config/_base.py
@@ -14,10 +14,9 @@
 # limitations under the License.

 import argparse
+import sys
 import os
 import yaml
-import sys
-from textwrap import dedent


 class ConfigError(Exception):
@@ -25,35 +24,8 @@ class ConfigError(Exception):


 class Config(object):
-
-    @staticmethod
-    def parse_size(value):
-        if isinstance(value, int) or isinstance(value, long):
-            return value
-        sizes = {"K": 1024, "M": 1024 * 1024}
-        size = 1
-        suffix = value[-1]
-        if suffix in sizes:
-            value = value[:-1]
-            size = sizes[suffix]
-        return int(value) * size
-
-    @staticmethod
-    def parse_duration(value):
-        if isinstance(value, int) or isinstance(value, long):
-            return value
-        second = 1000
-        hour = 60 * 60 * second
-        day = 24 * hour
-        week = 7 * day
-        year = 365 * day
-        sizes = {"s": second, "h": hour, "d": day, "w": week, "y": year}
-        size = 1
-        suffix = value[-1]
-        if suffix in sizes:
-            value = value[:-1]
-            size = sizes[suffix]
-        return int(value) * size
+    def __init__(self, args):
+        pass

    @staticmethod
    def abspath(file_path):
@@ -78,9 +50,8 @@ class Config(object):
            )
        return cls.abspath(file_path)

-    @classmethod
-    def ensure_directory(cls, dir_path):
-        dir_path = cls.abspath(dir_path)
+    @staticmethod
+    def ensure_directory(dir_path):
        if not os.path.exists(dir_path):
            os.makedirs(dir_path)
        if not os.path.isdir(dir_path):
@@ -104,130 +75,83 @@ class Config(object):
        with open(file_path) as file_stream:
            return yaml.load(file_stream)

-    def invoke_all(self, name, *args, **kargs):
-        results = []
-        for cls in type(self).mro():
-            if name in cls.__dict__:
-                results.append(getattr(cls, name)(self, *args, **kargs))
-        return results
+    @classmethod
+    def add_arguments(cls, parser):
+        pass

-    def generate_config(self, config_dir_path, server_name):
-        default_config = "# vim:ft=yaml\n"
-
-        default_config += "\n\n".join(dedent(conf) for conf in self.invoke_all(
-            "default_config", config_dir_path, server_name
-        ))
-
-        config = yaml.load(default_config)
-
-        return default_config, config
+    @classmethod
+    def generate_config(cls, args, config_dir_path):
+        pass

    @classmethod
    def load_config(cls, description, argv, generate_section=None):
-        obj = cls()
-
        config_parser = argparse.ArgumentParser(add_help=False)
        config_parser.add_argument(
            "-c", "--config-path",
-            action="append",
            metavar="CONFIG_FILE",
            help="Specify config file"
        )
        config_parser.add_argument(
            "--generate-config",
            action="store_true",
-            help="Generate a config file for the server name"
-        )
-        config_parser.add_argument(
-            "-H", "--server-name",
-            help="The server name to generate a config file for"
+            help="Generate config file"
        )
        config_args, remaining_args = config_parser.parse_known_args(argv)

        if config_args.generate_config:
            if not config_args.config_path:
                config_parser.error(
-                    "Must supply a config file.\nA config file can be automatically"
-                    " generated using \"--generate-config -h SERVER_NAME"
-                    " -c CONFIG-FILE\""
+                    "Must specify where to generate the config file"
                )
-
-            config_dir_path = os.path.dirname(config_args.config_path[0])
-            config_dir_path = os.path.abspath(config_dir_path)
-
-            server_name = config_args.server_name
-            if not server_name:
-                print "Must specify a server_name to a generate config for."
-                sys.exit(1)
-            (config_path,) = config_args.config_path
-            if not os.path.exists(config_dir_path):
-                os.makedirs(config_dir_path)
-            if os.path.exists(config_path):
-                print "Config file %r already exists" % (config_path,)
-                yaml_config = cls.read_config_file(config_path)
-                yaml_name = yaml_config["server_name"]
-                if server_name != yaml_name:
-                    print (
-                        "Config file %r has a different server_name: "
-                        " %r != %r" % (config_path, server_name, yaml_name)
-                    )
-                    sys.exit(1)
-                config_bytes, config = obj.generate_config(
-                    config_dir_path, server_name
-                )
-                config.update(yaml_config)
-                print "Generating any missing keys for %r" % (server_name,)
-                obj.invoke_all("generate_files", config)
-                sys.exit(0)
-            with open(config_path, "wb") as config_file:
-                config_bytes, config = obj.generate_config(
-                    config_dir_path, server_name
-                )
-                obj.invoke_all("generate_files", config)
-                config_file.write(config_bytes)
-                print (
-                    "A config file has been generated in %s for server name"
-                    " '%s' with corresponding SSL keys and self-signed"
-                    " certificates. Please review this file and customise it to"
-                    " your needs."
-                ) % (config_path, server_name)
-            print (
-                "If this server name is incorrect, you will need to regenerate"
-                " the SSL certificates"
-            )
-            sys.exit(0)
+            config_dir_path = os.path.dirname(config_args.config_path)
+            if os.path.exists(config_args.config_path):
+                defaults = cls.read_config_file(config_args.config_path)
+            else:
+                defaults = {}
+        else:
+            if config_args.config_path:
+                defaults = cls.read_config_file(config_args.config_path)
+            else:
+                defaults = {}

        parser = argparse.ArgumentParser(
            parents=[config_parser],
            description=description,
            formatter_class=argparse.RawDescriptionHelpFormatter,
        )
+        cls.add_arguments(parser)
+        parser.set_defaults(**defaults)

-        obj.invoke_all("add_arguments", parser)
        args = parser.parse_args(remaining_args)

-        if not config_args.config_path:
-            config_parser.error(
-                "Must supply a config file.\nA config file can be automatically"
-                " generated using \"--generate-config -h SERVER_NAME"
-                " -c CONFIG-FILE\""
+        if config_args.generate_config:
+            config_dir_path = os.path.dirname(config_args.config_path)
+            config_dir_path = os.path.abspath(config_dir_path)
+            if not os.path.exists(config_dir_path):
+                os.makedirs(config_dir_path)
+            cls.generate_config(args, config_dir_path)
+            config = {}
+            for key, value in vars(args).items():
+                if (key not in set(["config_path", "generate_config"])
+                        and value is not None):
+                    config[key] = value
+            with open(config_args.config_path, "w") as config_file:
+                # TODO(paul) it would be lovely if we wrote out vim- and emacs-
+                #   style mode markers into the file, to hint to people that
+                #   this is a YAML file.
+                yaml.dump(config, config_file, default_flow_style=False)
+            print (
+                "A config file has been generated in %s for server name"
+                " '%s' with corresponding SSL keys and self-signed"
+                " certificates. Please review this file and customise it to"
+                " your needs."
+            ) % (
+                config_args.config_path, config['server_name']
            )
+            print (
+                "If this server name is incorrect, you will need to regenerate"
+                " the SSL certificates"
+            )
+            sys.exit(0)

-        config_dir_path = os.path.dirname(config_args.config_path[0])
-        config_dir_path = os.path.abspath(config_dir_path)
-
-        specified_config = {}
-        for config_path in config_args.config_path:
-            yaml_config = cls.read_config_file(config_path)
-            specified_config.update(yaml_config)
-
-        server_name = specified_config["server_name"]
-        _, config = obj.generate_config(config_dir_path, server_name)
-        config.pop("log_config")
-        config.update(specified_config)
-
-        obj.invoke_all("read_config", config)
-
-        obj.invoke_all("read_arguments", args)
-
-        return obj
+        return cls(args)
--- a/synapse/config/appservice.py
+++ b/synapse/config/appservice.py
@@ -1,27 +0,0 @@
-# Copyright 2015 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.
-
-from ._base import Config
-
-
-class AppServiceConfig(Config):
-
-    def read_config(self, config):
-        self.app_service_config_files = config.get("app_service_config_files", [])
-
-    def default_config(cls, config_dir_path, server_name):
-        return """\
-        # A list of application service config file to use
-        app_service_config_files: []
-        """
--- a/synapse/config/captcha.py
+++ b/synapse/config/captcha.py
@@ -17,35 +17,35 @@ from ._base import Config

 class CaptchaConfig(Config):

-    def read_config(self, config):
-        self.recaptcha_private_key = config["recaptcha_private_key"]
-        self.recaptcha_public_key = config["recaptcha_public_key"]
-        self.enable_registration_captcha = config["enable_registration_captcha"]
-        # XXX: This is used for more than just captcha
+    def __init__(self, args):
+        super(CaptchaConfig, self).__init__(args)
+        self.recaptcha_private_key = args.recaptcha_private_key
+        self.enable_registration_captcha = args.enable_registration_captcha
        self.captcha_ip_origin_is_x_forwarded = (
-            config["captcha_ip_origin_is_x_forwarded"]
+            args.captcha_ip_origin_is_x_forwarded
        )
-        self.captcha_bypass_secret = config.get("captcha_bypass_secret")
+        self.captcha_bypass_secret = args.captcha_bypass_secret

-    def default_config(self, config_dir_path, server_name):
-        return """\
-        ## Captcha ##
-
-        # This Home Server's ReCAPTCHA public key.
-        recaptcha_private_key: "YOUR_PUBLIC_KEY"
-
-        # This Home Server's ReCAPTCHA private key.
-        recaptcha_public_key: "YOUR_PRIVATE_KEY"
-
-        # Enables ReCaptcha checks when registering, preventing signup
-        # unless a captcha is answered. Requires a valid ReCaptcha
-        # public/private key.
-        enable_registration_captcha: False
-
-        # When checking captchas, use the X-Forwarded-For (XFF) header
-        # as the client IP and not the actual client IP.
-        captcha_ip_origin_is_x_forwarded: False
-
-        # A secret key used to bypass the captcha test entirely.
-        #captcha_bypass_secret: "YOUR_SECRET_HERE"
-        """
+    @classmethod
+    def add_arguments(cls, parser):
+        super(CaptchaConfig, cls).add_arguments(parser)
+        group = parser.add_argument_group("recaptcha")
+        group.add_argument(
+            "--recaptcha-private-key", type=str, default="YOUR_PRIVATE_KEY",
+            help="The matching private key for the web client's public key."
+        )
+        group.add_argument(
+            "--enable-registration-captcha", type=bool, default=False,
+            help="Enables ReCaptcha checks when registering, preventing signup"
+            + " unless a captcha is answered. Requires a valid ReCaptcha "
+            + "public/private key."
+        )
+        group.add_argument(
+            "--captcha_ip_origin_is_x_forwarded", type=bool, default=False,
+            help="When checking captchas, use the X-Forwarded-For (XFF) header"
+            + " as the client IP and not the actual client IP."
+        )
+        group.add_argument(
+            "--captcha_bypass_secret", type=str,
+            help="A secret key used to bypass the captcha test entirely."
+        )
--- a/synapse/config/database.py
+++ b/synapse/config/database.py
@@ -14,66 +14,27 @@
 # limitations under the License.

 from ._base import Config
+import os


 class DatabaseConfig(Config):
-
-    def read_config(self, config):
-        self.event_cache_size = self.parse_size(
-            config.get("event_cache_size", "10K")
-        )
-
-        self.database_config = config.get("database")
-
-        if self.database_config is None:
-            self.database_config = {
-                "name": "sqlite3",
-                "args": {},
-            }
-
-        name = self.database_config.get("name", None)
-        if name == "psycopg2":
-            pass
-        elif name == "sqlite3":
-            self.database_config.setdefault("args", {}).update({
-                "cp_min": 1,
-                "cp_max": 1,
-                "check_same_thread": False,
-            })
+    def __init__(self, args):
+        super(DatabaseConfig, self).__init__(args)
+        if args.database_path == ":memory:":
+            self.database_path = ":memory:"
        else:
-            raise RuntimeError("Unsupported database type '%s'" % (name,))
+            self.database_path = self.abspath(args.database_path)

-        self.set_databasepath(config.get("database_path"))
-
-    def default_config(self, config, config_dir_path):
-        database_path = self.abspath("homeserver.db")
-        return """\
-        # Database configuration
-        database:
-          # The database engine name
-          name: "sqlite3"
-          # Arguments to pass to the engine
-          args:
-            # Path to the database
-            database: "%(database_path)s"
-
-        # Number of events to cache in memory.
-        event_cache_size: "10K"
-        """ % locals()
-
-    def read_arguments(self, args):
-        self.set_databasepath(args.database_path)
-
-    def set_databasepath(self, database_path):
-        if database_path != ":memory:":
-            database_path = self.abspath(database_path)
-        if self.database_config.get("name", None) == "sqlite3":
-            if database_path is not None:
-                self.database_config["args"]["database"] = database_path
-
-    def add_arguments(self, parser):
+    @classmethod
+    def add_arguments(cls, parser):
+        super(DatabaseConfig, cls).add_arguments(parser)
        db_group = parser.add_argument_group("database")
        db_group.add_argument(
-            "-d", "--database-path", metavar="SQLITE_DATABASE_PATH",
-            help="The path to a sqlite database to use."
+            "-d", "--database-path", default="homeserver.db",
+            help="The database name."
        )
+
+    @classmethod
+    def generate_config(cls, args, config_dir_path):
+        super(DatabaseConfig, cls).generate_config(args, config_dir_path)
+        args.database_path = os.path.abspath(args.database_path)
--- a/synapse/config/email.py
+++ b/synapse/config/email.py
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# Copyright 2014, 2015 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.
+
+from ._base import Config
+
+
+class EmailConfig(Config):
+
+    def __init__(self, args):
+        super(EmailConfig, self).__init__(args)
+        self.email_from_address = args.email_from_address
+        self.email_smtp_server = args.email_smtp_server
+
+    @classmethod
+    def add_arguments(cls, parser):
+        super(EmailConfig, cls).add_arguments(parser)
+        email_group = parser.add_argument_group("email")
+        email_group.add_argument(
+            "--email-from-address",
+            default="FROM@EXAMPLE.COM",
+            help="The address to send emails from (e.g. for password resets)."
+        )
+        email_group.add_argument(
+            "--email-smtp-server",
+            default="",
+            help=(
+                "The SMTP server to send emails from (e.g. for password"
+                " resets)."
+            )
+        )
--- a/synapse/config/homeserver.py
+++ b/synapse/config/homeserver.py
@@ -20,22 +20,16 @@ from .database import DatabaseConfig
 from .ratelimiting import RatelimitConfig
 from .repository import ContentRepositoryConfig
 from .captcha import CaptchaConfig
+from .email import EmailConfig
 from .voip import VoipConfig
-from .registration import RegistrationConfig
-from .metrics import MetricsConfig
-from .appservice import AppServiceConfig
-from .key import KeyConfig


 class HomeServerConfig(TlsConfig, ServerConfig, DatabaseConfig, LoggingConfig,
                       RatelimitConfig, ContentRepositoryConfig, CaptchaConfig,
-                       VoipConfig, RegistrationConfig,
-                       MetricsConfig, AppServiceConfig, KeyConfig,):
+                       EmailConfig, VoipConfig):
    pass


 if __name__ == '__main__':
    import sys
-    sys.stdout.write(
-        HomeServerConfig().generate_config(sys.argv[1], sys.argv[2])[0]
-    )
+    HomeServerConfig.load_config("Generate config", sys.argv[1:], "HomeServer")
--- a/synapse/config/key.py
+++ b/synapse/config/key.py
@@ -1,133 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 OpenMarket Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-from ._base import Config, ConfigError
-import syutil.crypto.signing_key
-from syutil.crypto.signing_key import (
-    is_signing_algorithm_supported, decode_verify_key_bytes
-)
-from syutil.base64util import decode_base64
-from synapse.util.stringutils import random_string
-
-
-class KeyConfig(Config):
-
-    def read_config(self, config):
-        self.signing_key = self.read_signing_key(config["signing_key_path"])
-        self.old_signing_keys = self.read_old_signing_keys(
-            config["old_signing_keys"]
-        )
-        self.key_refresh_interval = self.parse_duration(
-            config["key_refresh_interval"]
-        )
-        self.perspectives = self.read_perspectives(
-            config["perspectives"]
-        )
-
-    def default_config(self, config_dir_path, server_name):
-        base_key_name = os.path.join(config_dir_path, server_name)
-        return """\
-        ## Signing Keys ##
-
-        # Path to the signing key to sign messages with
-        signing_key_path: "%(base_key_name)s.signing.key"
-
-        # The keys that the server used to sign messages with but won't use
-        # to sign new messages. E.g. it has lost its private key
-        old_signing_keys: {}
-        #  "ed25519:auto":
-        #    # Base64 encoded public key
-        #    key: "The public part of your old signing key."
-        #    # Millisecond POSIX timestamp when the key expired.
-        #    expired_ts: 123456789123
-
-        # How long key response published by this server is valid for.
-        # Used to set the valid_until_ts in /key/v2 APIs.
-        # Determines how quickly servers will query to check which keys
-        # are still valid.
-        key_refresh_interval: "1d" # 1 Day.
-
-        # The trusted servers to download signing keys from.
-        perspectives:
-          servers:
-            "matrix.org":
-              verify_keys:
-                "ed25519:auto":
-                  key: "Noi6WqcDj0QmPxCNQqgezwTlBKrfqehY1u2FyWP9uYw"
-        """ % locals()
-
-    def read_perspectives(self, perspectives_config):
-        servers = {}
-        for server_name, server_config in perspectives_config["servers"].items():
-            for key_id, key_data in server_config["verify_keys"].items():
-                if is_signing_algorithm_supported(key_id):
-                    key_base64 = key_data["key"]
-                    key_bytes = decode_base64(key_base64)
-                    verify_key = decode_verify_key_bytes(key_id, key_bytes)
-                    servers.setdefault(server_name, {})[key_id] = verify_key
-        return servers
-
-    def read_signing_key(self, signing_key_path):
-        signing_keys = self.read_file(signing_key_path, "signing_key")
-        try:
-            return syutil.crypto.signing_key.read_signing_keys(
-                signing_keys.splitlines(True)
-            )
-        except Exception:
-            raise ConfigError(
-                "Error reading signing_key."
-                " Try running again with --generate-config"
-            )
-
-    def read_old_signing_keys(self, old_signing_keys):
-        keys = {}
-        for key_id, key_data in old_signing_keys.items():
-            if is_signing_algorithm_supported(key_id):
-                key_base64 = key_data["key"]
-                key_bytes = decode_base64(key_base64)
-                verify_key = decode_verify_key_bytes(key_id, key_bytes)
-                verify_key.expired_ts = key_data["expired_ts"]
-                keys[key_id] = verify_key
-            else:
-                raise ConfigError(
-                    "Unsupported signing algorithm for old key: %r" % (key_id,)
-                )
-        return keys
-
-    def generate_files(self, config):
-        signing_key_path = config["signing_key_path"]
-        if not os.path.exists(signing_key_path):
-            with open(signing_key_path, "w") as signing_key_file:
-                key_id = "a_" + random_string(4)
-                syutil.crypto.signing_key.write_signing_keys(
-                    signing_key_file,
-                    (syutil.crypto.signing_key.generate_signing_key(key_id),),
-                )
-        else:
-            signing_keys = self.read_file(signing_key_path, "signing_key")
-            if len(signing_keys.split("\n")[0].split()) == 1:
-                # handle keys in the old format.
-                key_id = "a_" + random_string(4)
-                key = syutil.crypto.signing_key.decode_signing_key_base64(
-                    syutil.crypto.signing_key.NACL_ED25519,
-                    key_id,
-                    signing_keys.split("\n")[0]
-                )
-                with open(signing_key_path, "w") as signing_key_file:
-                    syutil.crypto.signing_key.write_signing_keys(
-                        signing_key_file,
-                        (key,),
-                    )
--- a/synapse/config/logger.py
+++ b/synapse/config/logger.py
@@ -18,89 +18,25 @@ from synapse.util.logcontext import LoggingContextFilter
 from twisted.python.log import PythonLoggingObserver
 import logging
 import logging.config
-import yaml
-from string import Template
-import os
-
-
-DEFAULT_LOG_CONFIG = Template("""
-version: 1
-
-formatters:
-  precise:
-   format: '%(asctime)s - %(name)s - %(lineno)d - %(levelname)s - %(request)s\
- %(message)s'
-
-filters:
-  context:
-    (): synapse.util.logcontext.LoggingContextFilter
-    request: ""
-
-handlers:
-  file:
-    class: logging.handlers.RotatingFileHandler
-    formatter: precise
-    filename: ${log_file}
-    maxBytes: 104857600
-    backupCount: 10
-    filters: [context]
-    level: INFO
-  console:
-    class: logging.StreamHandler
-    formatter: precise
-
-loggers:
-    synapse:
-        level: INFO
-
-    synapse.storage.SQL:
-        level: INFO
-
-root:
-    level: INFO
-    handlers: [file, console]
-""")


 class LoggingConfig(Config):
+    def __init__(self, args):
+        super(LoggingConfig, self).__init__(args)
+        self.verbosity = int(args.verbose) if args.verbose else None
+        self.log_config = self.abspath(args.log_config)
+        self.log_file = self.abspath(args.log_file)

-    def read_config(self, config):
-        self.verbosity = config.get("verbose", 0)
-        self.log_config = self.abspath(config.get("log_config"))
-        self.log_file = self.abspath(config.get("log_file"))
-
-    def default_config(self, config_dir_path, server_name):
-        log_file = self.abspath("homeserver.log")
-        log_config = self.abspath(
-            os.path.join(config_dir_path, server_name + ".log.config")
-        )
-        return """
-        # Logging verbosity level.
-        verbose: 0
-
-        # File to write logging to
-        log_file: "%(log_file)s"
-
-        # A yaml python logging config file
-        log_config: "%(log_config)s"
-        """ % locals()
-
-    def read_arguments(self, args):
-        if args.verbose is not None:
-            self.verbosity = args.verbose
-        if args.log_config is not None:
-            self.log_config = args.log_config
-        if args.log_file is not None:
-            self.log_file = args.log_file
-
+    @classmethod
    def add_arguments(cls, parser):
+        super(LoggingConfig, cls).add_arguments(parser)
        logging_group = parser.add_argument_group("logging")
        logging_group.add_argument(
            '-v', '--verbose', dest="verbose", action='count',
            help="The verbosity level."
        )
        logging_group.add_argument(
-            '-f', '--log-file', dest="log_file",
+            '-f', '--log-file', dest="log_file", default="homeserver.log",
            help="File to log to."
        )
        logging_group.add_argument(
@@ -108,14 +44,6 @@ class LoggingConfig(Config):
            help="Python logging config file"
        )

-    def generate_files(self, config):
-        log_config = config.get("log_config")
-        if log_config and not os.path.exists(log_config):
-            with open(log_config, "wb") as log_config_file:
-                log_config_file.write(
-                    DEFAULT_LOG_CONFIG.substitute(log_file=config["log_file"])
-                )
-
    def setup_logging(self):
        log_format = (
            "%(asctime)s - %(name)s - %(lineno)d - %(levelname)s - %(request)s"
@@ -149,9 +77,9 @@ class LoggingConfig(Config):
            handler.addFilter(LoggingContextFilter(request=""))

            logger.addHandler(handler)
+            logger.info("Test")
        else:
-            with open(self.log_config, 'r') as f:
-                logging.config.dictConfig(yaml.load(f))
+            logging.config.fileConfig(self.log_config)

        observer = PythonLoggingObserver()
        observer.start()
--- a/synapse/config/metrics.py
+++ b/synapse/config/metrics.py
@@ -1,37 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-
-from ._base import Config
-
-
-class MetricsConfig(Config):
-    def read_config(self, config):
-        self.enable_metrics = config["enable_metrics"]
-        self.metrics_port = config.get("metrics_port")
-        self.metrics_bind_host = config.get("metrics_bind_host", "127.0.0.1")
-
-    def default_config(self, config_dir_path, server_name):
-        return """\
-        ## Metrics ###
-
-        # Enable collection and rendering of performance metrics
-        enable_metrics: False
-
-        # Separate port to accept metrics requests on
-        # metrics_port: 8081
-
-        # Which host to bind the metric listener to
-        # metrics_bind_host: 127.0.0.1
-        """
--- a/synapse/config/ratelimiting.py
+++ b/synapse/config/ratelimiting.py
@@ -17,42 +17,20 @@ from ._base import Config

 class RatelimitConfig(Config):

-    def read_config(self, config):
-        self.rc_messages_per_second = config["rc_messages_per_second"]
-        self.rc_message_burst_count = config["rc_message_burst_count"]
+    def __init__(self, args):
+        super(RatelimitConfig, self).__init__(args)
+        self.rc_messages_per_second = args.rc_messages_per_second
+        self.rc_message_burst_count = args.rc_message_burst_count

-        self.federation_rc_window_size = config["federation_rc_window_size"]
-        self.federation_rc_sleep_limit = config["federation_rc_sleep_limit"]
-        self.federation_rc_sleep_delay = config["federation_rc_sleep_delay"]
-        self.federation_rc_reject_limit = config["federation_rc_reject_limit"]
-        self.federation_rc_concurrent = config["federation_rc_concurrent"]
-
-    def default_config(self, config_dir_path, server_name):
-        return """\
-        ## Ratelimiting ##
-
-        # Number of messages a client can send per second
-        rc_messages_per_second: 0.2
-
-        # Number of message a client can send before being throttled
-        rc_message_burst_count: 10.0
-
-        # The federation window size in milliseconds
-        federation_rc_window_size: 1000
-
-        # The number of federation requests from a single server in a window
-        # before the server will delay processing the request.
-        federation_rc_sleep_limit: 10
-
-        # The duration in milliseconds to delay processing events from
-        # remote servers by if they go over the sleep limit.
-        federation_rc_sleep_delay: 500
-
-        # The maximum number of concurrent federation requests allowed
-        # from a single server
-        federation_rc_reject_limit: 50
-
-        # The number of federation requests to concurrently process from a
-        # single server
-        federation_rc_concurrent: 3
-        """
+    @classmethod
+    def add_arguments(cls, parser):
+        super(RatelimitConfig, cls).add_arguments(parser)
+        rc_group = parser.add_argument_group("ratelimiting")
+        rc_group.add_argument(
+            "--rc-messages-per-second", type=float, default=0.2,
+            help="number of messages a client can send per second"
+        )
+        rc_group.add_argument(
+            "--rc-message-burst-count", type=float, default=10,
+            help="number of message a client can send before being throttled"
+        )
--- a/synapse/config/registration.py
+++ b/synapse/config/registration.py
@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-
-from ._base import Config
-
-from synapse.util.stringutils import random_string_with_symbols
-
-from distutils.util import strtobool
-
-
-class RegistrationConfig(Config):
-
-    def read_config(self, config):
-        self.disable_registration = not bool(
-            strtobool(str(config["enable_registration"]))
-        )
-        if "disable_registration" in config:
-            self.disable_registration = bool(
-                strtobool(str(config["disable_registration"]))
-            )
-
-        self.registration_shared_secret = config.get("registration_shared_secret")
-
-    def default_config(self, config_dir, server_name):
-        registration_shared_secret = random_string_with_symbols(50)
-        return """\
-        ## Registration ##
-
-        # Enable registration for new users.
-        enable_registration: True
-
-        # 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"
-        """ % locals()
-
-    def add_arguments(self, parser):
-        reg_group = parser.add_argument_group("registration")
-        reg_group.add_argument(
-            "--enable-registration", action="store_true", default=None,
-            help="Enable registration for new users."
-        )
-
-    def read_arguments(self, args):
-        if args.enable_registration is not None:
-            self.disable_registration = not bool(
-                strtobool(str(args.enable_registration))
-            )
--- a/synapse/config/repository.py
+++ b/synapse/config/repository.py
@@ -17,20 +17,32 @@ from ._base import Config


 class ContentRepositoryConfig(Config):
-    def read_config(self, config):
-        self.max_upload_size = self.parse_size(config["max_upload_size"])
-        self.max_image_pixels = self.parse_size(config["max_image_pixels"])
-        self.media_store_path = self.ensure_directory(config["media_store_path"])
+    def __init__(self, args):
+        super(ContentRepositoryConfig, self).__init__(args)
+        self.max_upload_size = self.parse_size(args.max_upload_size)
+        self.max_image_pixels = self.parse_size(args.max_image_pixels)
+        self.media_store_path = self.ensure_directory(args.media_store_path)

-    def default_config(self, config_dir_path, server_name):
-        media_store = self.default_path("media_store")
-        return """
-        # Directory where uploaded images and attachments are stored.
-        media_store_path: "%(media_store)s"
+    def parse_size(self, string):
+        sizes = {"K": 1024, "M": 1024 * 1024}
+        size = 1
+        suffix = string[-1]
+        if suffix in sizes:
+            string = string[:-1]
+            size = sizes[suffix]
+        return int(string) * size

-        # The largest allowed upload size in bytes
-        max_upload_size: "10M"
-
-        # Maximum number of pixels that will be thumbnailed
-        max_image_pixels: "32M"
-        """ % locals()
+    @classmethod
+    def add_arguments(cls, parser):
+        super(ContentRepositoryConfig, cls).add_arguments(parser)
+        db_group = parser.add_argument_group("content_repository")
+        db_group.add_argument(
+            "--max-upload-size", default="10M"
+        )
+        db_group.add_argument(
+            "--media-store-path", default=cls.default_path("media_store")
+        )
+        db_group.add_argument(
+            "--max-image-pixels", default="32M",
+            help="Maximum number of pixels that will be thumbnailed"
+        )
--- a/synapse/config/server.py
+++ b/synapse/config/server.py
@@ -13,92 +13,110 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-from ._base import Config
+import os
+from ._base import Config, ConfigError
+import syutil.crypto.signing_key


 class ServerConfig(Config):
+    def __init__(self, args):
+        super(ServerConfig, self).__init__(args)
+        self.server_name = args.server_name
+        self.signing_key = self.read_signing_key(args.signing_key_path)
+        self.bind_port = args.bind_port
+        self.bind_host = args.bind_host
+        self.unsecure_port = args.unsecure_port
+        self.daemonize = args.daemonize
+        self.pid_file = self.abspath(args.pid_file)
+        self.webclient = True
+        self.manhole = args.manhole
+        self.no_tls = args.no_tls

-    def read_config(self, config):
-        self.server_name = config["server_name"]
-        self.bind_port = config["bind_port"]
-        self.bind_host = config["bind_host"]
-        self.unsecure_port = config["unsecure_port"]
-        self.manhole = config.get("manhole")
-        self.pid_file = self.abspath(config.get("pid_file"))
-        self.web_client = config["web_client"]
-        self.soft_file_limit = config["soft_file_limit"]
-        self.daemonize = config.get("daemonize")
-
-        # Attempt to guess the content_addr for the v0 content repostitory
-        content_addr = config.get("content_addr")
-        if not content_addr:
-            host = self.server_name
+        if not args.content_addr:
+            host = args.server_name
            if ':' not in host:
-                host = "%s:%d" % (host, self.unsecure_port)
+                host = "%s:%d" % (host, args.unsecure_port)
            else:
                host = host.split(':')[0]
-                host = "%s:%d" % (host, self.unsecure_port)
-            content_addr = "http://%s" % (host,)
+                host = "%s:%d" % (host, args.unsecure_port)
+            args.content_addr = "http://%s" % (host,)

-        self.content_addr = content_addr
+        self.content_addr = args.content_addr

-    def default_config(self, config_dir_path, server_name):
-        if ":" in server_name:
-            bind_port = int(server_name.split(":")[1])
-            unsecure_port = bind_port - 400
-        else:
-            bind_port = 8448
-            unsecure_port = 8008
-
-        pid_file = self.abspath("homeserver.pid")
-        return """\
-        ## Server ##
-
-        # The domain name of the server, with optional explicit port.
-        # This is used by remote servers to connect to this server,
-        # e.g. matrix.org, localhost:8080, etc.
-        server_name: "%(server_name)s"
-
-        # The port to listen for HTTPS requests on.
-        # For when matrix traffic is sent directly to synapse.
-        bind_port: %(bind_port)s
-
-        # The port to listen for HTTP requests on.
-        # For when matrix traffic passes through loadbalancer that unwraps TLS.
-        unsecure_port: %(unsecure_port)s
-
-        # Local interface to listen on.
-        # The empty string will cause synapse to listen on all interfaces.
-        bind_host: ""
-
-        # When running as a daemon, the file to store the pid in
-        pid_file: %(pid_file)s
-
-        # Whether to serve a web client from the HTTP/HTTPS root resource.
-        web_client: True
-
-        # Set the soft limit on the number of file descriptors synapse can use
-        # Zero is used to indicate synapse should set the soft limit to the
-        # hard limit.
-        soft_file_limit: 0
-
-        # Turn on the twisted telnet manhole service on localhost on the given
-        # port.
-        #manhole: 9000
-        """ % locals()
-
-    def read_arguments(self, args):
-        if args.manhole is not None:
-            self.manhole = args.manhole
-        if args.daemonize is not None:
-            self.daemonize = args.daemonize
-
-    def add_arguments(self, parser):
+    @classmethod
+    def add_arguments(cls, parser):
+        super(ServerConfig, cls).add_arguments(parser)
        server_group = parser.add_argument_group("server")
+        server_group.add_argument(
+            "-H", "--server-name", default="localhost",
+            help="The domain name of the server, with optional explicit port. "
+                 "This is used by remote servers to connect to this server, "
+                 "e.g. matrix.org, localhost:8080, etc."
+        )
+        server_group.add_argument("--signing-key-path",
+                                  help="The signing key to sign messages with")
+        server_group.add_argument("-p", "--bind-port", metavar="PORT",
+                                  type=int, help="https port to listen on",
+                                  default=8448)
+        server_group.add_argument("--unsecure-port", metavar="PORT",
+                                  type=int, help="http port to listen on",
+                                  default=8008)
+        server_group.add_argument("--bind-host", default="",
+                                  help="Local interface to listen on")
        server_group.add_argument("-D", "--daemonize", action='store_true',
-                                  default=None,
                                  help="Daemonize the home server")
+        server_group.add_argument('--pid-file', default="homeserver.pid",
+                                  help="When running as a daemon, the file to"
+                                  " store the pid in")
        server_group.add_argument("--manhole", metavar="PORT", dest="manhole",
                                  type=int,
                                  help="Turn on the twisted telnet manhole"
                                  " service on the given port.")
+        server_group.add_argument("--content-addr", default=None,
+                                  help="The host and scheme to use for the "
+                                  "content repository")
+        server_group.add_argument("--no-tls", action='store_true',
+                                  help="Don't bind to the https port.")
+
+    def read_signing_key(self, signing_key_path):
+        signing_keys = self.read_file(signing_key_path, "signing_key")
+        try:
+            return syutil.crypto.signing_key.read_signing_keys(
+                signing_keys.splitlines(True)
+            )
+        except Exception:
+            raise ConfigError(
+                "Error reading signing_key."
+                " Try running again with --generate-config"
+            )
+
+    @classmethod
+    def generate_config(cls, args, config_dir_path):
+        super(ServerConfig, cls).generate_config(args, config_dir_path)
+        base_key_name = os.path.join(config_dir_path, args.server_name)
+
+        args.pid_file = os.path.abspath(args.pid_file)
+
+        if not args.signing_key_path:
+            args.signing_key_path = base_key_name + ".signing.key"
+
+        if not os.path.exists(args.signing_key_path):
+            with open(args.signing_key_path, "w") as signing_key_file:
+                syutil.crypto.signing_key.write_signing_keys(
+                    signing_key_file,
+                    (syutil.crypto.signing_key.generate_singing_key("auto"),),
+                )
+        else:
+            signing_keys = cls.read_file(args.signing_key_path, "signing_key")
+            if len(signing_keys.split("\n")[0].split()) == 1:
+                # handle keys in the old format.
+                key = syutil.crypto.signing_key.decode_signing_key_base64(
+                    syutil.crypto.signing_key.NACL_ED25519,
+                    "auto",
+                    signing_keys.split("\n")[0]
+                )
+                with open(args.signing_key_path, "w") as signing_key_file:
+                    syutil.crypto.signing_key.write_signing_keys(
+                        signing_key_file,
+                        (key,),
+                    )
--- a/synapse/config/tls.py
+++ b/synapse/config/tls.py
@@ -23,44 +23,28 @@ GENERATE_DH_PARAMS = False


 class TlsConfig(Config):
-    def read_config(self, config):
+    def __init__(self, args):
+        super(TlsConfig, self).__init__(args)
        self.tls_certificate = self.read_tls_certificate(
-            config.get("tls_certificate_path")
+            args.tls_certificate_path
+        )
+        self.tls_private_key = self.read_tls_private_key(
+            args.tls_private_key_path
        )
-
-        self.no_tls = config.get("no_tls", False)
-
-        if self.no_tls:
-            self.tls_private_key = None
-        else:
-            self.tls_private_key = self.read_tls_private_key(
-                config.get("tls_private_key_path")
-            )
-
        self.tls_dh_params_path = self.check_file(
-            config.get("tls_dh_params_path"), "tls_dh_params"
+            args.tls_dh_params_path, "tls_dh_params"
        )

-    def default_config(self, config_dir_path, server_name):
-        base_key_name = os.path.join(config_dir_path, server_name)
-
-        tls_certificate_path = base_key_name + ".tls.crt"
-        tls_private_key_path = base_key_name + ".tls.key"
-        tls_dh_params_path = base_key_name + ".tls.dh"
-
-        return """\
-        # PEM encoded X509 certificate for TLS
-        tls_certificate_path: "%(tls_certificate_path)s"
-
-        # PEM encoded private key for TLS
-        tls_private_key_path: "%(tls_private_key_path)s"
-
-        # PEM dh parameters for ephemeral keys
-        tls_dh_params_path: "%(tls_dh_params_path)s"
-
-        # Don't bind to the https port
-        no_tls: False
-        """ % locals()
+    @classmethod
+    def add_arguments(cls, parser):
+        super(TlsConfig, cls).add_arguments(parser)
+        tls_group = parser.add_argument_group("tls")
+        tls_group.add_argument("--tls-certificate-path",
+                               help="PEM encoded X509 certificate for TLS")
+        tls_group.add_argument("--tls-private-key-path",
+                               help="PEM encoded private key for TLS")
+        tls_group.add_argument("--tls-dh-params-path",
+                               help="PEM dh parameters for ephemeral keys")

    def read_tls_certificate(self, cert_path):
        cert_pem = self.read_file(cert_path, "tls_certificate")
@@ -70,13 +54,22 @@ class TlsConfig(Config):
        private_key_pem = self.read_file(private_key_path, "tls_private_key")
        return crypto.load_privatekey(crypto.FILETYPE_PEM, private_key_pem)

-    def generate_files(self, config):
-        tls_certificate_path = config["tls_certificate_path"]
-        tls_private_key_path = config["tls_private_key_path"]
-        tls_dh_params_path = config["tls_dh_params_path"]
+    @classmethod
+    def generate_config(cls, args, config_dir_path):
+        super(TlsConfig, cls).generate_config(args, config_dir_path)
+        base_key_name = os.path.join(config_dir_path, args.server_name)

-        if not os.path.exists(tls_private_key_path):
-            with open(tls_private_key_path, "w") as private_key_file:
+        if args.tls_certificate_path is None:
+            args.tls_certificate_path = base_key_name + ".tls.crt"
+
+        if args.tls_private_key_path is None:
+            args.tls_private_key_path = base_key_name + ".tls.key"
+
+        if args.tls_dh_params_path is None:
+            args.tls_dh_params_path = base_key_name + ".tls.dh"
+
+        if not os.path.exists(args.tls_private_key_path):
+            with open(args.tls_private_key_path, "w") as private_key_file:
                tls_private_key = crypto.PKey()
                tls_private_key.generate_key(crypto.TYPE_RSA, 2048)
                private_key_pem = crypto.dump_privatekey(
@@ -84,17 +77,17 @@ class TlsConfig(Config):
                )
                private_key_file.write(private_key_pem)
        else:
-            with open(tls_private_key_path) as private_key_file:
+            with open(args.tls_private_key_path) as private_key_file:
                private_key_pem = private_key_file.read()
                tls_private_key = crypto.load_privatekey(
                    crypto.FILETYPE_PEM, private_key_pem
                )

-        if not os.path.exists(tls_certificate_path):
-            with open(tls_certificate_path, "w") as certifcate_file:
+        if not os.path.exists(args.tls_certificate_path):
+            with open(args.tls_certificate_path, "w") as certifcate_file:
                cert = crypto.X509()
                subject = cert.get_subject()
-                subject.CN = config["server_name"]
+                subject.CN = args.server_name

                cert.set_serial_number(1000)
                cert.gmtime_adj_notBefore(0)
@@ -108,16 +101,16 @@ class TlsConfig(Config):

                certifcate_file.write(cert_pem)

-        if not os.path.exists(tls_dh_params_path):
+        if not os.path.exists(args.tls_dh_params_path):
            if GENERATE_DH_PARAMS:
                subprocess.check_call([
                    "openssl", "dhparam",
                    "-outform", "PEM",
-                    "-out", tls_dh_params_path,
+                    "-out", args.tls_dh_params_path,
                    "2048"
                ])
            else:
-                with open(tls_dh_params_path, "w") as dh_params_file:
+                with open(args.tls_dh_params_path, "w") as dh_params_file:
                    dh_params_file.write(
                        "2048-bit DH parameters taken from rfc3526\n"
                        "-----BEGIN DH PARAMETERS-----\n"
--- a/synapse/config/voip.py
+++ b/synapse/config/voip.py
@@ -17,21 +17,28 @@ from ._base import Config

 class VoipConfig(Config):

-    def read_config(self, config):
-        self.turn_uris = config.get("turn_uris", [])
-        self.turn_shared_secret = config["turn_shared_secret"]
-        self.turn_user_lifetime = self.parse_duration(config["turn_user_lifetime"])
+    def __init__(self, args):
+        super(VoipConfig, self).__init__(args)
+        self.turn_uris = args.turn_uris
+        self.turn_shared_secret = args.turn_shared_secret
+        self.turn_user_lifetime = args.turn_user_lifetime

-    def default_config(self, config_dir_path, server_name):
-        return """\
-        ## Turn ##
-
-        # The public URIs of the TURN server to give to clients
-        turn_uris: []
-
-        # The shared secret used to compute passwords for the TURN server
-        turn_shared_secret: "YOUR_SHARED_SECRET"
-
-        # How long generated TURN credentials last
-        turn_user_lifetime: "1h"
-        """
+    @classmethod
+    def add_arguments(cls, parser):
+        super(VoipConfig, cls).add_arguments(parser)
+        group = parser.add_argument_group("voip")
+        group.add_argument(
+            "--turn-uris", type=str, default=None,
+            help="The public URIs of the TURN server to give to clients"
+        )
+        group.add_argument(
+            "--turn-shared-secret", type=str, default=None,
+            help=(
+                "The shared secret used to compute passwords for the TURN"
+                " server"
+            )
+        )
+        group.add_argument(
+            "--turn-user-lifetime", type=int, default=(1000 * 60 * 60),
+            help="How long generated TURN credentials last, in ms"
+        )
--- a/synapse/crypto/context_factory.py
+++ b/synapse/crypto/context_factory.py
@@ -38,10 +38,7 @@ class ServerContextFactory(ssl.ContextFactory):
            logger.exception("Failed to enable eliptic curve for TLS")
        context.set_options(SSL.OP_NO_SSLv2 | SSL.OP_NO_SSLv3)
        context.use_certificate(config.tls_certificate)
-
-        if not config.no_tls:
-            context.use_privatekey(config.tls_private_key)
-
+        context.use_privatekey(config.tls_private_key)
        context.load_tmp_dh(config.tls_dh_params_path)
        context.set_cipher_list("!ADH:HIGH+kEDH:!AECDH:HIGH+kEECDH")

--- a/synapse/crypto/keyclient.py
+++ b/synapse/crypto/keyclient.py
@@ -18,51 +18,37 @@ from twisted.web.http import HTTPClient
 from twisted.internet.protocol import Factory
 from twisted.internet import defer, reactor
 from synapse.http.endpoint import matrix_federation_endpoint
-from synapse.util.logcontext import (
-    preserve_context_over_fn, preserve_context_over_deferred
-)
-import simplejson as json
+from synapse.util.logcontext import PreserveLoggingContext
+import json
 import logging


 logger = logging.getLogger(__name__)

-KEY_API_V1 = b"/_matrix/key/v1/"
-

@defer.inlineCallbacks
-def fetch_server_key(server_name, ssl_context_factory, path=KEY_API_V1):
+def fetch_server_key(server_name, ssl_context_factory):
    """Fetch the keys for a remote server."""

    factory = SynapseKeyClientFactory()
-    factory.path = path
    endpoint = matrix_federation_endpoint(
        reactor, server_name, ssl_context_factory, timeout=30
    )

    for i in range(5):
        try:
-            protocol = yield preserve_context_over_fn(
-                endpoint.connect, factory
-            )
-            server_response, server_certificate = yield preserve_context_over_deferred(
-                protocol.remote_key
-            )
-            defer.returnValue((server_response, server_certificate))
-            return
-        except SynapseKeyClientError as e:
-            logger.exception("Error getting key for %r" % (server_name,))
-            if e.status.startswith("4"):
-                # Don't retry for 4xx responses.
-                raise IOError("Cannot get key for %r" % server_name)
+            with PreserveLoggingContext():
+                protocol = yield endpoint.connect(factory)
+                server_response, server_certificate = yield protocol.remote_key
+                defer.returnValue((server_response, server_certificate))
+                return
        except Exception as e:
            logger.exception(e)
-    raise IOError("Cannot get key for %r" % server_name)
+    raise IOError("Cannot get key for %s" % server_name)


 class SynapseKeyClientError(Exception):
    """The key wasn't retrieved from the remote server."""
-    status = None
    pass


@@ -75,59 +61,42 @@ class SynapseKeyClientProtocol(HTTPClient):

    def __init__(self):
        self.remote_key = defer.Deferred()
-        self.host = None

    def connectionMade(self):
-        self.host = self.transport.getHost()
-        logger.debug("Connected to %s", self.host)
-        self.sendCommand(b"GET", self.path)
+        logger.debug("Connected to %s", self.transport.getHost())
+        self.sendCommand(b"GET", b"/_matrix/key/v1/")
        self.endHeaders()
        self.timer = reactor.callLater(
            self.timeout,
            self.on_timeout
        )

-    def errback(self, error):
-        if not self.remote_key.called:
-            self.remote_key.errback(error)
-
-    def callback(self, result):
-        if not self.remote_key.called:
-            self.remote_key.callback(result)
-
    def handleStatus(self, version, status, message):
        if status != b"200":
-            # logger.info("Non-200 response from %s: %s %s",
+            #logger.info("Non-200 response from %s: %s %s",
            #            self.transport.getHost(), status, message)
-            error = SynapseKeyClientError(
-                "Non-200 response %r from %r" % (status, self.host)
-            )
-            error.status = status
-            self.errback(error)
            self.transport.abortConnection()

    def handleResponse(self, response_body_bytes):
        try:
            json_response = json.loads(response_body_bytes)
        except ValueError:
-            # logger.info("Invalid JSON response from %s",
+            #logger.info("Invalid JSON response from %s",
            #            self.transport.getHost())
            self.transport.abortConnection()
            return

        certificate = self.transport.getPeerCertificate()
-        self.callback((json_response, certificate))
+        self.remote_key.callback((json_response, certificate))
        self.transport.abortConnection()
        self.timer.cancel()

    def on_timeout(self):
-        logger.debug("Timeout waiting for response from %s", self.host)
-        self.errback(IOError("Timeout waiting for response"))
+        logger.debug("Timeout waiting for response from %s",
+                     self.transport.getHost())
+        self.remote_key.errback(IOError("Timeout waiting for response"))
        self.transport.abortConnection()


 class SynapseKeyClientFactory(Factory):
-    def protocol(self):
-        protocol = SynapseKeyClientProtocol()
-        protocol.path = self.path
-        return protocol
+    protocol = SynapseKeyClientProtocol
--- a/synapse/crypto/keyring.py
+++ b/synapse/crypto/keyring.py
@@ -15,23 +15,15 @@

 from synapse.crypto.keyclient import fetch_server_key
 from twisted.internet import defer
-from syutil.crypto.jsonsign import (
-    verify_signed_json, signature_ids, sign_json, encode_canonical_json
-)
+from syutil.crypto.jsonsign import verify_signed_json, signature_ids
 from syutil.crypto.signing_key import (
    is_signing_algorithm_supported, decode_verify_key_bytes
 )
 from syutil.base64util import decode_base64, encode_base64
 from synapse.api.errors import SynapseError, Codes

-from synapse.util.retryutils import get_retry_limiter
-
-from synapse.util.async import ObservableDeferred
-
 from OpenSSL import crypto

-import urllib
-import hashlib
 import logging


@@ -42,13 +34,8 @@ class Keyring(object):
    def __init__(self, hs):
        self.store = hs.get_datastore()
        self.clock = hs.get_clock()
-        self.client = hs.get_http_client()
-        self.config = hs.get_config()
-        self.perspective_servers = self.config.perspectives
        self.hs = hs

-        self.key_downloads = {}
-
    @defer.inlineCallbacks
    def verify_json_for_server(self, server_name, json_object):
        logger.debug("Verifying for %s", server_name)
@@ -61,27 +48,18 @@ class Keyring(object):
            )
        try:
            verify_key = yield self.get_server_verify_key(server_name, key_ids)
-        except IOError as e:
-            logger.warn(
-                "Got IOError when downloading keys for %s: %s %s",
-                server_name, type(e).__name__, str(e.message),
-            )
+        except IOError:
            raise SynapseError(
                502,
                "Error downloading keys for %s" % (server_name,),
                Codes.UNAUTHORIZED,
            )
-        except Exception as e:
-            logger.warn(
-                "Got Exception when downloading keys for %s: %s %s",
-                server_name, type(e).__name__, str(e.message),
-            )
+        except:
            raise SynapseError(
                401,
                "No key for %s with id %s" % (server_name, key_ids),
                Codes.UNAUTHORIZED,
            )
-
        try:
            verify_signed_json(json_object, server_name, verify_key)
        except:
@@ -96,299 +74,20 @@ class Keyring(object):
    @defer.inlineCallbacks
    def get_server_verify_key(self, server_name, key_ids):
        """Finds a verification key for the server with one of the key ids.
-        Trys to fetch the key from a trusted perspective server first.
        Args:
-            server_name(str): The name of the server to fetch a key for.
+            server_name (str): The name of the server to fetch a key for.
            keys_ids (list of str): The key_ids to check for.
        """
+
+        # Check the datastore to see if we have one cached.
        cached = yield self.store.get_server_verify_keys(server_name, key_ids)

        if cached:
            defer.returnValue(cached[0])
            return

-        download = self.key_downloads.get(server_name)
-
-        if download is None:
-            download = self._get_server_verify_key_impl(server_name, key_ids)
-            download = ObservableDeferred(
-                download,
-                consumeErrors=True
-            )
-            self.key_downloads[server_name] = download
-
-            @download.addBoth
-            def callback(ret):
-                del self.key_downloads[server_name]
-                return ret
-
-        r = yield download.observe()
-        defer.returnValue(r)
-
-    @defer.inlineCallbacks
-    def _get_server_verify_key_impl(self, server_name, key_ids):
-        keys = None
-
-        @defer.inlineCallbacks
-        def get_key(perspective_name, perspective_keys):
-            try:
-                result = yield self.get_server_verify_key_v2_indirect(
-                    server_name, key_ids, perspective_name, perspective_keys
-                )
-                defer.returnValue(result)
-            except Exception as e:
-                logging.info(
-                    "Unable to getting key %r for %r from %r: %s %s",
-                    key_ids, server_name, perspective_name,
-                    type(e).__name__, str(e.message),
-                )
-
-        perspective_results = yield defer.gatherResults([
-            get_key(p_name, p_keys)
-            for p_name, p_keys in self.perspective_servers.items()
-        ])
-
-        for results in perspective_results:
-            if results is not None:
-                keys = results
-
-        limiter = yield get_retry_limiter(
-            server_name,
-            self.clock,
-            self.store,
-        )
-
-        with limiter:
-            if not keys:
-                try:
-                    keys = yield self.get_server_verify_key_v2_direct(
-                        server_name, key_ids
-                    )
-                except Exception as e:
-                    logging.info(
-                        "Unable to getting key %r for %r directly: %s %s",
-                        key_ids, server_name,
-                        type(e).__name__, str(e.message),
-                    )
-
-            if not keys:
-                keys = yield self.get_server_verify_key_v1_direct(
-                    server_name, key_ids
-                )
-
-        for key_id in key_ids:
-            if key_id in keys:
-                defer.returnValue(keys[key_id])
-                return
-        raise ValueError("No verification key found for given key ids")
-
-    @defer.inlineCallbacks
-    def get_server_verify_key_v2_indirect(self, server_name, key_ids,
-                                          perspective_name,
-                                          perspective_keys):
-        limiter = yield get_retry_limiter(
-            perspective_name, self.clock, self.store
-        )
-
-        with limiter:
-            # TODO(mark): Set the minimum_valid_until_ts to that needed by
-            # the events being validated or the current time if validating
-            # an incoming request.
-            query_response = yield self.client.post_json(
-                destination=perspective_name,
-                path=b"/_matrix/key/v2/query",
-                data={
-                    u"server_keys": {
-                        server_name: {
-                            key_id: {
-                                u"minimum_valid_until_ts": 0
-                            } for key_id in key_ids
-                        }
-                    }
-                },
-            )
-
-        keys = {}
-
-        responses = query_response["server_keys"]
-
-        for response in responses:
-            if (u"signatures" not in response
-                    or perspective_name not in response[u"signatures"]):
-                raise ValueError(
-                    "Key response not signed by perspective server"
-                    " %r" % (perspective_name,)
-                )
-
-            verified = False
-            for key_id in response[u"signatures"][perspective_name]:
-                if key_id in perspective_keys:
-                    verify_signed_json(
-                        response,
-                        perspective_name,
-                        perspective_keys[key_id]
-                    )
-                    verified = True
-
-            if not verified:
-                logging.info(
-                    "Response from perspective server %r not signed with a"
-                    " known key, signed with: %r, known keys: %r",
-                    perspective_name,
-                    list(response[u"signatures"][perspective_name]),
-                    list(perspective_keys)
-                )
-                raise ValueError(
-                    "Response not signed with a known key for perspective"
-                    " server %r" % (perspective_name,)
-                )
-
-            response_keys = yield self.process_v2_response(
-                server_name, perspective_name, response
-            )
-
-            keys.update(response_keys)
-
-        yield self.store_keys(
-            server_name=server_name,
-            from_server=perspective_name,
-            verify_keys=keys,
-        )
-
-        defer.returnValue(keys)
-
-    @defer.inlineCallbacks
-    def get_server_verify_key_v2_direct(self, server_name, key_ids):
-
-        keys = {}
-
-        for requested_key_id in key_ids:
-            if requested_key_id in keys:
-                continue
-
-            (response, tls_certificate) = yield fetch_server_key(
-                server_name, self.hs.tls_context_factory,
-                path=(b"/_matrix/key/v2/server/%s" % (
-                    urllib.quote(requested_key_id),
-                )).encode("ascii"),
-            )
-
-            if (u"signatures" not in response
-                    or server_name not in response[u"signatures"]):
-                raise ValueError("Key response not signed by remote server")
-
-            if "tls_fingerprints" not in response:
-                raise ValueError("Key response missing TLS fingerprints")
-
-            certificate_bytes = crypto.dump_certificate(
-                crypto.FILETYPE_ASN1, tls_certificate
-            )
-            sha256_fingerprint = hashlib.sha256(certificate_bytes).digest()
-            sha256_fingerprint_b64 = encode_base64(sha256_fingerprint)
-
-            response_sha256_fingerprints = set()
-            for fingerprint in response[u"tls_fingerprints"]:
-                if u"sha256" in fingerprint:
-                    response_sha256_fingerprints.add(fingerprint[u"sha256"])
-
-            if sha256_fingerprint_b64 not in response_sha256_fingerprints:
-                raise ValueError("TLS certificate not allowed by fingerprints")
-
-            response_keys = yield self.process_v2_response(
-                server_name=server_name,
-                from_server=server_name,
-                requested_id=requested_key_id,
-                response_json=response,
-            )
-
-            keys.update(response_keys)
-
-        yield self.store_keys(
-            server_name=server_name,
-            from_server=server_name,
-            verify_keys=keys,
-        )
-
-        defer.returnValue(keys)
-
-    @defer.inlineCallbacks
-    def process_v2_response(self, server_name, from_server, response_json,
-                            requested_id=None):
-        time_now_ms = self.clock.time_msec()
-        response_keys = {}
-        verify_keys = {}
-        for key_id, key_data in response_json["verify_keys"].items():
-            if is_signing_algorithm_supported(key_id):
-                key_base64 = key_data["key"]
-                key_bytes = decode_base64(key_base64)
-                verify_key = decode_verify_key_bytes(key_id, key_bytes)
-                verify_key.time_added = time_now_ms
-                verify_keys[key_id] = verify_key
-
-        old_verify_keys = {}
-        for key_id, key_data in response_json["old_verify_keys"].items():
-            if is_signing_algorithm_supported(key_id):
-                key_base64 = key_data["key"]
-                key_bytes = decode_base64(key_base64)
-                verify_key = decode_verify_key_bytes(key_id, key_bytes)
-                verify_key.expired = key_data["expired_ts"]
-                verify_key.time_added = time_now_ms
-                old_verify_keys[key_id] = verify_key
-
-        for key_id in response_json["signatures"].get(server_name, {}):
-            if key_id not in response_json["verify_keys"]:
-                raise ValueError(
-                    "Key response must include verification keys for all"
-                    " signatures"
-                )
-            if key_id in verify_keys:
-                verify_signed_json(
-                    response_json,
-                    server_name,
-                    verify_keys[key_id]
-                )
-
-        signed_key_json = sign_json(
-            response_json,
-            self.config.server_name,
-            self.config.signing_key[0],
-        )
-
-        signed_key_json_bytes = encode_canonical_json(signed_key_json)
-        ts_valid_until_ms = signed_key_json[u"valid_until_ts"]
-
-        updated_key_ids = set()
-        if requested_id is not None:
-            updated_key_ids.add(requested_id)
-        updated_key_ids.update(verify_keys)
-        updated_key_ids.update(old_verify_keys)
-
-        response_keys.update(verify_keys)
-        response_keys.update(old_verify_keys)
-
-        for key_id in updated_key_ids:
-            yield self.store.store_server_keys_json(
-                server_name=server_name,
-                key_id=key_id,
-                from_server=server_name,
-                ts_now_ms=time_now_ms,
-                ts_expires_ms=ts_valid_until_ms,
-                key_json_bytes=signed_key_json_bytes,
-            )
-
-        defer.returnValue(response_keys)
-
-        raise ValueError("No verification key found for given key ids")
-
-    @defer.inlineCallbacks
-    def get_server_verify_key_v1_direct(self, server_name, key_ids):
-        """Finds a verification key for the server with one of the key ids.
-        Args:
-            server_name (str): The name of the server to fetch a key for.
-            keys_ids (list of str): The key_ids to check for.
-        """
-
        # Try to fetch the key from the remote server.
+        # TODO(markjh): Ratelimit requests to a given server.

        (response, tls_certificate) = yield fetch_server_key(
            server_name, self.hs.tls_context_factory
@@ -412,16 +111,11 @@ class Keyring(object):
        if encode_base64(x509_certificate_bytes) != tls_certificate_b64:
            raise ValueError("TLS certificate doesn't match")

-        # Cache the result in the datastore.
-
-        time_now_ms = self.clock.time_msec()
-
        verify_keys = {}
        for key_id, key_base64 in response["verify_keys"].items():
            if is_signing_algorithm_supported(key_id):
                key_bytes = decode_base64(key_base64)
                verify_key = decode_verify_key_bytes(key_id, key_bytes)
-                verify_key.time_added = time_now_ms
                verify_keys[key_id] = verify_key

        for key_id in response["signatures"][server_name]:
@@ -437,6 +131,10 @@ class Keyring(object):
                    verify_keys[key_id]
                )

+        # Cache the result in the datastore.
+
+        time_now_ms = self.clock.time_msec()
+
        yield self.store.store_server_certificate(
            server_name,
            server_name,
@@ -444,26 +142,14 @@ class Keyring(object):
            tls_certificate,
        )

-        yield self.store_keys(
-            server_name=server_name,
-            from_server=server_name,
-            verify_keys=verify_keys,
-        )
-
-        defer.returnValue(verify_keys)
-
-    @defer.inlineCallbacks
-    def store_keys(self, server_name, from_server, verify_keys):
-        """Store a collection of verify keys for a given server
-        Args:
-            server_name(str): The name of the server the keys are for.
-            from_server(str): The server the keys were downloaded from.
-            verify_keys(dict): A mapping of key_id to VerifyKey.
-        Returns:
-            A deferred that completes when the keys are stored.
-        """
        for key_id, key in verify_keys.items():
-            # TODO(markjh): Store whether the keys have expired.
            yield self.store.store_server_verify_key(
-                server_name, server_name, key.time_added, key
+                server_name, server_name, time_now_ms, key
            )
+
+        for key_id in key_ids:
+            if key_id in verify_keys:
+                defer.returnValue(verify_keys[key_id])
+                return
+
+        raise ValueError("No verification key found for given key ids")
--- a/synapse/events/init.py
+++ b/synapse/events/init.py
@@ -13,12 +13,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-from synapse.util.frozenutils import freeze
+from synapse.util.frozenutils import freeze, unfreeze


 class _EventInternalMetadata(object):
    def __init__(self, internal_metadata_dict):
-        self.__dict__ = dict(internal_metadata_dict)
+        self.__dict__ = internal_metadata_dict

    def get_dict(self):
        return dict(self.__dict__)
@@ -46,10 +46,9 @@ def _event_dict_property(key):

 class EventBase(object):
    def __init__(self, event_dict, signatures={}, unsigned={},
-                 internal_metadata_dict={}, rejected_reason=None):
+                 internal_metadata_dict={}):
        self.signatures = signatures
        self.unsigned = unsigned
-        self.rejected_reason = rejected_reason

        self._event_dict = event_dict

@@ -78,7 +77,7 @@ class EventBase(object):
        return self.content["membership"]

    def is_state(self):
-        return hasattr(self, "state_key") and self.state_key is not None
+        return hasattr(self, "state_key")

    def get_dict(self):
        d = dict(self._event_dict)
@@ -110,7 +109,7 @@ class EventBase(object):


 class FrozenEvent(EventBase):
-    def __init__(self, event_dict, internal_metadata_dict={}, rejected_reason=None):
+    def __init__(self, event_dict, internal_metadata_dict={}):
        event_dict = dict(event_dict)

        # Signatures is a dict of dicts, and this is faster than doing a
@@ -129,7 +128,6 @@ class FrozenEvent(EventBase):
            signatures=signatures,
            unsigned=unsigned,
            internal_metadata_dict=internal_metadata_dict,
-            rejected_reason=rejected_reason,
        )

    @staticmethod
@@ -142,6 +140,10 @@ class FrozenEvent(EventBase):

        return e

+    def get_dict(self):
+        # We need to unfreeze what we return
+        return unfreeze(super(FrozenEvent, self).get_dict())
+
    def __str__(self):
        return self.__repr__()

--- a/synapse/events/builder.py
+++ b/synapse/events/builder.py
@@ -23,15 +23,14 @@ import copy


 class EventBuilder(EventBase):
-    def __init__(self, key_values={}, internal_metadata_dict={}):
+    def __init__(self, key_values={}):
        signatures = copy.deepcopy(key_values.pop("signatures", {}))
        unsigned = copy.deepcopy(key_values.pop("unsigned", {}))

        super(EventBuilder, self).__init__(
            key_values,
            signatures=signatures,
-            unsigned=unsigned,
-            internal_metadata_dict=internal_metadata_dict,
+            unsigned=unsigned
        )

    def build(self):
--- a/synapse/events/snapshot.py
+++ b/synapse/events/snapshot.py
@@ -16,7 +16,7 @@

 class EventContext(object):

-    def __init__(self, current_state=None):
+    def __init__(self, current_state=None, auth_events=None):
        self.current_state = current_state
+        self.auth_events = auth_events
        self.state_group = None
-        self.rejected = False
--- a/synapse/events/utils.py
+++ b/synapse/events/utils.py
@@ -45,14 +45,12 @@ def prune_event(event):
        "membership",
    ]

-    event_dict = event.get_dict()
-
    new_content = {}

    def add_fields(*fields):
        for field in fields:
            if field in event.content:
-                new_content[field] = event_dict["content"][field]
+                new_content[field] = event.content[field]

    if event_type == EventTypes.Member:
        add_fields("membership")
@@ -77,7 +75,7 @@ def prune_event(event):

    allowed_fields = {
        k: v
-        for k, v in event_dict.items()
+        for k, v in event.get_dict().items()
        if k in allowed_keys
    }

@@ -88,78 +86,56 @@ def prune_event(event):
    if "age_ts" in event.unsigned:
        allowed_fields["unsigned"]["age_ts"] = event.unsigned["age_ts"]

-    return type(event)(
-        allowed_fields,
-        internal_metadata_dict=event.internal_metadata.get_dict()
-    )
+    return type(event)(allowed_fields)


-def format_event_raw(d):
-    return d
-
-
-def format_event_for_client_v1(d):
-    d["user_id"] = d.pop("sender", None)
-
-    move_keys = ("age", "redacted_because", "replaces_state", "prev_content")
-    for key in move_keys:
-        if key in d["unsigned"]:
-            d[key] = d["unsigned"][key]
-
-    drop_keys = (
-        "auth_events", "prev_events", "hashes", "signatures", "depth",
-        "unsigned", "origin", "prev_state"
-    )
-    for key in drop_keys:
-        d.pop(key, None)
-    return d
-
-
-def format_event_for_client_v2(d):
-    drop_keys = (
-        "auth_events", "prev_events", "hashes", "signatures", "depth",
-        "origin", "prev_state",
-    )
-    for key in drop_keys:
-        d.pop(key, None)
-    return d
-
-
-def format_event_for_client_v2_without_event_id(d):
-    d = format_event_for_client_v2(d)
-    d.pop("room_id", None)
-    d.pop("event_id", None)
-    return d
-
-
-def serialize_event(e, time_now_ms, as_client_event=True,
-                    event_format=format_event_for_client_v1,
-                    token_id=None):
+def serialize_event(hs, e, client_event=True):
    # FIXME(erikj): To handle the case of presence events and the like
    if not isinstance(e, EventBase):
        return e

-    time_now_ms = int(time_now_ms)
-
    # Should this strip out None's?
    d = {k: v for k, v in e.get_dict().items()}

+    if not client_event:
+        # set the age and keep all other keys
+        if "age_ts" in d["unsigned"]:
+            now = int(hs.get_clock().time_msec())
+            d["unsigned"]["age"] = now - d["unsigned"]["age_ts"]
+        return d
+
    if "age_ts" in d["unsigned"]:
-        d["unsigned"]["age"] = time_now_ms - d["unsigned"]["age_ts"]
+        now = int(hs.get_clock().time_msec())
+        d["age"] = now - d["unsigned"]["age_ts"]
        del d["unsigned"]["age_ts"]

+    d["user_id"] = d.pop("sender", None)
+
    if "redacted_because" in e.unsigned:
-        d["unsigned"]["redacted_because"] = serialize_event(
-            e.unsigned["redacted_because"], time_now_ms
+        d["redacted_because"] = serialize_event(
+            hs, e.unsigned["redacted_because"]
        )

-    if token_id is not None:
-        if token_id == getattr(e.internal_metadata, "token_id", None):
-            txn_id = getattr(e.internal_metadata, "txn_id", None)
-            if txn_id is not None:
-                d["unsigned"]["transaction_id"] = txn_id
+        del d["unsigned"]["redacted_because"]

-    if as_client_event:
-        return event_format(d)
-    else:
-        return d
+    if "redacted_by" in e.unsigned:
+        d["redacted_by"] = e.unsigned["redacted_by"]
+        del d["unsigned"]["redacted_by"]
+
+    if "replaces_state" in e.unsigned:
+        d["replaces_state"] = e.unsigned["replaces_state"]
+        del d["unsigned"]["replaces_state"]
+
+    if "prev_content" in e.unsigned:
+        d["prev_content"] = e.unsigned["prev_content"]
+        del d["unsigned"]["prev_content"]
+
+    del d["auth_events"]
+    del d["prev_events"]
+    del d["hashes"]
+    del d["signatures"]
+    d.pop("depth", None)
+    d.pop("unsigned", None)
+    d.pop("origin", None)
+
+    return d
--- a/synapse/federation/federation_base.py
+++ b/synapse/federation/federation_base.py
@@ -1,136 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-
-
-from twisted.internet import defer
-
-from synapse.events.utils import prune_event
-
-from syutil.jsonutil import encode_canonical_json
-
-from synapse.crypto.event_signing import check_event_content_hash
-
-from synapse.api.errors import SynapseError
-
-from synapse.util import unwrapFirstError
-
-import logging
-
-
-logger = logging.getLogger(__name__)
-
-
-class FederationBase(object):
-    @defer.inlineCallbacks
-    def _check_sigs_and_hash_and_fetch(self, origin, pdus, outlier=False):
-        """Takes a list of PDUs and checks the signatures and hashs of each
-        one. If a PDU fails its signature check then we check if we have it in
-        the database and if not then request if from the originating server of
-        that PDU.
-
-        If a PDU fails its content hash check then it is redacted.
-
-        The given list of PDUs are not modified, instead the function returns
-        a new list.
-
-        Args:
-            pdu (list)
-            outlier (bool)
-
-        Returns:
-            Deferred : A list of PDUs that have valid signatures and hashes.
-        """
-
-        signed_pdus = []
-
-        @defer.inlineCallbacks
-        def do(pdu):
-            try:
-                new_pdu = yield self._check_sigs_and_hash(pdu)
-                signed_pdus.append(new_pdu)
-            except SynapseError:
-                # FIXME: We should handle signature failures more gracefully.
-
-                # Check local db.
-                new_pdu = yield self.store.get_event(
-                    pdu.event_id,
-                    allow_rejected=True,
-                    allow_none=True,
-                )
-                if new_pdu:
-                    signed_pdus.append(new_pdu)
-                    return
-
-                # Check pdu.origin
-                if pdu.origin != origin:
-                    try:
-                        new_pdu = yield self.get_pdu(
-                            destinations=[pdu.origin],
-                            event_id=pdu.event_id,
-                            outlier=outlier,
-                            timeout=10000,
-                        )
-
-                        if new_pdu:
-                            signed_pdus.append(new_pdu)
-                            return
-                    except:
-                        pass
-
-                logger.warn(
-                    "Failed to find copy of %s with valid signature",
-                    pdu.event_id,
-                )
-
-        yield defer.gatherResults(
-            [do(pdu) for pdu in pdus],
-            consumeErrors=True
-        ).addErrback(unwrapFirstError)
-
-        defer.returnValue(signed_pdus)
-
-    @defer.inlineCallbacks
-    def _check_sigs_and_hash(self, pdu):
-        """Throws a SynapseError if the PDU does not have the correct
-        signatures.
-
-        Returns:
-            FrozenEvent: Either the given event or it redacted if it failed the
-            content hash check.
-        """
-        # Check signatures are correct.
-        redacted_event = prune_event(pdu)
-        redacted_pdu_json = redacted_event.get_pdu_json()
-
-        try:
-            yield self.keyring.verify_json_for_server(
-                pdu.origin, redacted_pdu_json
-            )
-        except SynapseError:
-            logger.warn(
-                "Signature check failed for %s redacted to %s",
-                encode_canonical_json(pdu.get_pdu_json()),
-                encode_canonical_json(redacted_pdu_json),
-            )
-            raise
-
-        if not check_event_content_hash(pdu):
-            logger.warn(
-                "Event content has been tampered, redacting %s, %s",
-                pdu.event_id, encode_canonical_json(pdu.get_dict())
-            )
-            defer.returnValue(redacted_event)
-
-        defer.returnValue(pdu)
--- a/synapse/federation/federation_client.py
+++ b/synapse/federation/federation_client.py
@@ -1,586 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-
-
-from twisted.internet import defer
-
-from .federation_base import FederationBase
-from .units import Edu
-
-from synapse.api.errors import (
-    CodeMessageException, HttpResponseException, SynapseError,
-)
-from synapse.util import unwrapFirstError
-from synapse.util.expiringcache import ExpiringCache
-from synapse.util.logutils import log_function
-from synapse.events import FrozenEvent
-import synapse.metrics
-
-from synapse.util.retryutils import get_retry_limiter, NotRetryingDestination
-
-import itertools
-import logging
-import random
-
-
-logger = logging.getLogger(__name__)
-
-
-# synapse.federation.federation_client is a silly name
-metrics = synapse.metrics.get_metrics_for("synapse.federation.client")
-
-sent_pdus_destination_dist = metrics.register_distribution("sent_pdu_destinations")
-
-sent_edus_counter = metrics.register_counter("sent_edus")
-
-sent_queries_counter = metrics.register_counter("sent_queries", labels=["type"])
-
-
-class FederationClient(FederationBase):
-
-    def start_get_pdu_cache(self):
-        self._get_pdu_cache = ExpiringCache(
-            cache_name="get_pdu_cache",
-            clock=self._clock,
-            max_len=1000,
-            expiry_ms=120*1000,
-            reset_expiry_on_get=False,
-        )
-
-        self._get_pdu_cache.start()
-
-    @log_function
-    def send_pdu(self, pdu, destinations):
-        """Informs the replication layer about a new PDU generated within the
-        home server that should be transmitted to others.
-
-        TODO: Figure out when we should actually resolve the deferred.
-
-        Args:
-            pdu (Pdu): The new Pdu.
-
-        Returns:
-            Deferred: Completes when we have successfully processed the PDU
-            and replicated it to any interested remote home servers.
-        """
-        order = self._order
-        self._order += 1
-
-        sent_pdus_destination_dist.inc_by(len(destinations))
-
-        logger.debug("[%s] transaction_layer.enqueue_pdu... ", pdu.event_id)
-
-        # TODO, add errback, etc.
-        self._transaction_queue.enqueue_pdu(pdu, destinations, order)
-
-        logger.debug(
-            "[%s] transaction_layer.enqueue_pdu... done",
-            pdu.event_id
-        )
-
-    @log_function
-    def send_edu(self, destination, edu_type, content):
-        edu = Edu(
-            origin=self.server_name,
-            destination=destination,
-            edu_type=edu_type,
-            content=content,
-        )
-
-        sent_edus_counter.inc()
-
-        # TODO, add errback, etc.
-        self._transaction_queue.enqueue_edu(edu)
-        return defer.succeed(None)
-
-    @log_function
-    def send_failure(self, failure, destination):
-        self._transaction_queue.enqueue_failure(failure, destination)
-        return defer.succeed(None)
-
-    @log_function
-    def make_query(self, destination, query_type, args,
-                   retry_on_dns_fail=True):
-        """Sends a federation Query to a remote homeserver of the given type
-        and arguments.
-
-        Args:
-            destination (str): Domain name of the remote homeserver
-            query_type (str): Category of the query type; should match the
-                handler name used in register_query_handler().
-            args (dict): Mapping of strings to strings containing the details
-                of the query request.
-
-        Returns:
-            a Deferred which will eventually yield a JSON object from the
-            response
-        """
-        sent_queries_counter.inc(query_type)
-
-        return self.transport_layer.make_query(
-            destination, query_type, args, retry_on_dns_fail=retry_on_dns_fail
-        )
-
-    @defer.inlineCallbacks
-    @log_function
-    def backfill(self, dest, context, limit, extremities):
-        """Requests some more historic PDUs for the given context from the
-        given destination server.
-
-        Args:
-            dest (str): The remote home server to ask.
-            context (str): The context to backfill.
-            limit (int): The maximum number of PDUs to return.
-            extremities (list): List of PDU id and origins of the first pdus
-                we have seen from the context
-
-        Returns:
-            Deferred: Results in the received PDUs.
-        """
-        logger.debug("backfill extrem=%s", extremities)
-
-        # If there are no extremeties then we've (probably) reached the start.
-        if not extremities:
-            return
-
-        transaction_data = yield self.transport_layer.backfill(
-            dest, context, extremities, limit)
-
-        logger.debug("backfill transaction_data=%s", repr(transaction_data))
-
-        pdus = [
-            self.event_from_pdu_json(p, outlier=False)
-            for p in transaction_data["pdus"]
-        ]
-
-        # FIXME: We should handle signature failures more gracefully.
-        pdus[:] = yield defer.gatherResults(
-            [self._check_sigs_and_hash(pdu) for pdu in pdus],
-            consumeErrors=True,
-        ).addErrback(unwrapFirstError)
-
-        defer.returnValue(pdus)
-
-    @defer.inlineCallbacks
-    @log_function
-    def get_pdu(self, destinations, event_id, outlier=False, timeout=None):
-        """Requests the PDU with given origin and ID from the remote home
-        servers.
-
-        Will attempt to get the PDU from each destination in the list until
-        one succeeds.
-
-        This will persist the PDU locally upon receipt.
-
-        Args:
-            destinations (list): Which home servers to query
-            pdu_origin (str): The home server that originally sent the pdu.
-            event_id (str)
-            outlier (bool): Indicates whether the PDU is an `outlier`, i.e. if
-                it's from an arbitary point in the context as opposed to part
-                of the current block of PDUs. Defaults to `False`
-            timeout (int): How long to try (in ms) each destination for before
-                moving to the next destination. None indicates no timeout.
-
-        Returns:
-            Deferred: Results in the requested PDU.
-        """
-
-        # TODO: Rate limit the number of times we try and get the same event.
-
-        if self._get_pdu_cache:
-            e = self._get_pdu_cache.get(event_id)
-            if e:
-                defer.returnValue(e)
-
-        pdu = None
-        for destination in destinations:
-            try:
-                limiter = yield get_retry_limiter(
-                    destination,
-                    self._clock,
-                    self.store,
-                )
-
-                with limiter:
-                    transaction_data = yield self.transport_layer.get_event(
-                        destination, event_id, timeout=timeout,
-                    )
-
-                    logger.debug("transaction_data %r", transaction_data)
-
-                    pdu_list = [
-                        self.event_from_pdu_json(p, outlier=outlier)
-                        for p in transaction_data["pdus"]
-                    ]
-
-                    if pdu_list and pdu_list[0]:
-                        pdu = pdu_list[0]
-
-                        # Check signatures are correct.
-                        pdu = yield self._check_sigs_and_hash(pdu)
-
-                        break
-
-            except SynapseError:
-                logger.info(
-                    "Failed to get PDU %s from %s because %s",
-                    event_id, destination, e,
-                )
-                continue
-            except CodeMessageException as e:
-                if 400 <= e.code < 500:
-                    raise
-
-                logger.info(
-                    "Failed to get PDU %s from %s because %s",
-                    event_id, destination, e,
-                )
-                continue
-            except NotRetryingDestination as e:
-                logger.info(e.message)
-                continue
-            except Exception as e:
-                logger.info(
-                    "Failed to get PDU %s from %s because %s",
-                    event_id, destination, e,
-                )
-                continue
-
-        if self._get_pdu_cache is not None and pdu:
-            self._get_pdu_cache[event_id] = pdu
-
-        defer.returnValue(pdu)
-
-    @defer.inlineCallbacks
-    @log_function
-    def get_state_for_room(self, destination, room_id, event_id):
-        """Requests all of the `current` state PDUs for a given room from
-        a remote home server.
-
-        Args:
-            destination (str): The remote homeserver to query for the state.
-            room_id (str): The id of the room we're interested in.
-            event_id (str): The id of the event we want the state at.
-
-        Returns:
-            Deferred: Results in a list of PDUs.
-        """
-
-        result = yield self.transport_layer.get_room_state(
-            destination, room_id, event_id=event_id,
-        )
-
-        pdus = [
-            self.event_from_pdu_json(p, outlier=True) for p in result["pdus"]
-        ]
-
-        auth_chain = [
-            self.event_from_pdu_json(p, outlier=True)
-            for p in result.get("auth_chain", [])
-        ]
-
-        signed_pdus = yield self._check_sigs_and_hash_and_fetch(
-            destination, pdus, outlier=True
-        )
-
-        signed_auth = yield self._check_sigs_and_hash_and_fetch(
-            destination, auth_chain, outlier=True
-        )
-
-        signed_auth.sort(key=lambda e: e.depth)
-
-        defer.returnValue((signed_pdus, signed_auth))
-
-    @defer.inlineCallbacks
-    @log_function
-    def get_event_auth(self, destination, room_id, event_id):
-        res = yield self.transport_layer.get_event_auth(
-            destination, room_id, event_id,
-        )
-
-        auth_chain = [
-            self.event_from_pdu_json(p, outlier=True)
-            for p in res["auth_chain"]
-        ]
-
-        signed_auth = yield self._check_sigs_and_hash_and_fetch(
-            destination, auth_chain, outlier=True
-        )
-
-        signed_auth.sort(key=lambda e: e.depth)
-
-        defer.returnValue(signed_auth)
-
-    @defer.inlineCallbacks
-    def make_join(self, destinations, room_id, user_id):
-        for destination in destinations:
-            try:
-                ret = yield self.transport_layer.make_join(
-                    destination, room_id, user_id
-                )
-
-                pdu_dict = ret["event"]
-
-                logger.debug("Got response to make_join: %s", pdu_dict)
-
-                defer.returnValue(
-                    (destination, self.event_from_pdu_json(pdu_dict))
-                )
-                break
-            except CodeMessageException:
-                raise
-            except Exception as e:
-                logger.warn(
-                    "Failed to make_join via %s: %s",
-                    destination, e.message
-                )
-
-        raise RuntimeError("Failed to send to any server.")
-
-    @defer.inlineCallbacks
-    def send_join(self, destinations, pdu):
-        for destination in destinations:
-            try:
-                time_now = self._clock.time_msec()
-                _, content = yield self.transport_layer.send_join(
-                    destination=destination,
-                    room_id=pdu.room_id,
-                    event_id=pdu.event_id,
-                    content=pdu.get_pdu_json(time_now),
-                )
-
-                logger.debug("Got content: %s", content)
-
-                state = [
-                    self.event_from_pdu_json(p, outlier=True)
-                    for p in content.get("state", [])
-                ]
-
-                auth_chain = [
-                    self.event_from_pdu_json(p, outlier=True)
-                    for p in content.get("auth_chain", [])
-                ]
-
-                signed_state, signed_auth = yield defer.gatherResults(
-                    [
-                        self._check_sigs_and_hash_and_fetch(
-                            destination, state, outlier=True
-                        ),
-                        self._check_sigs_and_hash_and_fetch(
-                            destination, auth_chain, outlier=True
-                        )
-                    ],
-                    consumeErrors=True
-                ).addErrback(unwrapFirstError)
-
-                auth_chain.sort(key=lambda e: e.depth)
-
-                defer.returnValue({
-                    "state": signed_state,
-                    "auth_chain": signed_auth,
-                    "origin": destination,
-                })
-            except CodeMessageException:
-                raise
-            except Exception as e:
-                logger.warn(
-                    "Failed to send_join via %s: %s",
-                    destination, e.message
-                )
-
-        raise RuntimeError("Failed to send to any server.")
-
-    @defer.inlineCallbacks
-    def send_invite(self, destination, room_id, event_id, pdu):
-        time_now = self._clock.time_msec()
-        code, content = yield self.transport_layer.send_invite(
-            destination=destination,
-            room_id=room_id,
-            event_id=event_id,
-            content=pdu.get_pdu_json(time_now),
-        )
-
-        pdu_dict = content["event"]
-
-        logger.debug("Got response to send_invite: %s", pdu_dict)
-
-        pdu = self.event_from_pdu_json(pdu_dict)
-
-        # Check signatures are correct.
-        pdu = yield self._check_sigs_and_hash(pdu)
-
-        # FIXME: We should handle signature failures more gracefully.
-
-        defer.returnValue(pdu)
-
-    @defer.inlineCallbacks
-    def query_auth(self, destination, room_id, event_id, local_auth):
-        """
-        Params:
-            destination (str)
-            event_it (str)
-            local_auth (list)
-        """
-        time_now = self._clock.time_msec()
-
-        send_content = {
-            "auth_chain": [e.get_pdu_json(time_now) for e in local_auth],
-        }
-
-        code, content = yield self.transport_layer.send_query_auth(
-            destination=destination,
-            room_id=room_id,
-            event_id=event_id,
-            content=send_content,
-        )
-
-        auth_chain = [
-            self.event_from_pdu_json(e)
-            for e in content["auth_chain"]
-        ]
-
-        signed_auth = yield self._check_sigs_and_hash_and_fetch(
-            destination, auth_chain, outlier=True
-        )
-
-        signed_auth.sort(key=lambda e: e.depth)
-
-        ret = {
-            "auth_chain": signed_auth,
-            "rejects": content.get("rejects", []),
-            "missing": content.get("missing", []),
-        }
-
-        defer.returnValue(ret)
-
-    @defer.inlineCallbacks
-    def get_missing_events(self, destination, room_id, earliest_events_ids,
-                           latest_events, limit, min_depth):
-        """Tries to fetch events we are missing. This is called when we receive
-        an event without having received all of its ancestors.
-
-        Args:
-            destination (str)
-            room_id (str)
-            earliest_events_ids (list): List of event ids. Effectively the
-                events we expected to receive, but haven't. `get_missing_events`
-                should only return events that didn't happen before these.
-            latest_events (list): List of events we have received that we don't
-                have all previous events for.
-            limit (int): Maximum number of events to return.
-            min_depth (int): Minimum depth of events tor return.
-        """
-        try:
-            content = yield self.transport_layer.get_missing_events(
-                destination=destination,
-                room_id=room_id,
-                earliest_events=earliest_events_ids,
-                latest_events=[e.event_id for e in latest_events],
-                limit=limit,
-                min_depth=min_depth,
-            )
-
-            events = [
-                self.event_from_pdu_json(e)
-                for e in content.get("events", [])
-            ]
-
-            signed_events = yield self._check_sigs_and_hash_and_fetch(
-                destination, events, outlier=False
-            )
-
-            have_gotten_all_from_destination = True
-        except HttpResponseException as e:
-            if not e.code == 400:
-                raise
-
-            # We are probably hitting an old server that doesn't support
-            # get_missing_events
-            signed_events = []
-            have_gotten_all_from_destination = False
-
-        if len(signed_events) >= limit:
-            defer.returnValue(signed_events)
-
-        servers = yield self.store.get_joined_hosts_for_room(room_id)
-
-        servers = set(servers)
-        servers.discard(self.server_name)
-
-        failed_to_fetch = set()
-
-        while len(signed_events) < limit:
-            # Are we missing any?
-
-            seen_events = set(earliest_events_ids)
-            seen_events.update(e.event_id for e in signed_events if e)
-
-            missing_events = {}
-            for e in itertools.chain(latest_events, signed_events):
-                if e.depth > min_depth:
-                    missing_events.update({
-                        e_id: e.depth for e_id, _ in e.prev_events
-                        if e_id not in seen_events
-                        and e_id not in failed_to_fetch
-                    })
-
-            if not missing_events:
-                break
-
-            have_seen = yield self.store.have_events(missing_events)
-
-            for k in have_seen:
-                missing_events.pop(k, None)
-
-            if not missing_events:
-                break
-
-            # Okay, we haven't gotten everything yet. Lets get them.
-            ordered_missing = sorted(missing_events.items(), key=lambda x: x[0])
-
-            if have_gotten_all_from_destination:
-                servers.discard(destination)
-
-            def random_server_list():
-                srvs = list(servers)
-                random.shuffle(srvs)
-                return srvs
-
-            deferreds = [
-                self.get_pdu(
-                    destinations=random_server_list(),
-                    event_id=e_id,
-                )
-                for e_id, depth in ordered_missing[:limit - len(signed_events)]
-            ]
-
-            res = yield defer.DeferredList(deferreds, consumeErrors=True)
-            for (result, val), (e_id, _) in zip(res, ordered_missing):
-                if result and val:
-                    signed_events.append(val)
-                else:
-                    failed_to_fetch.add(e_id)
-
-        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
--- a/synapse/federation/federation_server.py
+++ b/synapse/federation/federation_server.py
@@ -1,488 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-
-
-from twisted.internet import defer
-
-from .federation_base import FederationBase
-from .units import Transaction, Edu
-
-from synapse.util.logutils import log_function
-from synapse.events import FrozenEvent
-import synapse.metrics
-
-from synapse.api.errors import FederationError, SynapseError
-
-from synapse.crypto.event_signing import compute_event_signature
-
-import logging
-
-
-logger = logging.getLogger(__name__)
-
-# synapse.federation.federation_server is a silly name
-metrics = synapse.metrics.get_metrics_for("synapse.federation.server")
-
-received_pdus_counter = metrics.register_counter("received_pdus")
-
-received_edus_counter = metrics.register_counter("received_edus")
-
-received_queries_counter = metrics.register_counter("received_queries", labels=["type"])
-
-
-class FederationServer(FederationBase):
-    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):
-        pdus = yield self.handler.on_backfill_request(
-            origin, room_id, versions, limit
-        )
-
-        defer.returnValue((200, self._transaction_from_pdus(pdus).get_dict()))
-
-    @defer.inlineCallbacks
-    @log_function
-    def on_incoming_transaction(self, transaction_data):
-        transaction = Transaction(**transaction_data)
-
-        received_pdus_counter.inc_by(len(transaction.pdus))
-
-        for p in transaction.pdus:
-            if "unsigned" in p:
-                unsigned = p["unsigned"]
-                if "age" in unsigned:
-                    p["age"] = unsigned["age"]
-            if "age" in p:
-                p["age_ts"] = int(self._clock.time_msec()) - int(p["age"])
-                del p["age"]
-
-        pdu_list = [
-            self.event_from_pdu_json(p) for p in transaction.pdus
-        ]
-
-        logger.debug("[%s] Got transaction", transaction.transaction_id)
-
-        response = yield self.transaction_actions.have_responded(transaction)
-
-        if response:
-            logger.debug(
-                "[%s] We've already responed to this request",
-                transaction.transaction_id
-            )
-            defer.returnValue(response)
-            return
-
-        logger.debug("[%s] Transaction is new", transaction.transaction_id)
-
-        results = []
-
-        for pdu in pdu_list:
-            d = self._handle_new_pdu(transaction.origin, pdu)
-
-            try:
-                yield d
-                results.append({})
-            except FederationError as e:
-                self.send_failure(e, transaction.origin)
-                results.append({"error": str(e)})
-            except Exception as e:
-                results.append({"error": str(e)})
-                logger.exception("Failed to handle PDU")
-
-        if hasattr(transaction, "edus"):
-            for edu in [Edu(**x) for x in transaction.edus]:
-                self.received_edu(
-                    transaction.origin,
-                    edu.edu_type,
-                    edu.content
-                )
-
-            for failure in getattr(transaction, "pdu_failures", []):
-                logger.info("Got failure %r", failure)
-
-        logger.debug("Returning: %s", str(results))
-
-        response = {
-            "pdus": dict(zip(
-                (p.event_id for p in pdu_list), results
-            )),
-        }
-
-        yield self.transaction_actions.set_response(
-            transaction,
-            200, response
-        )
-        defer.returnValue((200, response))
-
-    def received_edu(self, origin, edu_type, content):
-        received_edus_counter.inc()
-
-        if edu_type in self.edu_handlers:
-            self.edu_handlers[edu_type](origin, content)
-        else:
-            logger.warn("Received EDU of type %s with no handler", edu_type)
-
-    @defer.inlineCallbacks
-    @log_function
-    def on_context_state_request(self, origin, room_id, event_id):
-        if event_id:
-            pdus = yield self.handler.get_state_for_pdu(
-                origin, room_id, event_id,
-            )
-            auth_chain = yield self.store.get_auth_chain(
-                [pdu.event_id for pdu in pdus]
-            )
-
-            for event in auth_chain:
-                event.signatures.update(
-                    compute_event_signature(
-                        event,
-                        self.hs.hostname,
-                        self.hs.config.signing_key[0]
-                    )
-                )
-        else:
-            raise NotImplementedError("Specify an event")
-
-        defer.returnValue((200, {
-            "pdus": [pdu.get_pdu_json() for pdu in pdus],
-            "auth_chain": [pdu.get_pdu_json() for pdu in auth_chain],
-        }))
-
-    @defer.inlineCallbacks
-    @log_function
-    def on_pdu_request(self, origin, event_id):
-        pdu = yield self._get_persisted_pdu(origin, event_id)
-
-        if pdu:
-            defer.returnValue(
-                (200, self._transaction_from_pdus([pdu]).get_dict())
-            )
-        else:
-            defer.returnValue((404, ""))
-
-    @defer.inlineCallbacks
-    @log_function
-    def on_pull_request(self, origin, versions):
-        raise NotImplementedError("Pull transactions not implemented")
-
-    @defer.inlineCallbacks
-    def on_query_request(self, query_type, args):
-        received_queries_counter.inc(query_type)
-
-        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):
-        pdu = yield self.handler.on_make_join_request(room_id, user_id)
-        time_now = self._clock.time_msec()
-        defer.returnValue({"event": pdu.get_pdu_json(time_now)})
-
-    @defer.inlineCallbacks
-    def on_invite_request(self, origin, 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)}))
-
-    @defer.inlineCallbacks
-    def on_send_join_request(self, origin, content):
-        logger.debug("on_send_join_request: content: %s", 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()
-        defer.returnValue((200, {
-            "state": [p.get_pdu_json(time_now) for p in res_pdus["state"]],
-            "auth_chain": [
-                p.get_pdu_json(time_now) for p in res_pdus["auth_chain"]
-            ],
-        }))
-
-    @defer.inlineCallbacks
-    def on_event_auth(self, origin, room_id, event_id):
-        time_now = self._clock.time_msec()
-        auth_pdus = yield self.handler.on_event_auth(event_id)
-        defer.returnValue((200, {
-            "auth_chain": [a.get_pdu_json(time_now) for a in auth_pdus],
-        }))
-
-    @defer.inlineCallbacks
-    def on_query_auth_request(self, origin, content, event_id):
-        """
-        Content is a dict with keys::
-            auth_chain (list): A list of events that give the auth chain.
-            missing (list): A list of event_ids indicating what the other
-              side (`origin`) think we're missing.
-            rejects (dict): A mapping from event_id to a 2-tuple of reason
-              string and a proof (or None) of why the event was rejected.
-              The keys of this dict give the list of events the `origin` has
-              rejected.
-
-        Args:
-            origin (str)
-            content (dict)
-            event_id (str)
-
-        Returns:
-            Deferred: Results in `dict` with the same format as `content`
-        """
-        auth_chain = [
-            self.event_from_pdu_json(e)
-            for e in content["auth_chain"]
-        ]
-
-        signed_auth = yield self._check_sigs_and_hash_and_fetch(
-            origin, auth_chain, outlier=True
-        )
-
-        ret = yield self.handler.on_query_auth(
-            origin,
-            event_id,
-            signed_auth,
-            content.get("rejects", []),
-            content.get("missing", []),
-        )
-
-        time_now = self._clock.time_msec()
-        send_content = {
-            "auth_chain": [
-                e.get_pdu_json(time_now)
-                for e in ret["auth_chain"]
-            ],
-            "rejects": ret.get("rejects", []),
-            "missing": ret.get("missing", []),
-        }
-
-        defer.returnValue(
-            (200, send_content)
-        )
-
-    @defer.inlineCallbacks
-    @log_function
-    def on_get_missing_events(self, origin, room_id, earliest_events,
-                              latest_events, limit, min_depth):
-        missing_events = yield self.handler.on_get_missing_events(
-            origin, room_id, earliest_events, latest_events, limit, min_depth
-        )
-
-        time_now = self._clock.time_msec()
-
-        defer.returnValue({
-            "events": [ev.get_pdu_json(time_now) for ev in missing_events],
-        })
-
-    @log_function
-    def _get_persisted_pdu(self, origin, event_id, do_auth=True):
-        """ Get a PDU from the database with given origin and id.
-
-        Returns:
-            Deferred: Results in a `Pdu`.
-        """
-        return self.handler.get_persisted_pdu(
-            origin, event_id, do_auth=do_auth
-        )
-
-    def _transaction_from_pdus(self, pdu_list):
-        """Returns a new Transaction containing the given PDUs suitable for
-        transmission.
-        """
-        time_now = self._clock.time_msec()
-        pdus = [p.get_pdu_json(time_now) for p in pdu_list]
-        return Transaction(
-            origin=self.server_name,
-            pdus=pdus,
-            origin_server_ts=int(time_now),
-            destination=None,
-        )
-
-    @defer.inlineCallbacks
-    @log_function
-    def _handle_new_pdu(self, origin, pdu, get_missing=True):
-        # We reprocess pdus when we have seen them only as outliers
-        existing = yield self._get_persisted_pdu(
-            origin, pdu.event_id, do_auth=False
-        )
-
-        # FIXME: Currently we fetch an event again when we already have it
-        # if it has been marked as an outlier.
-
-        already_seen = (
-            existing and (
-                not existing.internal_metadata.is_outlier()
-                or pdu.internal_metadata.is_outlier()
-            )
-        )
-        if already_seen:
-            logger.debug("Already seen pdu %s", pdu.event_id)
-            return
-
-        # Check signature.
-        try:
-            pdu = yield self._check_sigs_and_hash(pdu)
-        except SynapseError as e:
-            raise FederationError(
-                "ERROR",
-                e.code,
-                e.msg,
-                affected=pdu.event_id,
-            )
-
-        state = None
-
-        auth_chain = []
-
-        have_seen = yield self.store.have_events(
-            [ev for ev, _ in pdu.prev_events]
-        )
-
-        fetch_state = False
-
-        # Get missing pdus if necessary.
-        if not pdu.internal_metadata.is_outlier():
-            # We only backfill backwards to the min depth.
-            min_depth = yield self.handler.get_min_depth_for_context(
-                pdu.room_id
-            )
-
-            logger.debug(
-                "_handle_new_pdu min_depth for %s: %d",
-                pdu.room_id, min_depth
-            )
-
-            prevs = {e_id for e_id, _ in pdu.prev_events}
-            seen = set(have_seen.keys())
-
-            if min_depth and pdu.depth < min_depth:
-                # This is so that we don't notify the user about this
-                # message, to work around the fact that some events will
-                # reference really really old events we really don't want to
-                # send to the clients.
-                pdu.internal_metadata.outlier = True
-            elif min_depth and pdu.depth > min_depth:
-                if get_missing and prevs - seen:
-                    latest = yield self.store.get_latest_event_ids_in_room(
-                        pdu.room_id
-                    )
-
-                    # We add the prev events that we have seen to the latest
-                    # list to ensure the remote server doesn't give them to us
-                    latest = set(latest)
-                    latest |= seen
-
-                    missing_events = yield self.get_missing_events(
-                        origin,
-                        pdu.room_id,
-                        earliest_events_ids=list(latest),
-                        latest_events=[pdu],
-                        limit=10,
-                        min_depth=min_depth,
-                    )
-
-                    # We want to sort these by depth so we process them and
-                    # tell clients about them in order.
-                    missing_events.sort(key=lambda x: x.depth)
-
-                    for e in missing_events:
-                        yield self._handle_new_pdu(
-                            origin,
-                            e,
-                            get_missing=False
-                        )
-
-                    have_seen = yield self.store.have_events(
-                        [ev for ev, _ in pdu.prev_events]
-                    )
-
-            prevs = {e_id for e_id, _ in pdu.prev_events}
-            seen = set(have_seen.keys())
-            if prevs - seen:
-                fetch_state = True
-
-        if fetch_state:
-            # We need to get the state at this event, since we haven't
-            # processed all the prev events.
-            logger.debug(
-                "_handle_new_pdu getting state for %s",
-                pdu.room_id
-            )
-            try:
-                state, auth_chain = yield self.get_state_for_room(
-                    origin, pdu.room_id, pdu.event_id,
-                )
-            except:
-                logger.warn("Failed to get state for event: %s", pdu.event_id)
-
-        yield self.handler.on_receive_pdu(
-            origin,
-            pdu,
-            backfilled=False,
-            state=state,
-            auth_chain=auth_chain,
-        )
-
-    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
--- a/synapse/federation/persistence.py
+++ b/synapse/federation/persistence.py
@@ -23,6 +23,7 @@ from twisted.internet import defer

 from synapse.util.logutils import log_function

+import json
 import logging


@@ -69,7 +70,7 @@ class TransactionActions(object):
            transaction.transaction_id,
            transaction.origin,
            code,
-            response,
+            json.dumps(response)
        )

    @defer.inlineCallbacks
@@ -99,5 +100,5 @@ class TransactionActions(object):
            transaction.transaction_id,
            transaction.destination,
            response_code,
-            response_dict,
+            json.dumps(response_dict)
        )
--- a/synapse/federation/replication.py
+++ b/synapse/federation/replication.py
@@ -17,20 +17,23 @@
 a given transport.
 """

-from .federation_client import FederationClient
-from .federation_server import FederationServer
+from twisted.internet import defer

-from .transaction_queue import TransactionQueue
+from .units import Transaction, Edu

 from .persistence import TransactionActions

+from synapse.util.logutils import log_function
+from synapse.util.logcontext import PreserveLoggingContext
+from synapse.events import FrozenEvent
+
 import logging


 logger = logging.getLogger(__name__)


-class ReplicationLayer(FederationClient, FederationServer):
+class ReplicationLayer(object):
    """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.
@@ -51,28 +54,898 @@ class ReplicationLayer(FederationClient, FederationServer):
    def __init__(self, hs, transport_layer):
        self.server_name = hs.hostname

-        self.keyring = hs.get_keyring()
-
        self.transport_layer = transport_layer
        self.transport_layer.register_received_handler(self)
        self.transport_layer.register_request_handler(self)

-        self.federation_client = self
-
        self.store = hs.get_datastore()
+        # self.pdu_actions = PduActions(self.store)
+        self.transaction_actions = TransactionActions(self.store)
+
+        self._transaction_queue = _TransactionQueue(
+            hs, self.transaction_actions, transport_layer
+        )

        self.handler = None
        self.edu_handlers = {}
        self.query_handlers = {}

-        self._clock = hs.get_clock()
-
-        self.transaction_actions = TransactionActions(self.store)
-        self._transaction_queue = TransactionQueue(hs, transport_layer)
-
        self._order = 0

-        self.hs = hs
+        self._clock = hs.get_clock()
+
+        self.event_builder_factory = hs.get_event_builder_factory()
+
+    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
+
+    @log_function
+    def send_pdu(self, pdu, destinations):
+        """Informs the replication layer about a new PDU generated within the
+        home server that should be transmitted to others.
+
+        TODO: Figure out when we should actually resolve the deferred.
+
+        Args:
+            pdu (Pdu): The new Pdu.
+
+        Returns:
+            Deferred: Completes when we have successfully processed the PDU
+            and replicated it to any interested remote home servers.
+        """
+        order = self._order
+        self._order += 1
+
+        logger.debug("[%s] transaction_layer.enqueue_pdu... ", pdu.event_id)
+
+        # TODO, add errback, etc.
+        self._transaction_queue.enqueue_pdu(pdu, destinations, order)
+
+        logger.debug(
+            "[%s] transaction_layer.enqueue_pdu... done",
+            pdu.event_id
+        )
+
+    @log_function
+    def send_edu(self, destination, edu_type, content):
+        edu = Edu(
+            origin=self.server_name,
+            destination=destination,
+            edu_type=edu_type,
+            content=content,
+        )
+
+        # TODO, add errback, etc.
+        self._transaction_queue.enqueue_edu(edu)
+        return defer.succeed(None)
+
+    @log_function
+    def send_failure(self, failure, destination):
+        self._transaction_queue.enqueue_failure(failure, destination)
+        return defer.succeed(None)
+
+    @log_function
+    def make_query(self, destination, query_type, args,
+                   retry_on_dns_fail=True):
+        """Sends a federation Query to a remote homeserver of the given type
+        and arguments.
+
+        Args:
+            destination (str): Domain name of the remote homeserver
+            query_type (str): Category of the query type; should match the
+                handler name used in register_query_handler().
+            args (dict): Mapping of strings to strings containing the details
+                of the query request.
+
+        Returns:
+            a Deferred which will eventually yield a JSON object from the
+            response
+        """
+        return self.transport_layer.make_query(
+            destination, query_type, args, retry_on_dns_fail=retry_on_dns_fail
+        )
+
+    @defer.inlineCallbacks
+    @log_function
+    def backfill(self, dest, context, limit, extremities):
+        """Requests some more historic PDUs for the given context from the
+        given destination server.
+
+        Args:
+            dest (str): The remote home server to ask.
+            context (str): The context to backfill.
+            limit (int): The maximum number of PDUs to return.
+            extremities (list): List of PDU id and origins of the first pdus
+                we have seen from the context
+
+        Returns:
+            Deferred: Results in the received PDUs.
+        """
+        logger.debug("backfill extrem=%s", extremities)
+
+        # If there are no extremeties then we've (probably) reached the start.
+        if not extremities:
+            return
+
+        transaction_data = yield self.transport_layer.backfill(
+            dest, context, extremities, limit)
+
+        logger.debug("backfill transaction_data=%s", repr(transaction_data))
+
+        transaction = Transaction(**transaction_data)
+
+        pdus = [
+            self.event_from_pdu_json(p, outlier=False)
+            for p in transaction.pdus
+        ]
+        for pdu in pdus:
+            yield self._handle_new_pdu(dest, pdu, backfilled=True)
+
+        defer.returnValue(pdus)
+
+    @defer.inlineCallbacks
+    @log_function
+    def get_pdu(self, destination, event_id, outlier=False):
+        """Requests the PDU with given origin and ID from the remote home
+        server.
+
+        This will persist the PDU locally upon receipt.
+
+        Args:
+            destination (str): Which home server to query
+            pdu_origin (str): The home server that originally sent the pdu.
+            event_id (str)
+            outlier (bool): Indicates whether the PDU is an `outlier`, i.e. if
+                it's from an arbitary point in the context as opposed to part
+                of the current block of PDUs. Defaults to `False`
+
+        Returns:
+            Deferred: Results in the requested PDU.
+        """
+
+        transaction_data = yield self.transport_layer.get_event(
+            destination, event_id
+        )
+
+        transaction = Transaction(**transaction_data)
+
+        pdu_list = [
+            self.event_from_pdu_json(p, outlier=outlier)
+            for p in transaction.pdus
+        ]
+
+        pdu = None
+        if pdu_list:
+            pdu = pdu_list[0]
+            yield self._handle_new_pdu(destination, pdu)
+
+        defer.returnValue(pdu)
+
+    @defer.inlineCallbacks
+    @log_function
+    def get_state_for_room(self, destination, room_id, event_id):
+        """Requests all of the `current` state PDUs for a given room from
+        a remote home server.
+
+        Args:
+            destination (str): The remote homeserver to query for the state.
+            room_id (str): The id of the room we're interested in.
+            event_id (str): The id of the event we want the state at.
+
+        Returns:
+            Deferred: Results in a list of PDUs.
+        """
+
+        result = yield self.transport_layer.get_room_state(
+            destination, room_id, event_id=event_id,
+        )
+
+        pdus = [
+            self.event_from_pdu_json(p, outlier=True) for p in result["pdus"]
+        ]
+
+        auth_chain = [
+            self.event_from_pdu_json(p, outlier=True)
+            for p in result.get("auth_chain", [])
+        ]
+
+        defer.returnValue((pdus, auth_chain))
+
+    @defer.inlineCallbacks
+    @log_function
+    def get_event_auth(self, destination, room_id, event_id):
+        res = yield self.transport_layer.get_event_auth(
+            destination, room_id, event_id,
+        )
+
+        auth_chain = [
+            self.event_from_pdu_json(p, outlier=True)
+            for p in res["auth_chain"]
+        ]
+
+        auth_chain.sort(key=lambda e: e.depth)
+
+        defer.returnValue(auth_chain)
+
+    @defer.inlineCallbacks
+    @log_function
+    def on_backfill_request(self, origin, room_id, versions, limit):
+        pdus = yield self.handler.on_backfill_request(
+            origin, room_id, versions, limit
+        )
+
+        defer.returnValue((200, self._transaction_from_pdus(pdus).get_dict()))
+
+    @defer.inlineCallbacks
+    @log_function
+    def on_incoming_transaction(self, transaction_data):
+        transaction = Transaction(**transaction_data)
+
+        for p in transaction.pdus:
+            if "unsigned" in p:
+                unsigned = p["unsigned"]
+                if "age" in unsigned:
+                    p["age"] = unsigned["age"]
+            if "age" in p:
+                p["age_ts"] = int(self._clock.time_msec()) - int(p["age"])
+                del p["age"]
+
+        pdu_list = [
+            self.event_from_pdu_json(p) for p in transaction.pdus
+        ]
+
+        logger.debug("[%s] Got transaction", transaction.transaction_id)
+
+        response = yield self.transaction_actions.have_responded(transaction)
+
+        if response:
+            logger.debug("[%s] We've already responed to this request",
+                         transaction.transaction_id)
+            defer.returnValue(response)
+            return
+
+        logger.debug("[%s] Transaction is new", transaction.transaction_id)
+
+        with PreserveLoggingContext():
+            dl = []
+            for pdu in pdu_list:
+                dl.append(self._handle_new_pdu(transaction.origin, pdu))
+
+            if hasattr(transaction, "edus"):
+                for edu in [Edu(**x) for x in transaction.edus]:
+                    self.received_edu(
+                        transaction.origin,
+                        edu.edu_type,
+                        edu.content
+                    )
+
+            results = yield defer.DeferredList(dl)
+
+        ret = []
+        for r in results:
+            if r[0]:
+                ret.append({})
+            else:
+                logger.exception(r[1])
+                ret.append({"error": str(r[1])})
+
+        logger.debug("Returning: %s", str(ret))
+
+        yield self.transaction_actions.set_response(
+            transaction,
+            200, response
+        )
+        defer.returnValue((200, response))
+
+    def received_edu(self, origin, edu_type, content):
+        if edu_type in self.edu_handlers:
+            self.edu_handlers[edu_type](origin, content)
+        else:
+            logger.warn("Received EDU of type %s with no handler", edu_type)
+
+    @defer.inlineCallbacks
+    @log_function
+    def on_context_state_request(self, origin, room_id, event_id):
+        if event_id:
+            pdus = yield self.handler.get_state_for_pdu(
+                origin, room_id, event_id,
+            )
+            auth_chain = yield self.store.get_auth_chain(
+                [pdu.event_id for pdu in pdus]
+            )
+        else:
+            raise NotImplementedError("Specify an event")
+
+        defer.returnValue((200, {
+            "pdus": [pdu.get_pdu_json() for pdu in pdus],
+            "auth_chain": [pdu.get_pdu_json() for pdu in auth_chain],
+        }))
+
+    @defer.inlineCallbacks
+    @log_function
+    def on_pdu_request(self, origin, event_id):
+        pdu = yield self._get_persisted_pdu(origin, event_id)
+
+        if pdu:
+            defer.returnValue(
+                (200, self._transaction_from_pdus([pdu]).get_dict())
+            )
+        else:
+            defer.returnValue((404, ""))
+
+    @defer.inlineCallbacks
+    @log_function
+    def on_pull_request(self, origin, versions):
+        raise NotImplementedError("Pull transactions not implemented")
+
+    @defer.inlineCallbacks
+    def on_query_request(self, query_type, args):
+        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):
+        pdu = yield self.handler.on_make_join_request(room_id, user_id)
+        time_now = self._clock.time_msec()
+        defer.returnValue({"event": pdu.get_pdu_json(time_now)})
+
+    @defer.inlineCallbacks
+    def on_invite_request(self, origin, 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)}))
+
+    @defer.inlineCallbacks
+    def on_send_join_request(self, origin, content):
+        logger.debug("on_send_join_request: content: %s", 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()
+        defer.returnValue((200, {
+            "state": [p.get_pdu_json(time_now) for p in res_pdus["state"]],
+            "auth_chain": [
+                p.get_pdu_json(time_now) for p in res_pdus["auth_chain"]
+            ],
+        }))
+
+    @defer.inlineCallbacks
+    def on_event_auth(self, origin, room_id, event_id):
+        time_now = self._clock.time_msec()
+        auth_pdus = yield self.handler.on_event_auth(event_id)
+        defer.returnValue((200, {
+            "auth_chain": [a.get_pdu_json(time_now) for a in auth_pdus],
+        }))
+
+    @defer.inlineCallbacks
+    def make_join(self, destination, room_id, user_id):
+        ret = yield self.transport_layer.make_join(
+            destination, room_id, user_id
+        )
+
+        pdu_dict = ret["event"]
+
+        logger.debug("Got response to make_join: %s", pdu_dict)
+
+        defer.returnValue(self.event_from_pdu_json(pdu_dict))
+
+    @defer.inlineCallbacks
+    def send_join(self, destination, pdu):
+        time_now = self._clock.time_msec()
+        _, content = yield self.transport_layer.send_join(
+            destination=destination,
+            room_id=pdu.room_id,
+            event_id=pdu.event_id,
+            content=pdu.get_pdu_json(time_now),
+        )
+
+        logger.debug("Got content: %s", content)
+
+        state = [
+            self.event_from_pdu_json(p, outlier=True)
+            for p in content.get("state", [])
+        ]
+
+        auth_chain = [
+            self.event_from_pdu_json(p, outlier=True)
+            for p in content.get("auth_chain", [])
+        ]
+
+        auth_chain.sort(key=lambda e: e.depth)
+
+        defer.returnValue({
+            "state": state,
+            "auth_chain": auth_chain,
+        })
+
+    @defer.inlineCallbacks
+    def send_invite(self, destination, room_id, event_id, pdu):
+        time_now = self._clock.time_msec()
+        code, content = yield self.transport_layer.send_invite(
+            destination=destination,
+            room_id=room_id,
+            event_id=event_id,
+            content=pdu.get_pdu_json(time_now),
+        )
+
+        pdu_dict = content["event"]
+
+        logger.debug("Got response to send_invite: %s", pdu_dict)
+
+        defer.returnValue(self.event_from_pdu_json(pdu_dict))
+
+    @log_function
+    def _get_persisted_pdu(self, origin, event_id, do_auth=True):
+        """ Get a PDU from the database with given origin and id.
+
+        Returns:
+            Deferred: Results in a `Pdu`.
+        """
+        return self.handler.get_persisted_pdu(
+            origin, event_id, do_auth=do_auth
+        )
+
+    def _transaction_from_pdus(self, pdu_list):
+        """Returns a new Transaction containing the given PDUs suitable for
+        transmission.
+        """
+        time_now = self._clock.time_msec()
+        pdus = [p.get_pdu_json(time_now) for p in pdu_list]
+        return Transaction(
+            origin=self.server_name,
+            pdus=pdus,
+            origin_server_ts=int(time_now),
+            destination=None,
+        )
+
+    @defer.inlineCallbacks
+    @log_function
+    def _handle_new_pdu(self, origin, pdu, backfilled=False):
+        # We reprocess pdus when we have seen them only as outliers
+        existing = yield self._get_persisted_pdu(
+            origin, pdu.event_id, do_auth=False
+        )
+
+        already_seen = (
+            existing and (
+                not existing.internal_metadata.is_outlier()
+                or pdu.internal_metadata.is_outlier()
+            )
+        )
+        if already_seen:
+            logger.debug("Already seen pdu %s", pdu.event_id)
+            defer.returnValue({})
+            return
+
+        state = None
+
+        auth_chain = []
+
+        # We need to make sure we have all the auth events.
+        # for e_id, _ in pdu.auth_events:
+        #     exists = yield self._get_persisted_pdu(
+        #         origin,
+        #         e_id,
+        #         do_auth=False
+        #     )
+        #
+        #     if not exists:
+        #         try:
+        #             logger.debug(
+        #                 "_handle_new_pdu fetch missing auth event %s from %s",
+        #                 e_id,
+        #                 origin,
+        #             )
+        #
+        #             yield self.get_pdu(
+        #                 origin,
+        #                 event_id=e_id,
+        #                 outlier=True,
+        #             )
+        #
+        #             logger.debug("Processed pdu %s", e_id)
+        #         except:
+        #             logger.warn(
+        #                 "Failed to get auth event %s from %s",
+        #                 e_id,
+        #                 origin
+        #             )
+
+        # Get missing pdus if necessary.
+        if not pdu.internal_metadata.is_outlier():
+            # We only backfill backwards to the min depth.
+            min_depth = yield self.handler.get_min_depth_for_context(
+                pdu.room_id
+            )
+
+            logger.debug(
+                "_handle_new_pdu min_depth for %s: %d",
+                pdu.room_id, min_depth
+            )
+
+            if min_depth and pdu.depth > min_depth:
+                for event_id, hashes in pdu.prev_events:
+                    exists = yield self._get_persisted_pdu(
+                        origin,
+                        event_id,
+                        do_auth=False
+                    )
+
+                    if not exists:
+                        logger.debug(
+                            "_handle_new_pdu requesting pdu %s",
+                            event_id
+                        )
+
+                        try:
+                            yield self.get_pdu(
+                                origin,
+                                event_id=event_id,
+                            )
+                            logger.debug("Processed pdu %s", event_id)
+                        except:
+                            # TODO(erikj): Do some more intelligent retries.
+                            logger.exception("Failed to get PDU")
+            else:
+                # We need to get the state at this event, since we have reached
+                # a backward extremity edge.
+                logger.debug(
+                    "_handle_new_pdu getting state for %s",
+                    pdu.room_id
+                )
+                state, auth_chain = yield self.get_state_for_room(
+                    origin, pdu.room_id, pdu.event_id,
+                )
+
+        if not backfilled:
+            ret = yield self.handler.on_receive_pdu(
+                origin,
+                pdu,
+                backfilled=backfilled,
+                state=state,
+                auth_chain=auth_chain,
+            )
+        else:
+            ret = None
+
+        # yield self.pdu_actions.mark_as_processed(pdu)
+
+        defer.returnValue(ret)

    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
+
+
+class _TransactionQueue(object):
+    """This class makes sure we only have one transaction in flight at
+    a time for a given destination.
+
+    It batches pending PDUs into single transactions.
+    """
+
+    def __init__(self, hs, transaction_actions, transport_layer):
+        self.server_name = hs.hostname
+        self.transaction_actions = transaction_actions
+        self.transport_layer = transport_layer
+
+        self._clock = hs.get_clock()
+        self.store = hs.get_datastore()
+
+        # Is a mapping from destinations -> deferreds. Used to keep track
+        # of which destinations have transactions in flight and when they are
+        # done
+        self.pending_transactions = {}
+
+        # Is a mapping from destination -> list of
+        # tuple(pending pdus, deferred, order)
+        self.pending_pdus_by_dest = {}
+        # destination -> list of tuple(edu, deferred)
+        self.pending_edus_by_dest = {}
+
+        # destination -> list of tuple(failure, deferred)
+        self.pending_failures_by_dest = {}
+
+        # HACK to get unique tx id
+        self._next_txn_id = int(self._clock.time_msec())
+
+    @defer.inlineCallbacks
+    @log_function
+    def enqueue_pdu(self, pdu, destinations, order):
+        # We loop through all destinations to see whether we already have
+        # a transaction in progress. If we do, stick it in the pending_pdus
+        # table and we'll get back to it later.
+
+        destinations = set(destinations)
+        destinations.discard(self.server_name)
+        destinations.discard("localhost")
+
+        logger.debug("Sending to: %s", str(destinations))
+
+        if not destinations:
+            return
+
+        deferreds = []
+
+        for destination in destinations:
+            deferred = defer.Deferred()
+            self.pending_pdus_by_dest.setdefault(destination, []).append(
+                (pdu, deferred, order)
+            )
+
+            def eb(failure):
+                if not deferred.called:
+                    deferred.errback(failure)
+                else:
+                    logger.warn("Failed to send pdu", failure)
+
+            with PreserveLoggingContext():
+                self._attempt_new_transaction(destination).addErrback(eb)
+
+            deferreds.append(deferred)
+
+        yield defer.DeferredList(deferreds)
+
+    # NO inlineCallbacks
+    def enqueue_edu(self, edu):
+        destination = edu.destination
+
+        if destination == self.server_name:
+            return
+
+        deferred = defer.Deferred()
+        self.pending_edus_by_dest.setdefault(destination, []).append(
+            (edu, deferred)
+        )
+
+        def eb(failure):
+            if not deferred.called:
+                deferred.errback(failure)
+            else:
+                logger.warn("Failed to send edu", failure)
+
+        with PreserveLoggingContext():
+            self._attempt_new_transaction(destination).addErrback(eb)
+
+        return deferred
+
+    @defer.inlineCallbacks
+    def enqueue_failure(self, failure, destination):
+        deferred = defer.Deferred()
+
+        self.pending_failures_by_dest.setdefault(
+            destination, []
+        ).append(
+            (failure, deferred)
+        )
+
+        yield deferred
+
+    @defer.inlineCallbacks
+    @log_function
+    def _attempt_new_transaction(self, destination):
+
+        (retry_last_ts, retry_interval) = (0, 0)
+        retry_timings = yield self.store.get_destination_retry_timings(
+            destination
+        )
+        if retry_timings:
+            (retry_last_ts, retry_interval) = (
+                retry_timings.retry_last_ts, retry_timings.retry_interval
+            )
+            if retry_last_ts + retry_interval > int(self._clock.time_msec()):
+                logger.info(
+                    "TX [%s] not ready for retry yet - "
+                    "dropping transaction for now",
+                    destination,
+                )
+                return
+            else:
+                logger.info("TX [%s] is ready for retry", destination)
+
+        logger.info("TX [%s] _attempt_new_transaction", destination)
+
+        if destination in self.pending_transactions:
+            # XXX: pending_transactions can get stuck on by a never-ending
+            # request at which point pending_pdus_by_dest just keeps growing.
+            # we need application-layer timeouts of some flavour of these
+            # requests
+            return
+
+        # list of (pending_pdu, deferred, order)
+        pending_pdus = self.pending_pdus_by_dest.pop(destination, [])
+        pending_edus = self.pending_edus_by_dest.pop(destination, [])
+        pending_failures = self.pending_failures_by_dest.pop(destination, [])
+
+        if pending_pdus:
+            logger.info("TX [%s] len(pending_pdus_by_dest[dest]) = %d",
+                        destination, len(pending_pdus))
+
+        if not pending_pdus and not pending_edus and not pending_failures:
+            return
+
+        logger.debug(
+            "TX [%s] Attempting new transaction"
+            " (pdus: %d, edus: %d, failures: %d)",
+            destination,
+            len(pending_pdus),
+            len(pending_edus),
+            len(pending_failures)
+        )
+
+        # Sort based on the order field
+        pending_pdus.sort(key=lambda t: t[2])
+
+        pdus = [x[0] for x in pending_pdus]
+        edus = [x[0] for x in pending_edus]
+        failures = [x[0].get_dict() for x in pending_failures]
+        deferreds = [
+            x[1]
+            for x in pending_pdus + pending_edus + pending_failures
+        ]
+
+        try:
+            self.pending_transactions[destination] = 1
+
+            logger.debug("TX [%s] Persisting transaction...", destination)
+
+            transaction = Transaction.create_new(
+                origin_server_ts=int(self._clock.time_msec()),
+                transaction_id=str(self._next_txn_id),
+                origin=self.server_name,
+                destination=destination,
+                pdus=pdus,
+                edus=edus,
+                pdu_failures=failures,
+            )
+
+            self._next_txn_id += 1
+
+            yield self.transaction_actions.prepare_to_send(transaction)
+
+            logger.debug("TX [%s] Persisted transaction", destination)
+            logger.info(
+                "TX [%s] Sending transaction [%s]",
+                destination,
+                transaction.transaction_id,
+            )
+
+            # Actually send the transaction
+
+            # FIXME (erikj): This is a bit of a hack to make the Pdu age
+            # keys work
+            def json_data_cb():
+                data = transaction.get_dict()
+                now = int(self._clock.time_msec())
+                if "pdus" in data:
+                    for p in data["pdus"]:
+                        if "age_ts" in p:
+                            unsigned = p.setdefault("unsigned", {})
+                            unsigned["age"] = now - int(p["age_ts"])
+                            del p["age_ts"]
+                return data
+
+            code, response = yield self.transport_layer.send_transaction(
+                transaction, json_data_cb
+            )
+
+            logger.info("TX [%s] got %d response", destination, code)
+
+            logger.debug("TX [%s] Sent transaction", destination)
+            logger.debug("TX [%s] Marking as delivered...", destination)
+
+            yield self.transaction_actions.delivered(
+                transaction, code, response
+            )
+
+            logger.debug("TX [%s] Marked as delivered", destination)
+            logger.debug("TX [%s] Yielding to callbacks...", destination)
+
+            for deferred in deferreds:
+                if code == 200:
+                    if retry_last_ts:
+                        # this host is alive! reset retry schedule
+                        yield self.store.set_destination_retry_timings(
+                            destination, 0, 0
+                        )
+                    deferred.callback(None)
+                else:
+                    self.set_retrying(destination, retry_interval)
+                    deferred.errback(RuntimeError("Got status %d" % code))
+
+                # Ensures we don't continue until all callbacks on that
+                # deferred have fired
+                try:
+                    yield deferred
+                except:
+                    pass
+
+            logger.debug("TX [%s] Yielded to callbacks", destination)
+
+        except Exception as e:
+            # We capture this here as there as nothing actually listens
+            # for this finishing functions deferred.
+            logger.warn(
+                "TX [%s] Problem in _attempt_transaction: %s",
+                destination,
+                e,
+            )
+
+            self.set_retrying(destination, retry_interval)
+
+            for deferred in deferreds:
+                if not deferred.called:
+                    deferred.errback(e)
+
+        finally:
+            # We want to be *very* sure we delete this after we stop processing
+            self.pending_transactions.pop(destination, None)
+
+            # Check to see if there is anything else to send.
+            self._attempt_new_transaction(destination)
+
+    @defer.inlineCallbacks
+    def set_retrying(self, destination, retry_interval):
+        # track that this destination is having problems and we should
+        # give it a chance to recover before trying it again
+
+        if retry_interval:
+            retry_interval *= 2
+            # plateau at hourly retries for now
+            if retry_interval >= 60 * 60 * 1000:
+                retry_interval = 60 * 60 * 1000
+        else:
+            retry_interval = 2000  # try again at first after 2 seconds
+
+        yield self.store.set_destination_retry_timings(
+            destination,
+            int(self._clock.time_msec()),
+            retry_interval
+        )
--- a/synapse/federation/transaction_queue.py
+++ b/synapse/federation/transaction_queue.py
@@ -1,384 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2014, 2015 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.
-
-
-from twisted.internet import defer
-
-from .persistence import TransactionActions
-from .units import Transaction
-
-from synapse.api.errors import HttpResponseException
-from synapse.util.logutils import log_function
-from synapse.util.logcontext import PreserveLoggingContext
-from synapse.util.retryutils import (
-    get_retry_limiter, NotRetryingDestination,
-)
-import synapse.metrics
-
-import logging
-
-
-logger = logging.getLogger(__name__)
-
-metrics = synapse.metrics.get_metrics_for(__name__)
-
-
-class TransactionQueue(object):
-    """This class makes sure we only have one transaction in flight at
-    a time for a given destination.
-
-    It batches pending PDUs into single transactions.
-    """
-
-    def __init__(self, hs, transport_layer):
-        self.server_name = hs.hostname
-
-        self.store = hs.get_datastore()
-        self.transaction_actions = TransactionActions(self.store)
-
-        self.transport_layer = transport_layer
-
-        self._clock = hs.get_clock()
-
-        # Is a mapping from destinations -> deferreds. Used to keep track
-        # of which destinations have transactions in flight and when they are
-        # done
-        self.pending_transactions = {}
-
-        metrics.register_callback(
-            "pending_destinations",
-            lambda: len(self.pending_transactions),
-        )
-
-        # Is a mapping from destination -> list of
-        # tuple(pending pdus, deferred, order)
-        self.pending_pdus_by_dest = pdus = {}
-        # destination -> list of tuple(edu, deferred)
-        self.pending_edus_by_dest = edus = {}
-
-        metrics.register_callback(
-            "pending_pdus",
-            lambda: sum(map(len, pdus.values())),
-        )
-        metrics.register_callback(
-            "pending_edus",
-            lambda: sum(map(len, edus.values())),
-        )
-
-        # destination -> list of tuple(failure, deferred)
-        self.pending_failures_by_dest = {}
-
-        # HACK to get unique tx id
-        self._next_txn_id = int(self._clock.time_msec())
-
-    def can_send_to(self, destination):
-        """Can we send messages to the given server?
-
-        We can't send messages to ourselves. If we are running on localhost
-        then we can only federation with other servers running on localhost.
-        Otherwise we only federate with servers on a public domain.
-
-        Args:
-            destination(str): The server we are possibly trying to send to.
-        Returns:
-            bool: True if we can send to the server.
-        """
-
-        if destination == self.server_name:
-            return False
-        if self.server_name.startswith("localhost"):
-            return destination.startswith("localhost")
-        else:
-            return not destination.startswith("localhost")
-
-    @defer.inlineCallbacks
-    def enqueue_pdu(self, pdu, destinations, order):
-        # We loop through all destinations to see whether we already have
-        # a transaction in progress. If we do, stick it in the pending_pdus
-        # table and we'll get back to it later.
-
-        destinations = set(destinations)
-        destinations = set(
-            dest for dest in destinations if self.can_send_to(dest)
-        )
-
-        logger.debug("Sending to: %s", str(destinations))
-
-        if not destinations:
-            return
-
-        deferreds = []
-
-        for destination in destinations:
-            deferred = defer.Deferred()
-            self.pending_pdus_by_dest.setdefault(destination, []).append(
-                (pdu, deferred, order)
-            )
-
-            def chain(failure):
-                if not deferred.called:
-                    deferred.errback(failure)
-
-            def log_failure(f):
-                logger.warn("Failed to send pdu to %s: %s", destination, f.value)
-
-            deferred.addErrback(log_failure)
-
-            with PreserveLoggingContext():
-                self._attempt_new_transaction(destination).addErrback(chain)
-
-            deferreds.append(deferred)
-
-        yield defer.DeferredList(deferreds, consumeErrors=True)
-
-    # NO inlineCallbacks
-    def enqueue_edu(self, edu):
-        destination = edu.destination
-
-        if not self.can_send_to(destination):
-            return
-
-        deferred = defer.Deferred()
-        self.pending_edus_by_dest.setdefault(destination, []).append(
-            (edu, deferred)
-        )
-
-        def chain(failure):
-            if not deferred.called:
-                deferred.errback(failure)
-
-        def log_failure(f):
-            logger.warn("Failed to send edu to %s: %s", destination, f.value)
-
-        deferred.addErrback(log_failure)
-
-        with PreserveLoggingContext():
-            self._attempt_new_transaction(destination).addErrback(chain)
-
-        return deferred
-
-    @defer.inlineCallbacks
-    def enqueue_failure(self, failure, destination):
-        if destination == self.server_name or destination == "localhost":
-            return
-
-        deferred = defer.Deferred()
-
-        if not self.can_send_to(destination):
-            return
-
-        self.pending_failures_by_dest.setdefault(
-            destination, []
-        ).append(
-            (failure, deferred)
-        )
-
-        def chain(f):
-            if not deferred.called:
-                deferred.errback(f)
-
-        def log_failure(f):
-            logger.warn("Failed to send failure to %s: %s", destination, f.value)
-
-        deferred.addErrback(log_failure)
-
-        with PreserveLoggingContext():
-            self._attempt_new_transaction(destination).addErrback(chain)
-
-        yield deferred
-
-    @defer.inlineCallbacks
-    @log_function
-    def _attempt_new_transaction(self, destination):
-        if destination in self.pending_transactions:
-            # XXX: pending_transactions can get stuck on by a never-ending
-            # request at which point pending_pdus_by_dest just keeps growing.
-            # we need application-layer timeouts of some flavour of these
-            # requests
-            logger.debug(
-                "TX [%s] Transaction already in progress",
-                destination
-            )
-            return
-
-        logger.debug("TX [%s] _attempt_new_transaction", destination)
-
-        # list of (pending_pdu, deferred, order)
-        pending_pdus = self.pending_pdus_by_dest.pop(destination, [])
-        pending_edus = self.pending_edus_by_dest.pop(destination, [])
-        pending_failures = self.pending_failures_by_dest.pop(destination, [])
-
-        if pending_pdus:
-            logger.debug("TX [%s] len(pending_pdus_by_dest[dest]) = %d",
-                         destination, len(pending_pdus))
-
-        if not pending_pdus and not pending_edus and not pending_failures:
-            logger.debug("TX [%s] Nothing to send", destination)
-            return
-
-        # Sort based on the order field
-        pending_pdus.sort(key=lambda t: t[2])
-
-        pdus = [x[0] for x in pending_pdus]
-        edus = [x[0] for x in pending_edus]
-        failures = [x[0].get_dict() for x in pending_failures]
-        deferreds = [
-            x[1]
-            for x in pending_pdus + pending_edus + pending_failures
-        ]
-
-        try:
-            self.pending_transactions[destination] = 1
-
-            txn_id = str(self._next_txn_id)
-
-            limiter = yield get_retry_limiter(
-                destination,
-                self._clock,
-                self.store,
-            )
-
-            logger.debug(
-                "TX [%s] {%s} Attempting new transaction"
-                " (pdus: %d, edus: %d, failures: %d)",
-                destination, txn_id,
-                len(pending_pdus),
-                len(pending_edus),
-                len(pending_failures)
-            )
-
-            logger.debug("TX [%s] Persisting transaction...", destination)
-
-            transaction = Transaction.create_new(
-                origin_server_ts=int(self._clock.time_msec()),
-                transaction_id=txn_id,
-                origin=self.server_name,
-                destination=destination,
-                pdus=pdus,
-                edus=edus,
-                pdu_failures=failures,
-            )
-
-            self._next_txn_id += 1
-
-            yield self.transaction_actions.prepare_to_send(transaction)
-
-            logger.debug("TX [%s] Persisted transaction", destination)
-            logger.info(
-                "TX [%s] {%s} Sending transaction [%s],"
-                " (PDUs: %d, EDUs: %d, failures: %d)",
-                destination, txn_id,
-                transaction.transaction_id,
-                len(pending_pdus),
-                len(pending_edus),
-                len(pending_failures),
-            )
-
-            with limiter:
-                # Actually send the transaction
-
-                # FIXME (erikj): This is a bit of a hack to make the Pdu age
-                # keys work
-                def json_data_cb():
-                    data = transaction.get_dict()
-                    now = int(self._clock.time_msec())
-                    if "pdus" in data:
-                        for p in data["pdus"]:
-                            if "age_ts" in p:
-                                unsigned = p.setdefault("unsigned", {})
-                                unsigned["age"] = now - int(p["age_ts"])
-                                del p["age_ts"]
-                    return data
-
-                try:
-                    response = yield self.transport_layer.send_transaction(
-                        transaction, json_data_cb
-                    )
-                    code = 200
-
-                    if response:
-                        for e_id, r in response.get("pdus", {}).items():
-                            if "error" in r:
-                                logger.warn(
-                                    "Transaction returned error for %s: %s",
-                                    e_id, r,
-                                )
-                except HttpResponseException as e:
-                    code = e.code
-                    response = e.response
-
-                logger.info(
-                    "TX [%s] {%s} got %d response",
-                    destination, txn_id, code
-                )
-
-                logger.debug("TX [%s] Sent transaction", destination)
-                logger.debug("TX [%s] Marking as delivered...", destination)
-
-            yield self.transaction_actions.delivered(
-                transaction, code, response
-            )
-
-            logger.debug("TX [%s] Marked as delivered", destination)
-
-            logger.debug("TX [%s] Yielding to callbacks...", destination)
-
-            for deferred in deferreds:
-                if code == 200:
-                    deferred.callback(None)
-                else:
-                    deferred.errback(RuntimeError("Got status %d" % code))
-
-                # Ensures we don't continue until all callbacks on that
-                # deferred have fired
-                try:
-                    yield deferred
-                except:
-                    pass
-
-            logger.debug("TX [%s] Yielded to callbacks", destination)
-        except NotRetryingDestination:
-            logger.info(
-                "TX [%s] not ready for retry yet - "
-                "dropping transaction for now",
-                destination,
-            )
-        except RuntimeError as e:
-            # We capture this here as there as nothing actually listens
-            # for this finishing functions deferred.
-            logger.warn(
-                "TX [%s] Problem in _attempt_transaction: %s",
-                destination,
-                e,
-            )
-        except Exception as e:
-            # We capture this here as there as nothing actually listens
-            # for this finishing functions deferred.
-            logger.warn(
-                "TX [%s] Problem in _attempt_transaction: %s",
-                destination,
-                e,
-            )
-
-            for deferred in deferreds:
-                if not deferred.called:
-                    deferred.errback(e)
-
-        finally:
-            # We want to be *very* sure we delete this after we stop processing
-            self.pending_transactions.pop(destination, None)
-
-            # Check to see if there is anything else to send.
-            self._attempt_new_transaction(destination)
--- a/synapse/federation/transport/init.py
+++ b/synapse/federation/transport/init.py
@@ -24,8 +24,6 @@ communicate over a different (albeit still reliable) protocol.
 from .server import TransportLayerServer
 from .client import TransportLayerClient

-from synapse.util.ratelimitutils import FederationRateLimiter
-

 class TransportLayer(TransportLayerServer, TransportLayerClient):
    """This is a basic implementation of the transport layer that translates
@@ -57,18 +55,8 @@ class TransportLayer(TransportLayerServer, TransportLayerClient):
                send requests
        """
        self.keyring = homeserver.get_keyring()
-        self.clock = homeserver.get_clock()
        self.server_name = server_name
        self.server = server
        self.client = client
        self.request_handler = None
        self.received_handler = None
-
-        self.ratelimiter = FederationRateLimiter(
-            self.clock,
-            window_size=homeserver.config.federation_rc_window_size,
-            sleep_limit=homeserver.config.federation_rc_sleep_limit,
-            sleep_msec=homeserver.config.federation_rc_sleep_delay,
-            reject_limit=homeserver.config.federation_rc_reject_limit,
-            concurrent_requests=homeserver.config.federation_rc_concurrent,
-        )
--- a/synapse/federation/transport/client.py
+++ b/synapse/federation/transport/client.py
@@ -19,6 +19,7 @@ from synapse.api.urls import FEDERATION_PREFIX as PREFIX
 from synapse.util.logutils import log_function

 import logging
+import json


 logger = logging.getLogger(__name__)
@@ -50,15 +51,13 @@ class TransportLayerClient(object):
        )

    @log_function
-    def get_event(self, destination, event_id, timeout=None):
+    def get_event(self, destination, event_id):
        """ Requests the pdu with give id and origin from the given server.

        Args:
            destination (str): The host name of the remote home server we want
                to get the state from.
            event_id (str): The id of the event being requested.
-            timeout (int): How long to try (in ms) the destination for before
-                giving up. None indicates no timeout.

        Returns:
            Deferred: Results in a dict received from the remote homeserver.
@@ -67,7 +66,7 @@ class TransportLayerClient(object):
                     destination, event_id)

        path = PREFIX + "/event/%s/" % (event_id, )
-        return self.client.get_json(destination, path=path, timeout=timeout)
+        return self.client.get_json(destination, path=path)

    @log_function
    def backfill(self, destination, room_id, event_tuples, limit):
@@ -130,7 +129,7 @@ class TransportLayerClient(object):
        # generated by the json_data_callback.
        json_data = transaction.get_dict()

-        response = yield self.client.put_json(
+        code, response = yield self.client.put_json(
            transaction.destination,
            path=PREFIX + "/send/%s/" % transaction.transaction_id,
            data=json_data,
@@ -138,105 +137,79 @@ class TransportLayerClient(object):
        )

        logger.debug(
-            "send_data dest=%s, txid=%s, got response: 200",
-            transaction.destination, transaction.transaction_id,
+            "send_data dest=%s, txid=%s, got response: %d",
+            transaction.destination, transaction.transaction_id, code
        )

-        defer.returnValue(response)
+        defer.returnValue((code, response))

    @defer.inlineCallbacks
    @log_function
    def make_query(self, destination, query_type, args, retry_on_dns_fail):
        path = PREFIX + "/query/%s" % query_type

-        content = yield self.client.get_json(
+        response = yield self.client.get_json(
            destination=destination,
            path=path,
            args=args,
            retry_on_dns_fail=retry_on_dns_fail,
        )

-        defer.returnValue(content)
+        defer.returnValue(response)

    @defer.inlineCallbacks
    @log_function
    def make_join(self, destination, room_id, user_id, retry_on_dns_fail=True):
        path = PREFIX + "/make_join/%s/%s" % (room_id, user_id)

-        content = yield self.client.get_json(
+        response = yield self.client.get_json(
            destination=destination,
            path=path,
            retry_on_dns_fail=retry_on_dns_fail,
        )

-        defer.returnValue(content)
+        defer.returnValue(response)

    @defer.inlineCallbacks
    @log_function
    def send_join(self, destination, room_id, event_id, content):
        path = PREFIX + "/send_join/%s/%s" % (room_id, event_id)

-        response = yield self.client.put_json(
+        code, content = yield self.client.put_json(
            destination=destination,
            path=path,
            data=content,
        )

-        defer.returnValue(response)
+        if not 200 <= code < 300:
+            raise RuntimeError("Got %d from send_join", code)
+
+        defer.returnValue(json.loads(content))

    @defer.inlineCallbacks
    @log_function
    def send_invite(self, destination, room_id, event_id, content):
        path = PREFIX + "/invite/%s/%s" % (room_id, event_id)

-        response = yield self.client.put_json(
+        code, content = yield self.client.put_json(
            destination=destination,
            path=path,
            data=content,
        )

-        defer.returnValue(response)
+        if not 200 <= code < 300:
+            raise RuntimeError("Got %d from send_invite", code)
+
+        defer.returnValue(json.loads(content))

    @defer.inlineCallbacks
    @log_function
    def get_event_auth(self, destination, room_id, event_id):
        path = PREFIX + "/event_auth/%s/%s" % (room_id, event_id)

-        content = yield self.client.get_json(
+        response = yield self.client.get_json(
            destination=destination,
            path=path,
        )

-        defer.returnValue(content)
-
-    @defer.inlineCallbacks
-    @log_function
-    def send_query_auth(self, destination, room_id, event_id, content):
-        path = PREFIX + "/query_auth/%s/%s" % (room_id, event_id)
-
-        content = yield self.client.post_json(
-            destination=destination,
-            path=path,
-            data=content,
-        )
-
-        defer.returnValue(content)
-
-    @defer.inlineCallbacks
-    @log_function
-    def get_missing_events(self, destination, room_id, earliest_events,
-                           latest_events, limit, min_depth):
-        path = PREFIX + "/get_missing_events/%s" % (room_id,)
-
-        content = yield self.client.post_json(
-            destination=destination,
-            path=path,
-            data={
-                "limit": int(limit),
-                "min_depth": int(min_depth),
-                "earliest_events": earliest_events,
-                "latest_events": latest_events,
-            }
-        )
-
-        defer.returnValue(content)
+        defer.returnValue(response)
--- a/synapse/federation/transport/server.py
+++ b/synapse/federation/transport/server.py
@@ -19,9 +19,8 @@ from synapse.api.urls import FEDERATION_PREFIX as PREFIX
 from synapse.api.errors import Codes, SynapseError
 from synapse.util.logutils import log_function

-import functools
 import logging
-import simplejson as json
+import json
 import re


@@ -31,9 +30,8 @@ logger = logging.getLogger(__name__)
 class TransportLayerServer(object):
    """Handles incoming federation HTTP requests"""

-    # A method just so we can pass 'self' as the authenticator to the Servlets
    @defer.inlineCallbacks
-    def authenticate_request(self, request):
+    def _authenticate_request(self, request):
        json_request = {
            "method": request.method,
            "uri": request.uri,
@@ -44,7 +42,7 @@ class TransportLayerServer(object):
        content = None
        origin = None

-        if request.method in ["PUT", "POST"]:
+        if request.method == "PUT":
            # TODO: Handle other method types? other content types?
            try:
                content_bytes = request.content.read()
@@ -95,6 +93,20 @@ class TransportLayerServer(object):

        defer.returnValue((origin, content))

+    def _with_authentication(self, handler):
+        @defer.inlineCallbacks
+        def new_handler(request, *args, **kwargs):
+            try:
+                (origin, content) = yield self._authenticate_request(request)
+                response = yield handler(
+                    origin, content, request.args, *args, **kwargs
+                )
+            except:
+                logger.exception("_authenticate_request failed")
+                raise
+            defer.returnValue(response)
+        return new_handler
+
    @log_function
    def register_received_handler(self, handler):
        """ Register a handler that will be fired when we receive data.
@@ -102,12 +114,14 @@ class TransportLayerServer(object):
        Args:
            handler (TransportReceivedHandler)
        """
-        FederationSendServlet(
-            handler,
-            authenticator=self,
-            ratelimiter=self.ratelimiter,
-            server_name=self.server_name,
-        ).register(self.server)
+        self.received_handler = handler
+
+        # This is when someone is trying to send us a bunch of data.
+        self.server.register_path(
+            "PUT",
+            re.compile("^" + PREFIX + "/send/([^/]*)/$"),
+            self._with_authentication(self._on_send_request)
+        )

    @log_function
    def register_request_handler(self, handler):
@@ -116,65 +130,114 @@ class TransportLayerServer(object):
        Args:
            handler (TransportRequestHandler)
        """
-        for servletclass in SERVLET_CLASSES:
-            servletclass(
-                handler,
-                authenticator=self,
-                ratelimiter=self.ratelimiter,
-            ).register(self.server)
+        self.request_handler = handler

+        # This is for when someone asks us for everything since version X
+        self.server.register_path(
+            "GET",
+            re.compile("^" + PREFIX + "/pull/$"),
+            self._with_authentication(
+                lambda origin, content, query:
+                handler.on_pull_request(query["origin"][0], query["v"])
+            )
+        )

-class BaseFederationServlet(object):
-    def __init__(self, handler, authenticator, ratelimiter):
-        self.handler = handler
-        self.authenticator = authenticator
-        self.ratelimiter = ratelimiter
+        # This is when someone asks for a data item for a given server
+        # data_id pair.
+        self.server.register_path(
+            "GET",
+            re.compile("^" + PREFIX + "/event/([^/]*)/$"),
+            self._with_authentication(
+                lambda origin, content, query, event_id:
+                handler.on_pdu_request(origin, event_id)
+            )
+        )

-    def _wrap(self, code):
-        authenticator = self.authenticator
-        ratelimiter = self.ratelimiter
+        # This is when someone asks for all data for a given context.
+        self.server.register_path(
+            "GET",
+            re.compile("^" + PREFIX + "/state/([^/]*)/$"),
+            self._with_authentication(
+                lambda origin, content, query, context:
+                handler.on_context_state_request(
+                    origin,
+                    context,
+                    query.get("event_id", [None])[0],
+                )
+            )
+        )

-        @defer.inlineCallbacks
-        @functools.wraps(code)
-        def new_code(request, *args, **kwargs):
-            try:
-                (origin, content) = yield authenticator.authenticate_request(request)
-                with ratelimiter.ratelimit(origin) as d:
-                    yield d
-                    response = yield code(
-                        origin, content, request.args, *args, **kwargs
-                    )
-            except:
-                logger.exception("authenticate_request failed")
-                raise
-            defer.returnValue(response)
+        self.server.register_path(
+            "GET",
+            re.compile("^" + PREFIX + "/backfill/([^/]*)/$"),
+            self._with_authentication(
+                lambda origin, content, query, context:
+                self._on_backfill_request(
+                    origin, context, query["v"], query["limit"]
+                )
+            )
+        )

-        # Extra logic that functools.wraps() doesn't finish
-        new_code.__self__ = code.__self__
+        # This is when we receive a server-server Query
+        self.server.register_path(
+            "GET",
+            re.compile("^" + PREFIX + "/query/([^/]*)$"),
+            self._with_authentication(
+                lambda origin, content, query, query_type:
+                handler.on_query_request(
+                    query_type,
+                    {k: v[0].decode("utf-8") for k, v in query.items()}
+                )
+            )
+        )

-        return new_code
+        self.server.register_path(
+            "GET",
+            re.compile("^" + PREFIX + "/make_join/([^/]*)/([^/]*)$"),
+            self._with_authentication(
+                lambda origin, content, query, context, user_id:
+                self._on_make_join_request(
+                    origin, content, query, context, user_id
+                )
+            )
+        )

-    def register(self, server):
-        pattern = re.compile("^" + PREFIX + self.PATH + "$")
+        self.server.register_path(
+            "GET",
+            re.compile("^" + PREFIX + "/event_auth/([^/]*)/([^/]*)$"),
+            self._with_authentication(
+                lambda origin, content, query, context, event_id:
+                handler.on_event_auth(
+                    origin, context, event_id,
+                )
+            )
+        )

-        for method in ("GET", "PUT", "POST"):
-            code = getattr(self, "on_%s" % (method), None)
-            if code is None:
-                continue
+        self.server.register_path(
+            "PUT",
+            re.compile("^" + PREFIX + "/send_join/([^/]*)/([^/]*)$"),
+            self._with_authentication(
+                lambda origin, content, query, context, event_id:
+                self._on_send_join_request(
+                    origin, content, query,
+                )
+            )
+        )

-            server.register_path(method, pattern, self._wrap(code))
+        self.server.register_path(
+            "PUT",
+            re.compile("^" + PREFIX + "/invite/([^/]*)/([^/]*)$"),
+            self._with_authentication(
+                lambda origin, content, query, context, event_id:
+                self._on_invite_request(
+                    origin, content, query,
+                )
+            )
+        )

-
-class FederationSendServlet(BaseFederationServlet):
-    PATH = "/send/([^/]*)/"
-
-    def __init__(self, handler, server_name, **kwargs):
-        super(FederationSendServlet, self).__init__(handler, **kwargs)
-        self.server_name = server_name
-
-    # This is when someone is trying to send us a bunch of data.
    @defer.inlineCallbacks
-    def on_PUT(self, origin, content, query, transaction_id):
+    @log_function
+    def _on_send_request(self, origin, content, query, transaction_id):
        """ Called on PUT /send/<transaction_id>/

        Args:
@@ -196,14 +259,6 @@ class FederationSendServlet(BaseFederationServlet):
                transaction_id, str(transaction_data)
            )

-            logger.info(
-                "Received txn %s from %s. (PDUs: %d, EDUs: %d, failures: %d)",
-                transaction_id, origin,
-                len(transaction_data.get("pdus", [])),
-                len(transaction_data.get("edus", [])),
-                len(transaction_data.get("failures", [])),
-            )
-
            # We should ideally be getting this from the security layer.
            # origin = body["origin"]

@@ -220,7 +275,8 @@ class FederationSendServlet(BaseFederationServlet):
            return

        try:
-            code, response = yield self.handler.on_incoming_transaction(
+            handler = self.received_handler
+            code, response = yield handler.on_incoming_transaction(
                transaction_data
            )
        except:
@@ -229,145 +285,43 @@ class FederationSendServlet(BaseFederationServlet):

        defer.returnValue((code, response))

-
-class FederationPullServlet(BaseFederationServlet):
-    PATH = "/pull/"
-
-    # This is for when someone asks us for everything since version X
-    def on_GET(self, origin, content, query):
-        return self.handler.on_pull_request(query["origin"][0], query["v"])
-
-
-class FederationEventServlet(BaseFederationServlet):
-    PATH = "/event/([^/]*)/"
-
-    # This is when someone asks for a data item for a given server data_id pair.
-    def on_GET(self, origin, content, query, event_id):
-        return self.handler.on_pdu_request(origin, event_id)
-
-
-class FederationStateServlet(BaseFederationServlet):
-    PATH = "/state/([^/]*)/"
-
-    # This is when someone asks for all data for a given context.
-    def on_GET(self, origin, content, query, context):
-        return self.handler.on_context_state_request(
-            origin,
-            context,
-            query.get("event_id", [None])[0],
-        )
-
-
-class FederationBackfillServlet(BaseFederationServlet):
-    PATH = "/backfill/([^/]*)/"
-
-    def on_GET(self, origin, content, query, context):
-        versions = query["v"]
-        limits = query["limit"]
-
+    @log_function
+    def _on_backfill_request(self, origin, context, v_list, limits):
        if not limits:
-            return defer.succeed((400, {"error": "Did not include limit param"}))
+            return defer.succeed(
+                (400, {"error": "Did not include limit param"})
+            )

        limit = int(limits[-1])

-        return self.handler.on_backfill_request(origin, context, versions, limit)
+        versions = v_list

-
-class FederationQueryServlet(BaseFederationServlet):
-    PATH = "/query/([^/]*)"
-
-    # This is when we receive a server-server Query
-    def on_GET(self, origin, content, query, query_type):
-        return self.handler.on_query_request(
-            query_type,
-            {k: v[0].decode("utf-8") for k, v in query.items()}
+        return self.request_handler.on_backfill_request(
+            origin, context, versions, limit
        )

-
-class FederationMakeJoinServlet(BaseFederationServlet):
-    PATH = "/make_join/([^/]*)/([^/]*)"
-
    @defer.inlineCallbacks
-    def on_GET(self, origin, content, query, context, user_id):
-        content = yield self.handler.on_make_join_request(context, user_id)
-        defer.returnValue((200, content))
-
-
-class FederationEventAuthServlet(BaseFederationServlet):
-    PATH = "/event_auth/([^/]*)/([^/]*)"
-
-    def on_GET(self, origin, content, query, context, event_id):
-        return self.handler.on_event_auth(origin, context, event_id)
-
-
-class FederationSendJoinServlet(BaseFederationServlet):
-    PATH = "/send_join/([^/]*)/([^/]*)"
-
-    @defer.inlineCallbacks
-    def on_PUT(self, origin, content, query, context, event_id):
-        # TODO(paul): assert that context/event_id parsed from path actually
-        #   match those given in content
-        content = yield self.handler.on_send_join_request(origin, content)
-        defer.returnValue((200, content))
-
-
-class FederationInviteServlet(BaseFederationServlet):
-    PATH = "/invite/([^/]*)/([^/]*)"
-
-    @defer.inlineCallbacks
-    def on_PUT(self, origin, content, query, context, event_id):
-        # TODO(paul): assert that context/event_id parsed from path actually
-        #   match those given in content
-        content = yield self.handler.on_invite_request(origin, content)
-        defer.returnValue((200, content))
-
-
-class FederationQueryAuthServlet(BaseFederationServlet):
-    PATH = "/query_auth/([^/]*)/([^/]*)"
-
-    @defer.inlineCallbacks
-    def on_POST(self, origin, content, query, context, event_id):
-        new_content = yield self.handler.on_query_auth_request(
-            origin, content, event_id
+    @log_function
+    def _on_make_join_request(self, origin, content, query, context, user_id):
+        content = yield self.request_handler.on_make_join_request(
+            context, user_id,
        )
-
-        defer.returnValue((200, new_content))
-
-
-class FederationGetMissingEventsServlet(BaseFederationServlet):
-    # TODO(paul): Why does this path alone end with "/?" optional?
-    PATH = "/get_missing_events/([^/]*)/?"
+        defer.returnValue((200, content))

    @defer.inlineCallbacks
-    def on_POST(self, origin, content, query, room_id):
-        limit = int(content.get("limit", 10))
-        min_depth = int(content.get("min_depth", 0))
-        earliest_events = content.get("earliest_events", [])
-        latest_events = content.get("latest_events", [])
-
-        content = yield self.handler.on_get_missing_events(
-            origin,
-            room_id=room_id,
-            earliest_events=earliest_events,
-            latest_events=latest_events,
-            min_depth=min_depth,
-            limit=limit,
+    @log_function
+    def _on_send_join_request(self, origin, content, query):
+        content = yield self.request_handler.on_send_join_request(
+            origin, content,
        )

        defer.returnValue((200, content))

+    @defer.inlineCallbacks
+    @log_function
+    def _on_invite_request(self, origin, content, query):
+        content = yield self.request_handler.on_invite_request(
+            origin, content,
+        )

-SERVLET_CLASSES = (
-    FederationPullServlet,
-    FederationEventServlet,
-    FederationStateServlet,
-    FederationBackfillServlet,
-    FederationQueryServlet,
-    FederationMakeJoinServlet,
-    FederationEventServlet,
-    FederationSendJoinServlet,
-    FederationInviteServlet,
-    FederationQueryAuthServlet,
-    FederationGetMissingEventsServlet,
-    FederationEventAuthServlet,
-)
+        defer.returnValue((200, content))
--- a/synapse/handlers/init.py
+++ b/synapse/handlers/init.py
@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-from synapse.appservice.scheduler import AppServiceScheduler
-from synapse.appservice.api import ApplicationServiceApi
 from .register import RegistrationHandler
 from .room import (
    RoomCreationHandler, RoomMemberHandler, RoomListHandler
@@ -28,10 +26,6 @@ from .presence import PresenceHandler
 from .directory import DirectoryHandler
 from .typing import TypingNotificationHandler
 from .admin import AdminHandler
-from .appservice import ApplicationServicesHandler
-from .sync import SyncHandler
-from .auth import AuthHandler
-from .identity import IdentityHandler


 class Handlers(object):
@@ -57,14 +51,3 @@ class Handlers(object):
        self.directory_handler = DirectoryHandler(hs)
        self.typing_notification_handler = TypingNotificationHandler(hs)
        self.admin_handler = AdminHandler(hs)
-        asapi = ApplicationServiceApi(hs)
-        self.appservice_handler = ApplicationServicesHandler(
-            hs, asapi, AppServiceScheduler(
-                clock=hs.get_clock(),
-                store=hs.get_datastore(),
-                as_api=asapi
-            )
-        )
-        self.sync_handler = SyncHandler(hs)
-        self.auth_handler = AuthHandler(hs)
-        self.identity_handler = IdentityHandler(hs)
--- a/synapse/handlers/_base.py
+++ b/synapse/handlers/_base.py
@@ -16,11 +16,9 @@
 from twisted.internet import defer

 from synapse.api.errors import LimitExceededError, SynapseError
+from synapse.util.async import run_on_reactor
 from synapse.crypto.event_signing import add_hashes_and_signatures
 from synapse.api.constants import Membership, EventTypes
-from synapse.types import UserID
-
-from synapse.util.logcontext import PreserveLoggingContext

 import logging

@@ -59,6 +57,8 @@ class BaseHandler(object):

    @defer.inlineCallbacks
    def _create_new_client_event(self, builder):
+        yield run_on_reactor()
+
        latest_ret = yield self.store.get_latest_events_in_room(
            builder.room_id,
        )
@@ -89,8 +89,8 @@ class BaseHandler(object):
        event = builder.build()

        logger.debug(
-            "Created event %s with current state: %s",
-            event.event_id, context.current_state,
+            "Created event %s with auth_events: %s, current state: %s",
+            event.event_id, context.auth_events, context.current_state,
        )

        defer.returnValue(
@@ -100,20 +100,20 @@ class BaseHandler(object):
    @defer.inlineCallbacks
    def handle_new_client_event(self, event, context, extra_destinations=[],
                                extra_users=[], suppress_auth=False):
+        yield run_on_reactor()
+
        # We now need to go and hit out to wherever we need to hit out to.

        if not suppress_auth:
-            self.auth.check(event, auth_events=context.current_state)
+            self.auth.check(event, auth_events=context.auth_events)

-        (event_stream_id, max_stream_id) = yield self.store.persist_event(
-            event, context=context
-        )
+        yield self.store.persist_event(event, context=context)

        federation_handler = self.hs.get_handlers().federation_handler

        if event.type == EventTypes.Member:
            if event.content["membership"] == Membership.INVITE:
-                invitee = UserID.from_string(event.state_key)
+                invitee = self.hs.parse_userid(event.state_key)
                if not self.hs.is_mine(invitee):
                    # TODO: Can we add signature from remote server in a nicer
                    # way? If we have been invited by a remote server, we need
@@ -134,28 +134,15 @@ class BaseHandler(object):
                if k[0] == EventTypes.Member:
                    if s.content["membership"] == Membership.JOIN:
                        destinations.add(
-                            UserID.from_string(s.state_key).domain
+                            self.hs.parse_userid(s.state_key).domain
                        )
            except SynapseError:
                logger.warn(
                    "Failed to get destination from event %s", s.event_id
                )

-        with PreserveLoggingContext():
-            # Don't block waiting on waking up all the listeners.
-            notify_d = self.notifier.on_new_room_event(
-                event, event_stream_id, max_stream_id,
-                extra_users=extra_users
-            )
+        yield self.notifier.on_new_room_event(event, extra_users=extra_users)

-        def log_failure(f):
-            logger.warn(
-                "Failed to notify about %s: %s",
-                event.event_id, f.value
-            )
-
-        notify_d.addErrback(log_failure)
-
-        federation_handler.handle_new_event(
+        yield federation_handler.handle_new_event(
            event, destinations=destinations,
        )
--- a/synapse/handlers/appservice.py
+++ b/synapse/handlers/appservice.py
@@ -1,195 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-
-from twisted.internet import defer
-
-from synapse.api.constants import EventTypes
-from synapse.appservice import ApplicationService
-from synapse.types import UserID
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-def log_failure(failure):
-    logger.error(
-        "Application Services Failure",
-        exc_info=(
-            failure.type,
-            failure.value,
-            failure.getTracebackObject()
-        )
-    )
-
-
-# NB: Purposefully not inheriting BaseHandler since that contains way too much
-# setup code which this handler does not need or use. This makes testing a lot
-# easier.
-class ApplicationServicesHandler(object):
-
-    def __init__(self, hs, appservice_api, appservice_scheduler):
-        self.store = hs.get_datastore()
-        self.hs = hs
-        self.appservice_api = appservice_api
-        self.scheduler = appservice_scheduler
-        self.started_scheduler = False
-
-    @defer.inlineCallbacks
-    def notify_interested_services(self, event):
-        """Notifies (pushes) all application services interested in this event.
-
-        Pushing is done asynchronously, so this method won't block for any
-        prolonged length of time.
-
-        Args:
-            event(Event): The event to push out to interested services.
-        """
-        # Gather interested services
-        services = yield self._get_services_for_event(event)
-        if len(services) == 0:
-            return  # no services need notifying
-
-        # Do we know this user exists? If not, poke the user query API for
-        # all services which match that user regex. This needs to block as these
-        # user queries need to be made BEFORE pushing the event.
-        yield self._check_user_exists(event.sender)
-        if event.type == EventTypes.Member:
-            yield self._check_user_exists(event.state_key)
-
-        if not self.started_scheduler:
-            self.scheduler.start().addErrback(log_failure)
-            self.started_scheduler = True
-
-        # Fork off pushes to these services
-        for service in services:
-            self.scheduler.submit_event_for_as(service, event)
-
-    @defer.inlineCallbacks
-    def query_user_exists(self, user_id):
-        """Check if any application service knows this user_id exists.
-
-        Args:
-            user_id(str): The user to query if they exist on any AS.
-        Returns:
-            True if this user exists on at least one application service.
-        """
-        user_query_services = yield self._get_services_for_user(
-            user_id=user_id
-        )
-        for user_service in user_query_services:
-            is_known_user = yield self.appservice_api.query_user(
-                user_service, user_id
-            )
-            if is_known_user:
-                defer.returnValue(True)
-        defer.returnValue(False)
-
-    @defer.inlineCallbacks
-    def query_room_alias_exists(self, room_alias):
-        """Check if an application service knows this room alias exists.
-
-        Args:
-            room_alias(RoomAlias): The room alias to query.
-        Returns:
-            namedtuple: with keys "room_id" and "servers" or None if no
-            association can be found.
-        """
-        room_alias_str = room_alias.to_string()
-        alias_query_services = yield self._get_services_for_event(
-            event=None,
-            restrict_to=ApplicationService.NS_ALIASES,
-            alias_list=[room_alias_str]
-        )
-        for alias_service in alias_query_services:
-            is_known_alias = yield self.appservice_api.query_alias(
-                alias_service, room_alias_str
-            )
-            if is_known_alias:
-                # the alias exists now so don't query more ASes.
-                result = yield self.store.get_association_from_room_alias(
-                    room_alias
-                )
-                defer.returnValue(result)
-
-    @defer.inlineCallbacks
-    def _get_services_for_event(self, event, restrict_to="", alias_list=None):
-        """Retrieve a list of application services interested in this event.
-
-        Args:
-            event(Event): The event to check. Can be None if alias_list is not.
-            restrict_to(str): The namespace to restrict regex tests to.
-            alias_list: A list of aliases to get services for. If None, this
-            list is obtained from the database.
-        Returns:
-            list<ApplicationService>: A list of services interested in this
-            event based on the service regex.
-        """
-        member_list = None
-        if hasattr(event, "room_id"):
-            # We need to know the aliases associated with this event.room_id,
-            # if any.
-            if not alias_list:
-                alias_list = yield self.store.get_aliases_for_room(
-                    event.room_id
-                )
-            # We need to know the members associated with this event.room_id,
-            # if any.
-            member_list = yield self.store.get_users_in_room(event.room_id)
-
-        services = yield self.store.get_app_services()
-        interested_list = [
-            s for s in services if (
-                s.is_interested(event, restrict_to, alias_list, member_list)
-            )
-        ]
-        defer.returnValue(interested_list)
-
-    @defer.inlineCallbacks
-    def _get_services_for_user(self, user_id):
-        services = yield self.store.get_app_services()
-        interested_list = [
-            s for s in services if (
-                s.is_interested_in_user(user_id)
-            )
-        ]
-        defer.returnValue(interested_list)
-
-    @defer.inlineCallbacks
-    def _is_unknown_user(self, user_id):
-        user = UserID.from_string(user_id)
-        if not self.hs.is_mine(user):
-            # we don't know if they are unknown or not since it isn't one of our
-            # users. We can't poke ASes.
-            defer.returnValue(False)
-            return
-
-        user_info = yield self.store.get_user_by_id(user_id)
-        if not user_info:
-            defer.returnValue(False)
-            return
-
-        # user not found; could be the AS though, so check.
-        services = yield self.store.get_app_services()
-        service_list = [s for s in services if s.sender == user_id]
-        defer.returnValue(len(service_list) == 0)
-
-    @defer.inlineCallbacks
-    def _check_user_exists(self, user_id):
-        unknown_user = yield self._is_unknown_user(user_id)
-        if unknown_user:
-            exists = yield self.query_user_exists(user_id)
-            defer.returnValue(exists)
-        defer.returnValue(True)
--- a/synapse/handlers/auth.py
+++ b/synapse/handlers/auth.py
@@ -1,277 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2014, 2015 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.
-
-from twisted.internet import defer
-
-from ._base import BaseHandler
-from synapse.api.constants import LoginType
-from synapse.types import UserID
-from synapse.api.errors import LoginError, Codes
-from synapse.http.client import SimpleHttpClient
-from synapse.util.async import run_on_reactor
-
-from twisted.web.client import PartialDownloadError
-
-import logging
-import bcrypt
-import simplejson
-
-import synapse.util.stringutils as stringutils
-
-
-logger = logging.getLogger(__name__)
-
-
-class AuthHandler(BaseHandler):
-
-    def __init__(self, hs):
-        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.DUMMY: self._check_dummy_auth,
-        }
-        self.sessions = {}
-
-    @defer.inlineCallbacks
-    def check_auth(self, flows, clientdict, clientip=None):
-        """
-        Takes a dictionary sent by the client in the login / registration
-        protocol and handles the login flow.
-
-        Args:
-            flows: list of list of stages
-            authdict: The dictionary from the client root level, not the
-                      'auth' key: this method prompts for auth if none is sent.
-        Returns:
-            A tuple of authed, dict, dict 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.
-
-            If authed is false, the first dictionary is the server response to
-            the login request and should be passed back to the client.
-
-            In either case, the second dict contains the parameters for this
-            request (which may have been given only in a previous call).
-        """
-
-        authdict = None
-        sid = None
-        if clientdict and 'auth' in clientdict:
-            authdict = clientdict['auth']
-            del clientdict['auth']
-            if 'session' in authdict:
-                sid = authdict['session']
-        sess = self._get_session_info(sid)
-
-        if len(clientdict) > 0:
-            # This was designed to allow the client to omit the parameters
-            # and just supply the session in subsequent calls so it split
-            # auth between devices by just sharing the session, (eg. so you
-            # could continue registration from your phone having clicked the
-            # email auth link on there). It's probably too open to abuse
-            # because it lets unauthenticated clients store arbitrary objects
-            # on a home server.
-            # sess['clientdict'] = clientdict
-            # self._save_session(sess)
-            pass
-        elif 'clientdict' in sess:
-            clientdict = sess['clientdict']
-
-        if not authdict:
-            defer.returnValue(
-                (False, self._auth_dict_for_flows(flows, sess), clientdict)
-            )
-
-        if 'creds' not in sess:
-            sess['creds'] = {}
-        creds = sess['creds']
-
-        # check auth type currently being presented
-        if 'type' in authdict:
-            if authdict['type'] not in self.checkers:
-                raise LoginError(400, "", Codes.UNRECOGNIZED)
-            result = yield self.checkers[authdict['type']](authdict, clientip)
-            if result:
-                creds[authdict['type']] = result
-                self._save_session(sess)
-
-        for f in flows:
-            if len(set(f) - set(creds.keys())) == 0:
-                logger.info("Auth completed with creds: %r", creds)
-                self._remove_session(sess)
-                defer.returnValue((True, creds, clientdict))
-
-        ret = self._auth_dict_for_flows(flows, sess)
-        ret['completed'] = creds.keys()
-        defer.returnValue((False, ret, clientdict))
-
-    @defer.inlineCallbacks
-    def add_oob_auth(self, stagetype, authdict, clientip):
-        """
-        Adds the result of out-of-band authentication into an existing auth
-        session. Currently used for adding the result of fallback auth.
-        """
-        if stagetype not in self.checkers:
-            raise LoginError(400, "", Codes.MISSING_PARAM)
-        if 'session' not in authdict:
-            raise LoginError(400, "", Codes.MISSING_PARAM)
-
-        sess = self._get_session_info(
-            authdict['session']
-        )
-        if 'creds' not in sess:
-            sess['creds'] = {}
-        creds = sess['creds']
-
-        result = yield self.checkers[stagetype](authdict, clientip)
-        if result:
-            creds[stagetype] = result
-            self._save_session(sess)
-            defer.returnValue(True)
-        defer.returnValue(False)
-
-    @defer.inlineCallbacks
-    def _check_password_auth(self, authdict, _):
-        if "user" not in authdict or "password" not in authdict:
-            raise LoginError(400, "", Codes.MISSING_PARAM)
-
-        user = authdict["user"]
-        password = authdict["password"]
-        if not user.startswith('@'):
-            user = UserID.create(user, self.hs.hostname).to_string()
-
-        user_info = yield self.store.get_user_by_id(user_id=user)
-        if not user_info:
-            logger.warn("Attempted to login as %s but they do not exist", user)
-            raise LoginError(401, "", errcode=Codes.UNAUTHORIZED)
-
-        stored_hash = user_info["password_hash"]
-        if bcrypt.checkpw(password, stored_hash):
-            defer.returnValue(user)
-        else:
-            logger.warn("Failed password login for user %s", user)
-            raise LoginError(401, "", errcode=Codes.UNAUTHORIZED)
-
-    @defer.inlineCallbacks
-    def _check_recaptcha(self, authdict, clientip):
-        try:
-            user_response = authdict["response"]
-        except KeyError:
-            # Client tried to provide captcha but didn't give the parameter:
-            # bad request.
-            raise LoginError(
-                400, "Captcha response is required",
-                errcode=Codes.CAPTCHA_NEEDED
-            )
-
-        logger.info(
-            "Submitting recaptcha response %s with remoteip %s",
-            user_response, clientip
-        )
-
-        # TODO: get this from the homeserver rather than creating a new one for
-        # each request
-        try:
-            client = SimpleHttpClient(self.hs)
-            data = yield client.post_urlencoded_get_json(
-                "https://www.google.com/recaptcha/api/siteverify",
-                args={
-                    'secret': self.hs.config.recaptcha_private_key,
-                    'response': user_response,
-                    'remoteip': clientip,
-                }
-            )
-        except PartialDownloadError as pde:
-            # Twisted is silly
-            data = pde.response
-        resp_body = simplejson.loads(data)
-        if 'success' in resp_body and resp_body['success']:
-            defer.returnValue(True)
-        raise LoginError(401, "", errcode=Codes.UNAUTHORIZED)
-
-    @defer.inlineCallbacks
-    def _check_email_identity(self, authdict, _):
-        yield run_on_reactor()
-
-        if 'threepid_creds' not in authdict:
-            raise LoginError(400, "Missing threepid_creds", Codes.MISSING_PARAM)
-
-        threepid_creds = authdict['threepid_creds']
-        identity_handler = self.hs.get_handlers().identity_handler
-
-        logger.info("Getting validated threepid. threepidcreds: %r" % (threepid_creds,))
-        threepid = yield identity_handler.threepid_from_creds(threepid_creds)
-
-        if not threepid:
-            raise LoginError(401, "", errcode=Codes.UNAUTHORIZED)
-
-        threepid['threepid_creds'] = authdict['threepid_creds']
-
-        defer.returnValue(threepid)
-
-    @defer.inlineCallbacks
-    def _check_dummy_auth(self, authdict, _):
-        yield run_on_reactor()
-        defer.returnValue(True)
-
-    def _get_params_recaptcha(self):
-        return {"public_key": self.hs.config.recaptcha_public_key}
-
-    def _auth_dict_for_flows(self, flows, session):
-        public_flows = []
-        for f in flows:
-            public_flows.append(f)
-
-        get_params = {
-            LoginType.RECAPTCHA: self._get_params_recaptcha,
-        }
-
-        params = {}
-
-        for f in public_flows:
-            for stage in f:
-                if stage in get_params and stage not in params:
-                    params[stage] = get_params[stage]()
-
-        return {
-            "session": session['id'],
-            "flows": [{"stages": f} for f in public_flows],
-            "params": params
-        }
-
-    def _get_session_info(self, session_id):
-        if session_id not in self.sessions:
-            session_id = None
-
-        if not session_id:
-            # create a new session
-            while session_id is None or session_id in self.sessions:
-                session_id = stringutils.random_string(24)
-            self.sessions[session_id] = {
-                "id": session_id,
-            }
-
-        return self.sessions[session_id]
-
-    def _save_session(self, session):
-        # TODO: Persistent storage
-        logger.debug("Saving session %s", session)
-        self.sessions[session["id"]] = session
-
-    def _remove_session(self, session):
-        logger.debug("Removing session %s", session)
-        del self.sessions[session["id"]]
--- a/synapse/handlers/directory.py
+++ b/synapse/handlers/directory.py
@@ -19,10 +19,8 @@ from ._base import BaseHandler

 from synapse.api.errors import SynapseError, Codes, CodeMessageException
 from synapse.api.constants import EventTypes
-from synapse.types import RoomAlias

 import logging
-import string

 logger = logging.getLogger(__name__)

@@ -38,19 +36,18 @@ class DirectoryHandler(BaseHandler):
        )

    @defer.inlineCallbacks
-    def _create_association(self, room_alias, room_id, servers=None):
-        # general association creation for both human users and app services
+    def create_association(self, user_id, room_alias, room_id, servers=None):

-        for wchar in string.whitespace:
-                if wchar in room_alias.localpart:
-                    raise SynapseError(400, "Invalid characters in room alias")
+        # TODO(erikj): Do auth.

        if not self.hs.is_mine(room_alias):
            raise SynapseError(400, "Room alias must be local")
            # TODO(erikj): Change this.

        # TODO(erikj): Add transactions.
+
        # TODO(erikj): Check if there is a current association.
+
        if not servers:
            servers = yield self.store.get_joined_hosts_for_room(room_id)

@@ -63,78 +60,23 @@ class DirectoryHandler(BaseHandler):
            servers
        )

-    @defer.inlineCallbacks
-    def create_association(self, user_id, room_alias, room_id, servers=None):
-        # association creation for human users
-        # TODO(erikj): Do user auth.
-
-        can_create = yield self.can_modify_alias(
-            room_alias,
-            user_id=user_id
-        )
-        if not can_create:
-            raise SynapseError(
-                400, "This alias is reserved by an application service.",
-                errcode=Codes.EXCLUSIVE
-            )
-        yield self._create_association(room_alias, room_id, servers)
-
-    @defer.inlineCallbacks
-    def create_appservice_association(self, service, room_alias, room_id,
-                                      servers=None):
-        if not service.is_interested_in_alias(room_alias.to_string()):
-            raise SynapseError(
-                400, "This application service has not reserved"
-                " this kind of alias.", errcode=Codes.EXCLUSIVE
-            )
-
-        # association creation for app services
-        yield self._create_association(room_alias, room_id, servers)
-
    @defer.inlineCallbacks
    def delete_association(self, user_id, room_alias):
-        # association deletion for human users
-
        # TODO Check if server admin

-        can_delete = yield self.can_modify_alias(
-            room_alias,
-            user_id=user_id
-        )
-        if not can_delete:
-            raise SynapseError(
-                400, "This alias is reserved by an application service.",
-                errcode=Codes.EXCLUSIVE
-            )
-
-        yield self._delete_association(room_alias)
-
-    @defer.inlineCallbacks
-    def delete_appservice_association(self, service, room_alias):
-        if not service.is_interested_in_alias(room_alias.to_string()):
-            raise SynapseError(
-                400,
-                "This application service has not reserved this kind of alias",
-                errcode=Codes.EXCLUSIVE
-            )
-        yield self._delete_association(room_alias)
-
-    @defer.inlineCallbacks
-    def _delete_association(self, room_alias):
        if not self.hs.is_mine(room_alias):
            raise SynapseError(400, "Room alias must be local")

-        yield self.store.delete_room_alias(room_alias)
+        room_id = yield self.store.delete_room_alias(room_alias)

-        # TODO - Looks like _update_room_alias_event has never been implemented
-        # if room_id:
-        #    yield self._update_room_alias_events(user_id, room_id)
+        if room_id:
+            yield self._update_room_alias_events(user_id, room_id)

    @defer.inlineCallbacks
    def get_association(self, room_alias):
        room_id = None
        if self.hs.is_mine(room_alias):
-            result = yield self.get_association_from_room_alias(
+            result = yield self.store.get_association_from_room_alias(
                room_alias
            )

@@ -165,21 +107,12 @@ class DirectoryHandler(BaseHandler):
        if not room_id:
            raise SynapseError(
                404,
-                "Room alias %s not found" % (room_alias.to_string(),),
+                "Room alias %r not found" % (room_alias.to_string(),),
                Codes.NOT_FOUND
            )

        extra_servers = yield self.store.get_joined_hosts_for_room(room_id)
-        servers = set(extra_servers) | set(servers)
-
-        # If this server is in the list of servers, return it first.
-        if self.server_name in servers:
-            servers = (
-                [self.server_name]
-                + [s for s in servers if s != self.server_name]
-            )
-        else:
-            servers = list(servers)
+        servers = list(set(extra_servers) | set(servers))

        defer.returnValue({
            "room_id": room_id,
@@ -189,13 +122,13 @@ class DirectoryHandler(BaseHandler):

    @defer.inlineCallbacks
    def on_directory_query(self, args):
-        room_alias = RoomAlias.from_string(args["room_alias"])
+        room_alias = self.hs.parse_roomalias(args["room_alias"])
        if not self.hs.is_mine(room_alias):
            raise SynapseError(
                400, "Room Alias is not hosted on this Home Server"
            )

-        result = yield self.get_association_from_room_alias(
+        result = yield self.store.get_association_from_room_alias(
            room_alias
        )

@@ -223,37 +156,3 @@ class DirectoryHandler(BaseHandler):
            "sender": user_id,
            "content": {"aliases": aliases},
        }, ratelimit=False)
-
-    @defer.inlineCallbacks
-    def get_association_from_room_alias(self, room_alias):
-        result = yield self.store.get_association_from_room_alias(
-            room_alias
-        )
-        if not result:
-            # Query AS to see if it exists
-            as_handler = self.hs.get_handlers().appservice_handler
-            result = yield as_handler.query_room_alias_exists(room_alias)
-        defer.returnValue(result)
-
-    @defer.inlineCallbacks
-    def can_modify_alias(self, alias, user_id=None):
-        # Any application service "interested" in an alias they are regexing on
-        # can modify the alias.
-        # Users can only modify the alias if ALL the interested services have
-        # non-exclusive locks on the alias (or there are no interested services)
-        services = yield self.store.get_app_services()
-        interested_services = [
-            s for s in services if s.is_interested_in_alias(alias.to_string())
-        ]
-
-        for service in interested_services:
-            if user_id == service.sender:
-                # this user IS the app service so they can do whatever they like
-                defer.returnValue(True)
-                return
-            elif service.is_exclusive_alias(alias.to_string()):
-                # another service has an exclusive lock on this alias.
-                defer.returnValue(False)
-                return
-        # either no interested services, or no service with an exclusive lock
-        defer.returnValue(True)
--- a/synapse/handlers/events.py
+++ b/synapse/handlers/events.py
@@ -15,14 +15,12 @@

 from twisted.internet import defer

+from synapse.util.logcontext import PreserveLoggingContext
 from synapse.util.logutils import log_function
-from synapse.types import UserID
-from synapse.events.utils import serialize_event

 from ._base import BaseHandler

 import logging
-import random


 logger = logging.getLogger(__name__)
@@ -49,45 +47,38 @@ class EventStreamHandler(BaseHandler):
    @defer.inlineCallbacks
    @log_function
    def get_stream(self, auth_user_id, pagin_config, timeout=0,
-                   as_client_event=True, affect_presence=True):
-        auth_user = UserID.from_string(auth_user_id)
+                   as_client_event=True):
+        auth_user = self.hs.parse_userid(auth_user_id)

        try:
-            if affect_presence:
-                if auth_user not in self._streams_per_user:
-                    self._streams_per_user[auth_user] = 0
-                    if auth_user in self._stop_timer_per_user:
-                        try:
-                            self.clock.cancel_call_later(
-                                self._stop_timer_per_user.pop(auth_user)
-                            )
-                        except:
-                            logger.exception("Failed to cancel event timer")
-                    else:
-                        yield self.distributor.fire(
-                            "started_user_eventstream", auth_user
+            if auth_user not in self._streams_per_user:
+                self._streams_per_user[auth_user] = 0
+                if auth_user in self._stop_timer_per_user:
+                    try:
+                        self.clock.cancel_call_later(
+                            self._stop_timer_per_user.pop(auth_user)
                        )
-                self._streams_per_user[auth_user] += 1
+                    except:
+                        logger.exception("Failed to cancel event timer")
+                else:
+                    yield self.distributor.fire(
+                        "started_user_eventstream", auth_user
+                    )
+            self._streams_per_user[auth_user] += 1
+
+            if pagin_config.from_token is None:
+                pagin_config.from_token = None

            rm_handler = self.hs.get_handlers().room_member_handler
-            room_ids = yield rm_handler.get_joined_rooms_for_user(auth_user)
+            room_ids = yield rm_handler.get_rooms_for_user(auth_user)

-            if timeout:
-                # If they've set a timeout set a minimum limit.
-                timeout = max(timeout, 500)
-
-                # Add some randomness to this value to try and mitigate against
-                # thundering herds on restart.
-                timeout = random.randint(int(timeout*0.9), int(timeout*1.1))
-
-            events, tokens = yield self.notifier.get_events_for(
-                auth_user, room_ids, pagin_config, timeout
-            )
-
-            time_now = self.clock.time_msec()
+            with PreserveLoggingContext():
+                events, tokens = yield self.notifier.get_events_for(
+                    auth_user, room_ids, pagin_config, timeout
+                )

            chunks = [
-                serialize_event(e, time_now, as_client_event) for e in events
+                self.hs.serialize_event(e, as_client_event) for e in events
            ]

            chunk = {
@@ -99,29 +90,28 @@ class EventStreamHandler(BaseHandler):
            defer.returnValue(chunk)

        finally:
-            if affect_presence:
-                self._streams_per_user[auth_user] -= 1
-                if not self._streams_per_user[auth_user]:
-                    del self._streams_per_user[auth_user]
+            self._streams_per_user[auth_user] -= 1
+            if not self._streams_per_user[auth_user]:
+                del self._streams_per_user[auth_user]

-                    # 10 seconds of grace to allow the client to reconnect again
-                    #   before we think they're gone
-                    def _later():
-                        logger.debug(
-                            "_later stopped_user_eventstream %s", auth_user
-                        )
-
-                        self._stop_timer_per_user.pop(auth_user, None)
-
-                        return self.distributor.fire(
-                            "stopped_user_eventstream", auth_user
-                        )
-
-                    logger.debug("Scheduling _later: for %s", auth_user)
-                    self._stop_timer_per_user[auth_user] = (
-                        self.clock.call_later(30, _later)
+                # 10 seconds of grace to allow the client to reconnect again
+                #   before we think they're gone
+                def _later():
+                    logger.debug(
+                        "_later stopped_user_eventstream %s", auth_user
                    )

+                    self._stop_timer_per_user.pop(auth_user, None)
+
+                    yield self.distributor.fire(
+                        "stopped_user_eventstream", auth_user
+                    )
+
+                logger.debug("Scheduling _later: for %s", auth_user)
+                self._stop_timer_per_user[auth_user] = (
+                    self.clock.call_later(30, _later)
+                )
+

 class EventHandler(BaseHandler):

--- a/synapse/handlers/federation.py
+++ b/synapse/handlers/federation.py
--- a/synapse/handlers/identity.py
+++ b/synapse/handlers/identity.py
@@ -1,119 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2015 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.
-
-"""Utilities for interacting with Identity Servers"""
-from twisted.internet import defer
-
-from synapse.api.errors import (
-    CodeMessageException
-)
-from ._base import BaseHandler
-from synapse.http.client import SimpleHttpClient
-from synapse.util.async import run_on_reactor
-from synapse.api.errors import SynapseError
-
-import json
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class IdentityHandler(BaseHandler):
-
-    def __init__(self, hs):
-        super(IdentityHandler, self).__init__(hs)
-
-    @defer.inlineCallbacks
-    def threepid_from_creds(self, creds):
-        yield run_on_reactor()
-
-        # TODO: get this from the homeserver rather than creating a new one for
-        # each request
-        http_client = SimpleHttpClient(self.hs)
-        # XXX: make this configurable!
-        # trustedIdServers = ['matrix.org', 'localhost:8090']
-        trustedIdServers = ['matrix.org']
-
-        if 'id_server' in creds:
-            id_server = creds['id_server']
-        elif 'idServer' in creds:
-            id_server = creds['idServer']
-        else:
-            raise SynapseError(400, "No id_server in creds")
-
-        if 'client_secret' in creds:
-            client_secret = creds['client_secret']
-        elif 'clientSecret' in creds:
-            client_secret = creds['clientSecret']
-        else:
-            raise SynapseError(400, "No client_secret in creds")
-
-        if id_server not in trustedIdServers:
-            logger.warn('%s is not a trusted ID server: rejecting 3pid ' +
-                        'credentials', id_server)
-            defer.returnValue(None)
-
-        data = {}
-        try:
-            data = yield http_client.get_json(
-                "https://%s%s" % (
-                    id_server,
-                    "/_matrix/identity/api/v1/3pid/getValidated3pid"
-                ),
-                {'sid': creds['sid'], 'client_secret': client_secret}
-            )
-        except CodeMessageException as e:
-            data = json.loads(e.msg)
-
-        if 'medium' in data:
-            defer.returnValue(data)
-        defer.returnValue(None)
-
-    @defer.inlineCallbacks
-    def bind_threepid(self, creds, mxid):
-        yield run_on_reactor()
-        logger.debug("binding threepid %r to %s", creds, mxid)
-        http_client = SimpleHttpClient(self.hs)
-        data = None
-
-        if 'id_server' in creds:
-            id_server = creds['id_server']
-        elif 'idServer' in creds:
-            id_server = creds['idServer']
-        else:
-            raise SynapseError(400, "No id_server in creds")
-
-        if 'client_secret' in creds:
-            client_secret = creds['client_secret']
-        elif 'clientSecret' in creds:
-            client_secret = creds['clientSecret']
-        else:
-            raise SynapseError(400, "No client_secret in creds")
-
-        try:
-            data = yield http_client.post_urlencoded_get_json(
-                "https://%s%s" % (
-                    id_server, "/_matrix/identity/api/v1/3pid/bind"
-                ),
-                {
-                    'sid': creds['sid'],
-                    'client_secret': client_secret,
-                    'mxid': mxid,
-                }
-            )
-            logger.debug("bound threepid %r to %s", creds, mxid)
-        except CodeMessageException as e:
-            data = json.loads(e.msg)
-        defer.returnValue(data)
--- a/synapse/handlers/login.py
+++ b/synapse/handlers/login.py
@@ -17,6 +17,9 @@ from twisted.internet import defer

 from ._base import BaseHandler
 from synapse.api.errors import LoginError, Codes
+from synapse.http.client import SimpleHttpClient
+from synapse.util.emailutils import EmailException
+import synapse.util.emailutils as emailutils

 import bcrypt
 import logging
@@ -53,7 +56,7 @@ class LoginHandler(BaseHandler):
            logger.warn("Attempted to login as %s but they do not exist", user)
            raise LoginError(403, "", errcode=Codes.FORBIDDEN)

-        stored_hash = user_info["password_hash"]
+        stored_hash = user_info[0]["password_hash"]
        if bcrypt.checkpw(password, stored_hash):
            # generate an access token and store it.
            token = self.reg_handler._generate_token(user)
@@ -65,19 +68,44 @@ class LoginHandler(BaseHandler):
            raise LoginError(403, "", errcode=Codes.FORBIDDEN)

    @defer.inlineCallbacks
-    def set_password(self, user_id, newpassword, token_id=None):
-        password_hash = bcrypt.hashpw(newpassword, bcrypt.gensalt())
-
-        yield self.store.user_set_password_hash(user_id, password_hash)
-        yield self.store.user_delete_access_tokens_apart_from(user_id, token_id)
-        yield self.hs.get_pusherpool().remove_pushers_by_user_access_token(
-            user_id, token_id
-        )
-        yield self.store.flush_user(user_id)
+    def reset_password(self, user_id, email):
+        is_valid = yield self._check_valid_association(user_id, email)
+        logger.info("reset_password user=%s email=%s valid=%s", user_id, email,
+                    is_valid)
+        if is_valid:
+            try:
+                # send an email out
+                emailutils.send_email(
+                    smtp_server=self.hs.config.email_smtp_server,
+                    from_addr=self.hs.config.email_from_address,
+                    to_addr=email,
+                    subject="Password Reset",
+                    body="TODO."
+                )
+            except EmailException as e:
+                logger.exception(e)

    @defer.inlineCallbacks
-    def add_threepid(self, user_id, medium, address, validated_at):
-        yield self.store.user_add_threepid(
-            user_id, medium, address, validated_at,
-            self.hs.get_clock().time_msec()
+    def _check_valid_association(self, user_id, email):
+        identity = yield self._query_email(email)
+        if identity and "mxid" in identity:
+            if identity["mxid"] == user_id:
+                defer.returnValue(True)
+                return
+        defer.returnValue(False)
+
+    @defer.inlineCallbacks
+    def _query_email(self, email):
+        httpCli = SimpleHttpClient(self.hs)
+        data = yield httpCli.get_json(
+            # TODO FIXME This should be configurable.
+            # XXX: ID servers need to use HTTPS
+            "http://%s%s" % (
+                "matrix.org:8090", "/_matrix/identity/api/v1/lookup"
+            ),
+            {
+                'medium': 'email',
+                'address': email
+            }
        )
+        defer.returnValue(data)
--- a/synapse/handlers/message.py
+++ b/synapse/handlers/message.py
@@ -16,13 +16,10 @@
 from twisted.internet import defer

 from synapse.api.constants import EventTypes, Membership
-from synapse.api.errors import RoomError, SynapseError
+from synapse.api.errors import RoomError
 from synapse.streams.config import PaginationConfig
-from synapse.events.utils import serialize_event
 from synapse.events.validator import EventValidator
-from synapse.util import unwrapFirstError
 from synapse.util.logcontext import PreserveLoggingContext
-from synapse.types import UserID, RoomStreamToken

 from ._base import BaseHandler

@@ -36,7 +33,6 @@ class MessageHandler(BaseHandler):
    def __init__(self, hs):
        super(MessageHandler, self).__init__(hs)
        self.hs = hs
-        self.state = hs.get_state_handler()
        self.clock = hs.get_clock()
        self.validator = EventValidator()

@@ -90,20 +86,10 @@ class MessageHandler(BaseHandler):

        if not pagin_config.from_token:
            pagin_config.from_token = (
-                yield self.hs.get_event_sources().get_current_token(
-                    direction='b'
-                )
+                yield self.hs.get_event_sources().get_current_token()
            )

-        room_token = RoomStreamToken.parse(pagin_config.from_token.room_key)
-        if room_token.topological is None:
-            raise SynapseError(400, "Invalid token")
-
-        yield self.hs.get_handlers().federation_handler.maybe_backfill(
-            room_id, room_token.topological
-        )
-
-        user = UserID.from_string(user_id)
+        user = self.hs.parse_userid(user_id)

        events, next_key = yield data_source.get_pagination_rows(
            user, pagin_config.get_source_config("room"), room_id
@@ -113,11 +99,9 @@ class MessageHandler(BaseHandler):
            "room_key", next_key
        )

-        time_now = self.clock.time_msec()
-
        chunk = {
            "chunk": [
-                serialize_event(e, time_now, as_client_event) for e in events
+                self.hs.serialize_event(e, as_client_event) for e in events
            ],
            "start": pagin_config.from_token.to_string(),
            "end": next_token.to_string(),
@@ -126,8 +110,7 @@ class MessageHandler(BaseHandler):
        defer.returnValue(chunk)

    @defer.inlineCallbacks
-    def create_and_send_event(self, event_dict, ratelimit=True,
-                              client=None, txn_id=None):
+    def create_and_send_event(self, event_dict, ratelimit=True):
        """ Given a dict from a client, create and handle a new event.

        Creates an FrozenEvent object, filling out auth_events, prev_events,
@@ -147,13 +130,13 @@ class MessageHandler(BaseHandler):
        if ratelimit:
            self.ratelimit(builder.user_id)
        # TODO(paul): Why does 'event' not have a 'user' object?
-        user = UserID.from_string(builder.user_id)
+        user = self.hs.parse_userid(builder.user_id)
        assert self.hs.is_mine(user), "User must be our own: %s" % (user,)

        if builder.type == EventTypes.Member:
            membership = builder.content.get("membership", None)
            if membership == Membership.JOIN:
-                joinee = UserID.from_string(builder.state_key)
+                joinee = self.hs.parse_userid(builder.state_key)
                # If event doesn't include a display name, add one.
                yield self.distributor.fire(
                    "collect_presencelike_data",
@@ -161,15 +144,6 @@ class MessageHandler(BaseHandler):
                    builder.content
                )

-        if client is not None:
-            if client.token_id is not None:
-                builder.internal_metadata.token_id = client.token_id
-            if client.device_id is not None:
-                builder.internal_metadata.device_id = client.device_id
-
-        if txn_id is not None:
-            builder.internal_metadata.txn_id = txn_id
-
        event, context = yield self._create_new_client_event(
            builder=builder,
        )
@@ -236,10 +210,7 @@ class MessageHandler(BaseHandler):

        # TODO: This is duplicating logic from snapshot_all_rooms
        current_state = yield self.state_handler.get_current_state(room_id)
-        now = self.clock.time_msec()
-        defer.returnValue(
-            [serialize_event(c, now) for c in current_state.values()]
-        )
+        defer.returnValue([self.hs.serialize_event(c) for c in current_state])

    @defer.inlineCallbacks
    def snapshot_all_rooms(self, user_id=None, pagin_config=None,
@@ -266,7 +237,7 @@ class MessageHandler(BaseHandler):
            membership_list=[Membership.INVITE, Membership.JOIN]
        )

-        user = UserID.from_string(user_id)
+        user = self.hs.parse_userid(user_id)

        rooms_ret = []

@@ -278,14 +249,14 @@ class MessageHandler(BaseHandler):
            user, pagination_config.get_source_config("presence"), None
        )

-        public_room_ids = yield self.store.get_public_room_ids()
+        public_rooms = yield self.store.get_rooms(is_public=True)
+        public_room_ids = [r["room_id"] for r in public_rooms]

        limit = pagin_config.limit
        if limit is None:
            limit = 10

-        @defer.inlineCallbacks
-        def handle_room(event):
+        for event in room_list:
            d = {
                "room_id": event.room_id,
                "membership": event.membership,
@@ -301,46 +272,35 @@ class MessageHandler(BaseHandler):
            rooms_ret.append(d)

            if event.membership != Membership.JOIN:
-                return
+                continue
            try:
-                (messages, token), current_state = yield defer.gatherResults(
-                    [
-                        self.store.get_recent_events_for_room(
-                            event.room_id,
-                            limit=limit,
-                            end_token=now_token.room_key,
-                        ),
-                        self.state_handler.get_current_state(
-                            event.room_id
-                        ),
-                    ]
-                ).addErrback(unwrapFirstError)
+                messages, token = yield self.store.get_recent_events_for_room(
+                    event.room_id,
+                    limit=limit,
+                    end_token=now_token.room_key,
+                )

                start_token = now_token.copy_and_replace("room_key", token[0])
                end_token = now_token.copy_and_replace("room_key", token[1])
-                time_now = self.clock.time_msec()

                d["messages"] = {
                    "chunk": [
-                        serialize_event(m, time_now, as_client_event)
+                        self.hs.serialize_event(m, as_client_event)
                        for m in messages
                    ],
                    "start": start_token.to_string(),
                    "end": end_token.to_string(),
                }

+                current_state = yield self.state_handler.get_current_state(
+                    event.room_id
+                )
                d["state"] = [
-                    serialize_event(c, time_now, as_client_event)
-                    for c in current_state.values()
+                    self.hs.serialize_event(c) for c in current_state
                ]
            except:
                logger.exception("Failed to get snapshot")

-        yield defer.gatherResults(
-            [handle_room(e) for e in room_list],
-            consumeErrors=True
-        ).addErrback(unwrapFirstError)
-
        ret = {
            "rooms": rooms_ret,
            "presence": presence,
@@ -352,27 +312,20 @@ class MessageHandler(BaseHandler):
    @defer.inlineCallbacks
    def room_initial_sync(self, user_id, room_id, pagin_config=None,
                          feedback=False):
-        current_state = yield self.state.get_current_state(
-            room_id=room_id,
-        )
-
-        yield self.auth.check_joined_room(
-            room_id, user_id,
-            current_state=current_state
-        )
+        yield self.auth.check_joined_room(room_id, user_id)

        # TODO(paul): I wish I was called with user objects not user_id
        #   strings...
-        auth_user = UserID.from_string(user_id)
+        auth_user = self.hs.parse_userid(user_id)

        # TODO: These concurrently
-        time_now = self.clock.time_msec()
-        state = [
-            serialize_event(x, time_now)
-            for x in current_state.values()
-        ]
+        state_tuples = yield self.state_handler.get_current_state(room_id)
+        state = [self.hs.serialize_event(x) for x in state_tuples]

-        member_event = current_state.get((EventTypes.Member, user_id,))
+        member_event = (yield self.store.get_room_member(
+            user_id=user_id,
+            room_id=room_id
+        ))

        now_token = yield self.hs.get_event_sources().get_current_token()

@@ -389,34 +342,28 @@ class MessageHandler(BaseHandler):
        start_token = now_token.copy_and_replace("room_key", token[0])
        end_token = now_token.copy_and_replace("room_key", token[1])

-        room_members = [
-            m for m in current_state.values()
-            if m.type == EventTypes.Member
-            and m.content["membership"] == Membership.JOIN
-        ]
+        room_members = yield self.store.get_room_members(room_id)

        presence_handler = self.hs.get_handlers().presence_handler
        presence = []
        for m in room_members:
            try:
                member_presence = yield presence_handler.get_state(
-                    target_user=UserID.from_string(m.user_id),
+                    target_user=self.hs.parse_userid(m.user_id),
                    auth_user=auth_user,
                    as_event=True,
                )
                presence.append(member_presence)
-            except SynapseError:
+            except Exception:
                logger.exception(
                    "Failed to get member presence of %r", m.user_id
                )

-        time_now = self.clock.time_msec()
-
        defer.returnValue({
            "membership": member_event.membership,
            "room_id": room_id,
            "messages": {
-                "chunk": [serialize_event(m, time_now) for m in messages],
+                "chunk": [self.hs.serialize_event(m) for m in messages],
                "start": start_token.to_string(),
                "end": end_token.to_string(),
            },
--- a/synapse/handlers/presence.py
+++ b/synapse/handlers/presence.py
--- a/synapse/handlers/profile.py
+++ b/synapse/handlers/profile.py
@@ -17,8 +17,7 @@ from twisted.internet import defer

 from synapse.api.errors import SynapseError, AuthError, CodeMessageException
 from synapse.api.constants import EventTypes, Membership
-from synapse.types import UserID
-from synapse.util import unwrapFirstError
+from synapse.util.logcontext import PreserveLoggingContext

 from ._base import BaseHandler

@@ -88,9 +87,6 @@ class ProfileHandler(BaseHandler):
        if target_user != auth_user:
            raise AuthError(400, "Cannot set another user's displayname")

-        if new_displayname == '':
-            new_displayname = None
-
        yield self.store.set_profile_displayname(
            target_user.localpart, new_displayname
        )
@@ -157,13 +153,14 @@ class ProfileHandler(BaseHandler):
        if not self.hs.is_mine(user):
            defer.returnValue(None)

-        (displayname, avatar_url) = yield defer.gatherResults(
-            [
-                self.store.get_profile_displayname(user.localpart),
-                self.store.get_profile_avatar_url(user.localpart),
-            ],
-            consumeErrors=True
-        ).addErrback(unwrapFirstError)
+        with PreserveLoggingContext():
+            (displayname, avatar_url) = yield defer.gatherResults(
+                [
+                    self.store.get_profile_displayname(user.localpart),
+                    self.store.get_profile_avatar_url(user.localpart),
+                ],
+                consumeErrors=True
+            )

        state["displayname"] = displayname
        state["avatar_url"] = avatar_url
@@ -172,7 +169,7 @@ class ProfileHandler(BaseHandler):

    @defer.inlineCallbacks
    def on_profile_query(self, args):
-        user = UserID.from_string(args["user_id"])
+        user = self.hs.parse_userid(args["user_id"])
        if not self.hs.is_mine(user):
            raise SynapseError(400, "User is not hosted on this Home Server")

@@ -199,8 +196,9 @@ class ProfileHandler(BaseHandler):

        self.ratelimit(user.to_string())

-        joins = yield self.store.get_rooms_for_user(
+        joins = yield self.store.get_rooms_for_user_where_membership_is(
            user.to_string(),
+            [Membership.JOIN],
        )

        for j in joins:
@@ -213,16 +211,10 @@ class ProfileHandler(BaseHandler):
            )

            msg_handler = self.hs.get_handlers().message_handler
-            try:
-                yield msg_handler.create_and_send_event({
-                    "type": EventTypes.Member,
-                    "room_id": j.room_id,
-                    "state_key": user.to_string(),
-                    "content": content,
-                    "sender": user.to_string()
-                }, ratelimit=False)
-            except Exception as e:
-                logger.warn(
-                    "Failed to update join event for room %s - %s",
-                    j.room_id, str(e.message)
-                )
+            yield msg_handler.create_and_send_event({
+                "type": EventTypes.Member,
+                "room_id": j.room_id,
+                "state_key": user.to_string(),
+                "content": content,
+                "sender": user.to_string()
+            }, ratelimit=False)
--- a/synapse/handlers/register.py
+++ b/synapse/handlers/register.py
@@ -18,17 +18,17 @@ from twisted.internet import defer

 from synapse.types import UserID
 from synapse.api.errors import (
-    AuthError, Codes, SynapseError, RegistrationError, InvalidCaptchaError
+    SynapseError, RegistrationError, InvalidCaptchaError
 )
 from ._base import BaseHandler
 import synapse.util.stringutils as stringutils
 from synapse.util.async import run_on_reactor
+from synapse.http.client import SimpleHttpClient
 from synapse.http.client import CaptchaServerHttpClient

 import base64
 import bcrypt
 import logging
-import urllib

 logger = logging.getLogger(__name__)

@@ -41,30 +41,6 @@ class RegistrationHandler(BaseHandler):
        self.distributor = hs.get_distributor()
        self.distributor.declare("registered_user")

-    @defer.inlineCallbacks
-    def check_username(self, localpart):
-        yield run_on_reactor()
-
-        if urllib.quote(localpart) != localpart:
-            raise SynapseError(
-                400,
-                "User ID must only contain characters which do not"
-                " require URL encoding."
-            )
-
-        user = UserID(localpart, self.hs.hostname)
-        user_id = user.to_string()
-
-        yield self.check_user_id_is_valid(user_id)
-
-        u = yield self.store.get_user_by_id(user_id)
-        if u:
-            raise SynapseError(
-                400,
-                "User ID already taken.",
-                errcode=Codes.USER_IN_USE,
-            )
-
    @defer.inlineCallbacks
    def register(self, localpart=None, password=None):
        """Registers a new client on the server.
@@ -85,8 +61,6 @@ class RegistrationHandler(BaseHandler):
            password_hash = bcrypt.hashpw(password, bcrypt.gensalt())

        if localpart:
-            yield self.check_username(localpart)
-
            user = UserID(localpart, self.hs.hostname)
            user_id = user.to_string()

@@ -108,7 +82,6 @@ class RegistrationHandler(BaseHandler):
                    localpart = self._generate_user_id()
                    user = UserID(localpart, self.hs.hostname)
                    user_id = user.to_string()
-                    yield self.check_user_id_is_valid(user_id)

                    token = self._generate_token(user_id)
                    yield self.store.register(
@@ -126,56 +99,11 @@ class RegistrationHandler(BaseHandler):
                        raise RegistrationError(
                            500, "Cannot generate user ID.")

-        # create a default avatar for the user
-        # XXX: ideally clients would explicitly specify one, but given they don't
-        # and we want consistent and pretty identicons for random users, we'll
-        # do it here.
-        try:
-            auth_user = UserID.from_string(user_id)
-            media_repository = self.hs.get_resource_for_media_repository()
-            identicon_resource = media_repository.getChildWithDefault("identicon", None)
-            upload_resource = media_repository.getChildWithDefault("upload", None)
-            identicon_bytes = identicon_resource.generate_identicon(user_id, 320, 320)
-            content_uri = yield upload_resource.create_content(
-                "image/png", None, identicon_bytes, len(identicon_bytes), auth_user
-            )
-            profile_handler = self.hs.get_handlers().profile_handler
-            profile_handler.set_avatar_url(
-                auth_user, auth_user, ("%s#auto" % (content_uri,))
-            )
-        except NotImplementedError:
-            pass  # make tests pass without messing around creating default avatars
-
-        defer.returnValue((user_id, token))
-
-    @defer.inlineCallbacks
-    def appservice_register(self, user_localpart, as_token):
-        user = UserID(user_localpart, self.hs.hostname)
-        user_id = user.to_string()
-        service = yield self.store.get_app_service_by_token(as_token)
-        if not service:
-            raise AuthError(403, "Invalid application service token.")
-        if not service.is_interested_in_user(user_id):
-            raise SynapseError(
-                400, "Invalid user localpart for this application service.",
-                errcode=Codes.EXCLUSIVE
-            )
-        token = self._generate_token(user_id)
-        yield self.store.register(
-            user_id=user_id,
-            token=token,
-            password_hash=""
-        )
-        self.distributor.fire("registered_user", user)
        defer.returnValue((user_id, token))

    @defer.inlineCallbacks
    def check_recaptcha(self, ip, private_key, challenge, response):
-        """
-        Checks a recaptcha is correct.
-
-        Used only by c/s api v1
-        """
+        """Checks a recaptcha is correct."""

        captcha_response = yield self._validate_captcha(
            ip,
@@ -194,18 +122,13 @@ class RegistrationHandler(BaseHandler):

    @defer.inlineCallbacks
    def register_email(self, threepidCreds):
-        """
-        Registers emails with an identity server.
-
-        Used only by c/s api v1
-        """
+        """Registers emails with an identity server."""

        for c in threepidCreds:
            logger.info("validating theeepidcred sid %s on id server %s",
                        c['sid'], c['idServer'])
            try:
-                identity_handler = self.hs.get_handlers().identity_handler
-                threepid = yield identity_handler.threepid_from_creds(c)
+                threepid = yield self._threepid_from_creds(c)
            except:
                logger.exception("Couldn't validate 3pid")
                raise RegistrationError(400, "Couldn't validate 3pid")
@@ -217,31 +140,12 @@ class RegistrationHandler(BaseHandler):

    @defer.inlineCallbacks
    def bind_emails(self, user_id, threepidCreds):
-        """Links emails with a user ID and informs an identity server.
-
-        Used only by c/s api v1
-        """
+        """Links emails with a user ID and informs an identity server."""

        # Now we have a matrix ID, bind it to the threepids we were given
        for c in threepidCreds:
-            identity_handler = self.hs.get_handlers().identity_handler
            # XXX: This should be a deferred list, shouldn't it?
-            yield identity_handler.bind_threepid(c, user_id)
-
-    @defer.inlineCallbacks
-    def check_user_id_is_valid(self, user_id):
-        # valid user IDs must not clash with any user ID namespaces claimed by
-        # application services.
-        services = yield self.store.get_app_services()
-        interested_services = [
-            s for s in services if s.is_interested_in_user(user_id)
-        ]
-        for service in interested_services:
-            if service.is_exclusive_user(user_id):
-                raise SynapseError(
-                    400, "This user ID is reserved by an application service.",
-                    errcode=Codes.EXCLUSIVE
-                )
+            yield self._bind_threepid(c, user_id)

    def _generate_token(self, user_id):
        # urlsafe variant uses _ and - so use . as the separator and replace
@@ -253,12 +157,53 @@ class RegistrationHandler(BaseHandler):
    def _generate_user_id(self):
        return "-" + stringutils.random_string(18)

+    @defer.inlineCallbacks
+    def _threepid_from_creds(self, creds):
+        # TODO: get this from the homeserver rather than creating a new one for
+        # each request
+        httpCli = SimpleHttpClient(self.hs)
+        # XXX: make this configurable!
+        trustedIdServers = ['matrix.org:8090']
+        if not creds['idServer'] in trustedIdServers:
+            logger.warn('%s is not a trusted ID server: rejecting 3pid ' +
+                        'credentials', creds['idServer'])
+            defer.returnValue(None)
+        data = yield httpCli.get_json(
+            # XXX: This should be HTTPS
+            "http://%s%s" % (
+                creds['idServer'],
+                "/_matrix/identity/api/v1/3pid/getValidated3pid"
+            ),
+            {'sid': creds['sid'], 'clientSecret': creds['clientSecret']}
+        )
+
+        if 'medium' in data:
+            defer.returnValue(data)
+        defer.returnValue(None)
+
+    @defer.inlineCallbacks
+    def _bind_threepid(self, creds, mxid):
+        yield
+        logger.debug("binding threepid")
+        httpCli = SimpleHttpClient(self.hs)
+        data = yield httpCli.post_urlencoded_get_json(
+            # XXX: Change when ID servers are all HTTPS
+            "http://%s%s" % (
+                creds['idServer'], "/_matrix/identity/api/v1/3pid/bind"
+            ),
+            {
+                'sid': creds['sid'],
+                'clientSecret': creds['clientSecret'],
+                'mxid': mxid,
+            }
+        )
+        logger.debug("bound threepid")
+        defer.returnValue(data)
+
    @defer.inlineCallbacks
    def _validate_captcha(self, ip_addr, private_key, challenge, response):
        """Validates the captcha provided.

-        Used only by c/s api v1
-
        Returns:
            dict: Containing 'valid'(bool) and 'error_url'(str) if invalid.

@@ -276,9 +221,6 @@ class RegistrationHandler(BaseHandler):

    @defer.inlineCallbacks
    def _submit_captcha(self, ip_addr, private_key, challenge, response):
-        """
-        Used only by c/s api v1
-        """
        # TODO: get this from the homeserver rather than creating a new one for
        # each request
        client = CaptchaServerHttpClient(self.hs)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Erik Johnston	03c0da9f65	In get_recent_events_for_room, get the full event json rather than just the event_ids so we don't have to do so many db queries	2015-01-22 14:01:10 +00:00
Erik Johnston	33d2d82f6d	In get_state_groups, get the full event json rather than just the event_ids so we don't have to do so many db queries	2015-01-22 13:37:44 +00:00