improvement: efficient /sync, mutex for federation transactions

fix: stuck messages
Conduit did not send the event in /sync because of a race condition. There is a brief moment in time where Conduit accepted the event, but did not store it yet. So when the client /syncs it updates the since token without sending the event. I hope I fixed it by significantly shortening the race-condition period.
2021-07-01 19:55:26 +02:00 · 2021-07-01 11:08:43 +02:00 · 2021-06-30 20:31:51 +02:00
72 changed files with 3058 additions and 7125 deletions
@@ -1,11 +0,0 @@
---
-name: "Issue with / Feature Request for Conduit"
-about: "Please file issues on GitLab: https://gitlab.com/famedly/conduit/-/issues/new"
-title: "CLOSE ME"
---
-
-
-
-**⚠️ Conduit development does not happen on GitHub. Issues opened here will not be addressed** 
-
-Please open issues on GitLab: https://gitlab.com/famedly/conduit/-/issues/new
@@ -59,7 +59,6 @@ $RECYCLE.BIN/
 # Conduit
 Rocket.toml
 conduit.toml
-conduit.db

 # Etc.
 **/*.rs.bk
@@ -1,343 +1,28 @@
-stages:
-  - build
-  - build docker image
-  - test
-  - upload artifacts
+image: "rust:latest"
+
+default:
+    tags: [docker]
+
+cache:
+  paths:
+    - target
+    - cargohome
+

 variables:
  GIT_SUBMODULE_STRATEGY: recursive
+  CARGO_HOME: "cargohome"
  FF_USE_FASTZIP: 1
-  CACHE_COMPRESSION_LEVEL: fastest

-
-# --------------------------------------------------------------------- #
-#  Cargo: Compiling for different architectures                         #
-# --------------------------------------------------------------------- #
-
-.build-cargo-shared-settings:
-  stage: "build"
-  needs: []
-  rules:
-    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
-  interruptible: true
-  image: "rust:latest"
-  tags: ["docker"]
-  cache:
-    paths:
-      - cargohome
-      - target/
-    key: "build_cache-$TARGET-release"
-  variables:
-    CARGO_PROFILE_RELEASE_LTO=true
-    CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1
-  before_script:
-    - 'echo "Building for target $TARGET"'
-    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
-    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
-    - 'apt-get update -yqq'
-    - 'echo "Installing packages: $NEEDED_PACKAGES"'
-    - "apt-get install -yqq --no-install-recommends $NEEDED_PACKAGES"
-    - "rustup target add $TARGET"
-  script:
-    - time cargo build --target $TARGET --release
-    - 'mv "target/$TARGET/release/conduit" "conduit-$TARGET"'
-
-
-build:release:cargo:x86_64-unknown-linux-gnu:
-  extends: .build-cargo-shared-settings
-  variables:
-    TARGET: "x86_64-unknown-linux-gnu"
-  artifacts:
-    name: "conduit-x86_64-unknown-linux-gnu"
-    paths:
-      - "conduit-x86_64-unknown-linux-gnu"
-    expose_as: "Conduit for x86_64-unknown-linux-gnu"
-
-build:release:cargo:armv7-unknown-linux-gnueabihf:
-  extends: .build-cargo-shared-settings
-  variables:
-    TARGET: "armv7-unknown-linux-gnueabihf"
-    NEEDED_PACKAGES: "build-essential gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf libc6-dev-armhf-cross"
-    CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER: arm-linux-gnueabihf-gcc
-    CC_armv7_unknown_linux_gnueabihf: arm-linux-gnueabihf-gcc
-    CXX_armv7_unknown_linux_gnueabihf: arm-linux-gnueabihf-g++
-  artifacts:
-    name: "conduit-armv7-unknown-linux-gnueabihf"
-    paths:
-      - "conduit-armv7-unknown-linux-gnueabihf"
-    expose_as: "Conduit for armv7-unknown-linux-gnueabihf"
-
-build:release:cargo:aarch64-unknown-linux-gnu:
-  extends: .build-cargo-shared-settings
-  variables:
-    TARGET: "aarch64-unknown-linux-gnu"
-    NEEDED_PACKAGES: "build-essential gcc-8-aarch64-linux-gnu g++-aarch64-linux-gnu libc6-dev-arm64-cross"
-    CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
-    CC_aarch64_unknown_linux_gnu: aarch64-linux-gnu-gcc
-    CXX_aarch64_unknown_linux_gnu: aarch64-linux-gnu-g++
-    TARGET_CC: "/usr/bin/aarch64-linux-gnu-gcc-8"
-    TARGET_AR: "/usr/bin/aarch64-linux-gnu-gcc-ar-8"
-  artifacts:
-    name: "conduit-aarch64-unknown-linux-gnu"
-    paths:
-      - "conduit-aarch64-unknown-linux-gnu"
-    expose_as: "Conduit for aarch64-unknown-linux-gnu"
-
-build:release:cargo:x86_64-unknown-linux-musl:
-  extends: .build-cargo-shared-settings
-  image: "rust:alpine"
-  variables:
-    TARGET: "x86_64-unknown-linux-musl"
-  before_script:
-    - 'echo "Building for target $TARGET"'
-    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
-    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
-    - "rustup target add $TARGET"
-    - "apk add libc-dev"
-  artifacts:
-    name: "conduit-x86_64-unknown-linux-musl"
-    paths:
-      - "conduit-x86_64-unknown-linux-musl"
-    expose_as: "Conduit for x86_64-unknown-linux-musl"
-
-
-
-.cargo-debug-shared-settings:
-  extends: ".build-cargo-shared-settings"
-  rules:
-    - if: '$CI_COMMIT_BRANCH'
-  cache:
-    key: "build_cache-$TARGET-debug"
-  script:
-    - "time cargo build --target $TARGET"
-    - 'mv "target/$TARGET/debug/conduit" "conduit-debug-$TARGET"'
-
-build:debug:cargo:x86_64-unknown-linux-gnu:
-  extends: ".cargo-debug-shared-settings"
-  variables:
-    TARGET: "x86_64-unknown-linux-gnu"
-  artifacts:
-    name: "conduit-debug-x86_64-unknown-linux-gnu"
-    paths:
-      - "conduit-debug-x86_64-unknown-linux-gnu"
-    expose_as: "Conduit DEBUG for x86_64-unknown-linux-gnu"
-
-build:debug:cargo:x86_64-unknown-linux-musl:
-  extends: ".cargo-debug-shared-settings"
-  image: "rust:alpine"
-  variables:
-    TARGET: "x86_64-unknown-linux-musl"
-  before_script:
-    - 'echo "Building for target $TARGET"'
-    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
-    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
-    - "rustup target add $TARGET"
-    - "apk add libc-dev"
-  artifacts:
-    name: "conduit-debug-x86_64-unknown-linux-musl"
-    paths:
-      - "conduit-debug-x86_64-unknown-linux-musl"
-    expose_as: "Conduit DEBUG for x86_64-unknown-linux-musl"
-
-
-
-# --------------------------------------------------------------------- #
-#  Cargo: Compiling deb packages for different architectures            #
-# --------------------------------------------------------------------- #
-
-
-.build-cargo-deb-shared-settings:
-  stage: "build"
-  needs: [ ]
-  rules:
-    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
-  interruptible: true
-  image: "rust:latest"
-  tags: ["docker"]
-  cache:
-    paths:
-      - cargohome
-      - target/
-    key: "build_cache-deb-$TARGET"
-  before_script:
-    - 'echo "Building debian package for target $TARGET"'
-    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
-    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
-    - 'apt-get update -yqq'
-    - 'echo "Installing packages: $NEEDED_PACKAGES"'
-    - "apt-get install -yqq --no-install-recommends $NEEDED_PACKAGES"
-    - "rustup target add $TARGET"
-    - "cargo install cargo-deb"
-  script:
-    - time cargo deb --target $TARGET
-    - 'mv target/$TARGET/debian/*.deb "conduit-$TARGET.deb"'
-
-build:cargo-deb:x86_64-unknown-linux-gnu:
-  extends: .build-cargo-deb-shared-settings
-  variables:
-    TARGET: "x86_64-unknown-linux-gnu"
-    NEEDED_PACKAGES: ""
-  artifacts:
-    name: "conduit-x86_64-unknown-linux-gnu.deb"
-    paths:
-      - "conduit-x86_64-unknown-linux-gnu.deb"
-    expose_as: "Debian Package x86_64"
-
-
-
-# --------------------------------------------------------------------- #
-#  Create and publish docker image                                      #
-# --------------------------------------------------------------------- #
-
-.docker-shared-settings:
-  stage: "build docker image"
-  needs: []
-  interruptible: true
-  image:
-    name: "gcr.io/kaniko-project/executor:debug"
-    entrypoint: [""]
-  tags: ["docker"]
-  variables:
-    # Configure Kaniko Caching: https://cloud.google.com/build/docs/kaniko-cache
-    KANIKO_CACHE_ARGS: "--cache=true --cache-copy-layers=true --cache-ttl=120h --cache-repo $CI_REGISTRY_IMAGE/kaniko-ci-cache"
-  before_script:
-    - "mkdir -p /kaniko/.docker"
-    - 'echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"},\"$DOCKER_HUB\":{\"username\":\"$DOCKER_HUB_USER\",\"password\":\"$DOCKER_HUB_PASSWORD\"}}}" > /kaniko/.docker/config.json'
-
-
-# Build a docker image by packaging up the x86_64-unknown-linux-musl binary into an alpine image
-build:docker:main:
-  extends: .docker-shared-settings
-  needs:
-    - "build:release:cargo:x86_64-unknown-linux-musl"
-  script:
-    - >
-      /kaniko/executor
-      $KANIKO_CACHE_ARGS
-      --context $CI_PROJECT_DIR
-      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
-      --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
-      --build-arg "GIT_REF=$CI_COMMIT_REF_NAME"
-      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
-      --destination "$CI_REGISTRY_IMAGE/conduit:latest"
-      --destination "$CI_REGISTRY_IMAGE/conduit:alpine"
-      --destination "$CI_REGISTRY_IMAGE/conduit:commit-$CI_COMMIT_SHORT_SHA"
-      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest"
-      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:alpine"
-      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:commit-$CI_COMMIT_SHORT_SHA"
-  rules:
-    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
-
-
-
-# --------------------------------------------------------------------- #
-#  Run tests                                                            #
-# --------------------------------------------------------------------- #
+before_script:
+  - mkdir -p $CARGO_HOME && echo "using $CARGO_HOME to cache cargo deps"
+  - apt-get update -yqq
+  - apt-get install -yqq --no-install-recommends build-essential libssl-dev pkg-config
+  - rustup component add clippy rustfmt

 test:cargo:
-  stage: "test"
-  needs: [ ]
-  image: "rust:latest"
-  tags: [ "docker" ]
-  variables:
-    CARGO_HOME: "cargohome"
-  cache:
-    paths:
-      - target
-      - cargohome
-    key: test_cache
-  interruptible: true
-  before_script:
-    - mkdir -p $CARGO_HOME && echo "using $CARGO_HOME to cache cargo deps"
-    - apt-get update -yqq
-    - apt-get install -yqq --no-install-recommends build-essential libssl-dev pkg-config
-    - rustup component add clippy rustfmt
  script:
    - rustc --version && cargo --version  # Print version info for debugging
-    - cargo fmt --all -- --check
    - cargo test --workspace --verbose --locked
+    - cargo fmt --all -- --check
    - cargo clippy
-
-test:sytest:
-  stage: "test"
-  allow_failure: true
-  needs:
-    - "build:debug:cargo:x86_64-unknown-linux-musl"
-  image:
-    name: "valkum/sytest-conduit:latest"
-    entrypoint: [ "" ]
-  tags: [ "docker" ]
-  variables:
-    PLUGINS: "https://github.com/valkum/sytest_conduit/archive/master.tar.gz"
-  before_script:
-    - "mkdir -p /app"
-    - "cp ./conduit-debug-x86_64-unknown-linux-musl /app/conduit"
-    - "chmod +x /app/conduit"
-    - "rm -rf /src && ln -s $CI_PROJECT_DIR/ /src"
-    - "mkdir -p /work/server-0/database/ && mkdir -p /work/server-1/database/ && mkdir -p /work/server-2/database/"
-    - "cd /"
-  script:
-    - "SYTEST_EXIT_CODE=0"
-    - "/bootstrap.sh conduit || SYTEST_EXIT_CODE=1"
-    - "perl /sytest/tap-to-junit-xml.pl --puretap --input /logs/results.tap --output $CI_PROJECT_DIR/sytest.xml \"Sytest\" && cp /logs/results.tap $CI_PROJECT_DIR/results.tap"
-    - "exit $SYTEST_EXIT_CODE"
-  artifacts:
-    when: always
-    paths:
-      - "$CI_PROJECT_DIR/sytest.xml"
-      - "$CI_PROJECT_DIR/results.tap"
-    reports:
-      junit: "$CI_PROJECT_DIR/sytest.xml"
-
-
-test:register:element-web-stable:
-  stage: "test"
-  needs:
-    - "build:debug:cargo:x86_64-unknown-linux-gnu"
-  image: "buildkite/puppeteer:latest"
-  tags: [ "docker" ]
-  interruptible: true
-  script:
-    - "CONDUIT_CONFIG=tests/test-config.toml ./conduit-debug-x86_64-unknown-linux-gnu > conduit.log &"
-    - "cd tests/client-element-web/"
-    - "npm install puppeteer"
-    - "node test-element-web-registration.js \"https://app.element.io/\" \"http://localhost:6167\""
-    - "killall --regexp \"conduit\""
-    - "cd ../.."
-    - "cat conduit.log"
-  artifacts:
-    paths:
-      - "tests/client-element-web/*.png"
-      - "*.log"
-    expire_in: 1 week
-    when: always
-  retry: 1
-
-
-# --------------------------------------------------------------------- #
-#  Store binaries as package so they have download urls                 #
-# --------------------------------------------------------------------- #
-
-publish:package:
-  stage: "upload artifacts"
-  needs:
-    - "build:release:cargo:x86_64-unknown-linux-gnu"
-    - "build:release:cargo:armv7-unknown-linux-gnueabihf"
-    - "build:release:cargo:aarch64-unknown-linux-gnu"
-    - "build:release:cargo:x86_64-unknown-linux-musl"
-    - "build:cargo-deb:x86_64-unknown-linux-gnu"
-  rules:
-    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
-  image: curlimages/curl:latest
-  tags: ["docker"]
-  variables:
-    GIT_STRATEGY: "none" # Don't need a clean copy of the code, we just operate on artifacts
-  script:
-    - 'BASE_URL="${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-gnu "${BASE_URL}/conduit-x86_64-unknown-linux-gnu"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-armv7-unknown-linux-gnueabihf "${BASE_URL}/conduit-armv7-unknown-linux-gnueabihf"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-aarch64-unknown-linux-gnu "${BASE_URL}/conduit-aarch64-unknown-linux-gnu"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-musl "${BASE_URL}/conduit-x86_64-unknown-linux-musl"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-gnu.deb "${BASE_URL}/conduit-x86_64-unknown-linux-gnu.deb"'
-
-
@@ -1,19 +0,0 @@
-<!--
-If you're requesting a new feature, that isn't part of this project yet,
-then please consider filling out a "Feature Request" instead!
-
-If you need a hand setting up your conduit server, feel free to ask for help in the
-Conduit Matrix Chat: https://matrix.to/#/#conduit:fachschaften.org.
-->
-
-### Description
-<!-- What did you do and what happened? Why is that bad? -->
-
-### System Configuration
-<!-- Other data that might help us debug this issue, like os, conduit version, database backend -->
-
-Conduit Version:
-Database backend (default is sqlite): sqlite
-
-
-/label ~conduit
@@ -1,17 +0,0 @@
-<!--
-If you want to report a bug or an error,
-then please consider filling out a "Bug Report" instead!
-->
-
-
-### Is your feature request related to a problem? Please describe.
-
-<!-- Eg. I'm always frustrated when [...] -->
-
-
-### Describe the solution you'd like
-
-
-
-
-/label ~conduit
@@ -0,0 +1,15 @@
+# Headline
+
+### Description
+
+
+
+
+
+
+
+
+
+
+
+/label ~conduit
@@ -1,8 +0,0 @@
-
-<!-- Please describe your changes here -->
-
-----------------------------------------------------------------------------
-
- [ ] I ran `cargo fmt` and `cargo test`
- [ ] I agree to release my code and all other changes of this MR under the Apache-2.0 license
-
@@ -14,45 +14,46 @@ edition = "2018"
 [dependencies]
 # Used to handle requests
 # TODO: This can become optional as soon as proper configs are supported
-# rocket = { git = "https://github.com/SergioBenitez/Rocket.git", rev = "801e04bd5369eb39e126c75f6d11e1e9597304d8", features = ["tls"] } # Used to handle requests
-rocket = { version = "0.5.0-rc.1", features = ["tls"] } # Used to handle requests
+rocket = { git = "https://github.com/SergioBenitez/Rocket.git", rev = "801e04bd5369eb39e126c75f6d11e1e9597304d8", features = ["tls"] } # Used to handle requests

 # Used for matrix spec type definitions and helpers
-ruma = { version = "0.4.0", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
-#ruma = { git = "https://github.com/ruma/ruma", rev = "f5ab038e22421ed338396ece977b6b2844772ced", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
-#ruma = { git = "https://github.com/timokoesters/ruma", rev = "2215049b60a1c3358f5a52215adf1e7bb88619a1", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
+#ruma = { git = "https://github.com/ruma/ruma", rev = "5a7e2cddcf257e367465cced51442c91e8f557c9", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
+ruma = { git = "https://github.com/DevinR528/ruma", branch = "state-closure", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
 #ruma = { path = "../ruma/crates/ruma", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }

 # Used for long polling and federation sender, should be the same as rocket::tokio
-tokio = "1.8.2"
+tokio = "1.2.0"
 # Used for storing data permanently
 sled = { version = "0.34.6", features = ["compression", "no_metrics"], optional = true }
+rocksdb = { version = "0.16.0", features = ["multi-threaded-cf"], optional = true }
 #sled = { git = "https://github.com/spacejam/sled.git", rev = "e4640e0773595229f398438886f19bca6f7326a2", features = ["compression"] }

 # Used for the http request / response body type for Ruma endpoints used with reqwest
 bytes = "1.0.1"
+# Used for emitting log entries
+log = "0.4.14"
 # Used for rocket<->ruma conversions
-http = "0.2.4"
+http = "0.2.3"
 # Used to find data directory for default db path
-directories = "3.0.2"
+directories = "3.0.1"
 # Used for ruma wrapper
 serde_json = { version = "1.0.64", features = ["raw_value"] }
 # Used for appservice registration files
 serde_yaml = "0.8.17"
 # Used for pdu definition
-serde = "1.0.126"
+serde = "1.0.123"
 # Used for secure identifiers
-rand = "0.8.4"
+rand = "0.8.3"
 # Used to hash passwords
 rust-argon2 = "0.8.3"
 # Used to send requests
-reqwest = { version = "0.11.4", default-features = false, features = ["rustls-tls-native-roots", "socks"] }
+reqwest = { version = "0.11.3", default-features = false, features = ["rustls-tls-native-roots"] }
 # Custom TLS verifier
-rustls = { version = "0.19.1", features = ["dangerous_configuration"] }
+rustls = { version = "0.19", features = ["dangerous_configuration"] }
 rustls-native-certs = "0.5.0"
 webpki = "0.21.0"
 # Used for conduit::Error type
-thiserror = "1.0.26"
+thiserror = "1.0.24"
 # Used to generate thumbnails for images
 image = { version = "0.23.14", default-features = false, features = ["jpeg", "png", "gif"] }
 # Used to encode server public key
@@ -60,33 +61,24 @@ base64 = "0.13.0"
 # Used when hashing the state
 ring = "0.16.20"
 # Used when querying the SRV record of other servers
-trust-dns-resolver = "0.20.3"
+trust-dns-resolver = "0.20.0"
 # Used to find matching events for appservices
-regex = "1.5.4"
+regex = "1.4.3"
 # jwt jsonwebtokens
 jsonwebtoken = "7.2.0"
 # Performance measurements
-tracing = { version = "0.1.26", features = ["release_max_level_warn"] }
-tracing-subscriber = "0.2.19"
-tracing-opentelemetry = "0.14.0"
-tracing-flame = "0.1.0"
-opentelemetry = { version = "0.16.0", features = ["rt-tokio"] }
-opentelemetry-jaeger = { version = "0.15.0", features = ["rt-tokio"] }
+tracing = "0.1.25"
+opentelemetry = "0.12.0"
+tracing-subscriber = "0.2.16"
+tracing-opentelemetry = "0.11.0"
+opentelemetry-jaeger = "0.11.0"
 pretty_env_logger = "0.4.0"
 lru-cache = "0.1.2"
-rusqlite = { version = "0.25.3", optional = true, features = ["bundled"] }
-parking_lot = { version = "0.11.1", optional = true }
-crossbeam = { version = "0.8.1", optional = true }
-num_cpus = "1.13.0"
-threadpool = "1.8.1"
-heed = { git = "https://github.com/timokoesters/heed.git", rev = "f6f825da7fb2c758867e05ad973ef800a6fe1d5d", optional = true }

 [features]
-default = ["conduit_bin", "backend_sqlite"]
+default = ["conduit_bin", "backend_sled"]
 backend_sled = ["sled"]
-backend_sqlite = ["sqlite"]
-backend_heed = ["heed", "crossbeam"]
-sqlite = ["rusqlite", "parking_lot", "crossbeam", "tokio/signal"]
+backend_rocksdb = ["rocksdb"]
 conduit_bin = [] # TODO: add rocket to this when it is optional

 [[bin]]
@@ -120,20 +112,6 @@ conf-files = [
 maintainer-scripts = "debian/"
 systemd-units = { unit-name = "matrix-conduit" }

-[profile.dev]
-lto = 'thin'
-incremental = true
-
-[profile.release]
-lto = 'thin'
-incremental = true
-
-codegen-units=32
-# If you want to make flamegraphs, enable debug info:
-# debug = true
-
-# For releases also try to max optimizations for dependencies:
-[profile.release.build-override]
-opt-level = 3
-[profile.release.package."*"]
-opt-level = 3
+# For flamegraphs:
+#[profile.release]
+#debug = true
@@ -6,21 +6,12 @@ If you run into any problems while setting up Conduit, write an email to `timo@k

 ## Installing Conduit

-You may simply download the binary that fits your machine. Run `uname -m` to see what you need. Now copy the right url:
-
-| CPU Architecture     | GNU (Ubuntu, Debian, ArchLinux, ...)  | MUSL (Alpine, ... )     |
-| -------------------- | ------------------------------------- | ----------------------- |
-| x84_64 / amd64       | [Download][x84_64-gnu]                | [Download][x84_64-musl] |
-| armv7 (Raspberry Pi) | [Download][armv7-gnu]                 | -                       |
-| armv8 / aarch64      | [Download][armv8-gnu]                 | -                       |
-
-[x84_64-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-gnu?job=build:release:cargo:x86_64-unknown-linux-gnu
-
-[x84_64-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-musl?job=build:release:cargo:x86_64-unknown-linux-musl
-
-[armv7-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-armv7-unknown-linux-gnueabihf?job=build:release:cargo:armv7-unknown-linux-gnueabihf
-
-[armv8-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-aarch64-unknown-linux-gnu?job=build:release:cargo:aarch64-unknown-linux-gnu
+You may simply download the binary that fits your machine. Run `uname -m` to see
+what you need. Now copy the right url:
+- x84_64: `https://conduit.rs/master/x86_64/conduit-bin`
+- armv7: `https://conduit.rs/master/armv7/conduit-bin`
+- armv8: `https://conduit.rs/master/armv8/conduit-bin`
+- arm: `https://conduit.rs/master/arm/conduit-bin`

 ```bash
 $ sudo wget -O /usr/local/bin/matrix-conduit <url>
@@ -28,7 +19,6 @@ $ sudo chmod +x /usr/local/bin/matrix-conduit
 ```

 Alternatively, you may compile the binary yourself using
-
 ```bash
 $ cargo build --release
 ```
@@ -36,7 +26,6 @@ Note that this currently requires Rust 1.50.

 If you want to cross compile Conduit to another architecture, read the [Cross-Compile Guide](CROSS_COMPILE.md).

-
 ## Adding a Conduit user

 While Conduit can run as any user it is usually better to use dedicated users for different services.
@@ -117,13 +106,11 @@ allow_federation = true

 trusted_servers = ["matrix.org"]

+#cache_capacity = 1073741824 # in bytes, 1024 * 1024 * 1024
 #max_concurrent_requests = 100 # How many requests Conduit sends to other servers at the same time
 #workers = 4 # default: cpu core count * 2

 address = "127.0.0.1" # This makes sure Conduit can only be reached using the reverse proxy
-
-# The total amount of memory that the database will use.
-#db_cache_capacity_mb = 200
 ```

 ## Setting the correct file permissions
@@ -5,7 +5,7 @@

 ##########################  BUILD IMAGE  ##########################
 # Alpine build image to build Conduit's statically compiled binary
-FROM alpine:3.14 as builder
+FROM alpine:3.12 as builder

 # Specifies if the local project is build or if Conduit gets build
 # from the official git repository. Defaults to the git repo.
@@ -13,6 +13,11 @@ ARG LOCAL=false
 # Specifies which revision/commit is build. Defaults to HEAD
 ARG GIT_REF=origin/master

+# Add 'edge'-repository to get Rust 1.45
+RUN sed -i \
+	-e 's|v3\.12|edge|' \
+	/etc/apk/repositories
+
 # Install packages needed for building all crates
 RUN apk add --no-cache \
        cargo \
@@ -31,7 +36,7 @@ RUN if [[ $LOCAL == "true" ]]; then \
 ########################## RUNTIME IMAGE ##########################
 # Create new stage with a minimal image for the actual
 # runtime image/container
-FROM alpine:3.14
+FROM alpine:3.12

 ARG CREATED
 ARG VERSION
@@ -56,8 +61,8 @@ LABEL org.opencontainers.image.created=${CREATED} \
      org.label-schema.docker.build="docker build . -t matrixconduit/matrix-conduit:latest --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ') --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)" \
      maintainer="Weasy666"

-# Standard port on which Conduit launches. You still need to map the port when using the docker command or docker-compose.
-EXPOSE 6167
+# Standard port on which Rocket launches
+EXPOSE 8000

 # Copy config files from context and the binary from
 # the "builder" stage to the current stage into folder
@@ -81,11 +86,11 @@ RUN apk add --no-cache \
        curl \
        libgcc

+# Create a volume for the database, to persist its contents
+VOLUME ["/srv/conduit/.local/share/conduit"]
+
 # Test if Conduit is still alive, uses the same endpoint as Element
-HEALTHCHECK --start-period=5s \
-    CMD curl --fail -s "http://localhost:$(grep -m1 -o 'port\s=\s[0-9]*' conduit.toml | grep -m1 -o '[0-9]*')/_matrix/client/versions" || \
-        curl -k --fail -s "https://localhost:$(grep -m1 -o 'port\s=\s[0-9]*' conduit.toml | grep -m1 -o '[0-9]*')/_matrix/client/versions" || \
-        exit 1
+HEALTHCHECK --start-period=2s CMD curl --fail -s http://localhost:8000/_matrix/client/versions || curl -k --fail -s https://localhost:8000/_matrix/client/versions || exit 1

 # Set user to www-data
 USER www-data
@@ -38,8 +38,8 @@ are not aware of such a bug today, but we would like to do more testing.
 There are still a few important features missing:

 - Database stability (currently you might have to do manual upgrades or even wipe the db for new versions)
- Edge cases for end-to-end encryption over federation
- Typing and presence over federation
+- End-to-end encrypted chats over federation
+- Typing, presence, read receipts etc. over federation
 - Lots of testing

 Check out the [Conduit 1.0 Release Milestone](https://gitlab.com/famedly/conduit/-/milestones/3).
@@ -12,7 +12,7 @@
 #server_name = "your.server.name"

 # This is the only directory where Conduit will save its data
-database_path = "/var/lib/conduit/"
+database_path = "/var/lib/conduit/conduit.db"

 # The port Conduit will be running on. You need to set up a reverse proxy in
 # your web server (e.g. apache or nginx), so all requests to /_matrix on port
@@ -35,13 +35,9 @@ max_request_size = 20_000_000 # in bytes

 trusted_servers = ["matrix.org"]

+#cache_capacity = 1073741824 # in bytes, 1024 * 1024 * 1024
 #max_concurrent_requests = 100 # How many requests Conduit sends to other servers at the same time
 #log = "info,state_res=warn,rocket=off,_=off,sled=off"
 #workers = 4 # default: cpu core count * 2

 address = "127.0.0.1" # This makes sure Conduit can only be reached using the reverse proxy
-
-proxy = "none" # more examples can be found at src/database/proxy.rs:6
-
-# The total amount of memory that the database will use.
-#db_cache_capacity_mb = 200
@@ -73,12 +73,10 @@ max_request_size = 20_000_000 # in bytes
 # Enable jaeger to support monitoring and troubleshooting through jaeger.
 #allow_jaeger = false

+#cache_capacity = 1073741824 # in bytes, 1024 * 1024 * 1024
 #max_concurrent_requests = 100 # How many requests Conduit sends to other servers at the same time
 #log = "info,state_res=warn,rocket=off,_=off,sled=off"
 #workers = 4 # default: cpu core count * 2
-
-# The total amount of memory that the database will use.
-#db_cache_capacity_mb = 200
 EOF
    fi
    ;;
@@ -3,33 +3,33 @@ version: '3'

 services:
    homeserver:
-        ### If you already built the Conduit image with 'docker build' or want to use a registry image,
+        ### If you already built the Conduit image with 'docker build' or want to use the Docker Hub image,
        ### then you are ready to go.
-        image: matrixconduit/matrix-conduit:latest
+        #image: matrixconduit/matrix-conduit:latest
        ### If you want to build a fresh image from the sources, then comment the image line and uncomment the
        ### build lines. If you want meaningful labels in your built Conduit image, you should run docker-compose like this:
        ### CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ') VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml) docker-compose up -d
-        # build:
-        #     context: .
-        #     args:
-        #         CREATED: '2021-03-16T08:18:27Z'
-        #         VERSION: '0.1.0'
-        #         LOCAL: 'false'
-        #         GIT_REF: origin/master
+        build:
+            context: .
+            args:
+                CREATED: '2021-03-16T08:18:27Z'
+                VERSION: '0.1.0'
+                LOCAL: 'false'
+                GIT_REF: origin/master
        restart: unless-stopped
        ports:
-            - 8448:6167
+            - 8448:8000
        volumes:
            - db:/srv/conduit/.local/share/conduit
            ### Uncomment if you want to use conduit.toml to configure Conduit
            ### Note: Set env vars will override conduit.toml values
            # - ./conduit.toml:/srv/conduit/conduit.toml
        environment:
-            CONDUIT_SERVER_NAME: localhost:6167  # replace with your own name
+            CONDUIT_SERVER_NAME: localhost:8000  # replace with your own name
            CONDUIT_TRUSTED_SERVERS: '["matrix.org"]'
            ### Uncomment and change values as desired
-            # CONDUIT_ADDRESS: 0.0.0.0
-            # CONDUIT_PORT: 6167
+            # CONDUIT_ADDRESS: 127.0.0.1
+            # CONDUIT_PORT: 8000
            # CONDUIT_CONFIG: '/srv/conduit/conduit.toml'  # if you want to configure purely by env vars, set this to an empty string ''
            # Available levels are: error, warn, info, debug, trace - more info at: https://docs.rs/env_logger/*/env_logger/#enabling-logging
            # CONDUIT_LOG: info  # default is: "info,rocket=off,_=off,sled=off"
@@ -56,4 +56,4 @@ services:
    #         - homeserver

 volumes:
-  db:
+    db:
@@ -1,70 +0,0 @@
-# ---------------------------------------------------------------------------------------------------------
-# This Dockerfile is intended to be built as part of Conduit's CI pipeline.
-# It does not build Conduit in Docker, but just copies the matching build artifact from the build job.
-# As a consequence, this is not a multiarch capable image. It always expects and packages a x86_64 binary.
-#
-# It is mostly based on the normal Conduit Dockerfile, but adjusted in a few places to maximise caching.
-# Credit's for the original Dockerfile: Weasy666.
-# ---------------------------------------------------------------------------------------------------------
-
-FROM alpine:3.14
-
-ARG CREATED
-ARG VERSION
-ARG GIT_REF
-
-ENV CONDUIT_CONFIG="/srv/conduit/conduit.toml"
-
-# Labels according to https://github.com/opencontainers/image-spec/blob/master/annotations.md
-# including a custom label specifying the build command
-LABEL org.opencontainers.image.created=${CREATED} \
-      org.opencontainers.image.authors="Conduit Contributors" \
-      org.opencontainers.image.title="Conduit" \
-      org.opencontainers.image.version=${VERSION} \
-      org.opencontainers.image.vendor="Conduit Contributors" \
-      org.opencontainers.image.description="A Matrix homeserver written in Rust" \
-      org.opencontainers.image.url="https://conduit.rs/" \
-      org.opencontainers.image.revision=${GIT_REF} \
-      org.opencontainers.image.source="https://gitlab.com/famedly/conduit.git" \
-      org.opencontainers.image.licenses="Apache-2.0" \
-      org.opencontainers.image.documentation="" \
-      org.opencontainers.image.ref.name=""
-
-# Standard port on which Conduit launches. You still need to map the port when using the docker command or docker-compose.
-EXPOSE 6167
-
-# create data folder for database
-RUN mkdir -p /srv/conduit/.local/share/conduit
-
-# Add www-data user and group with UID 82, as used by alpine
-# https://git.alpinelinux.org/aports/tree/main/nginx/nginx.pre-install
-RUN set -x ; \
-    addgroup -Sg 82 www-data 2>/dev/null ; \
-    adduser -S -D -H -h /srv/conduit -G www-data -g www-data www-data 2>/dev/null ; \
-    addgroup www-data www-data 2>/dev/null && exit 0 ; exit 1
-
-# Change ownership of Conduit files to www-data user and group
-RUN chown -cR www-data:www-data /srv/conduit
-
-# Install packages needed to run Conduit
-RUN apk add --no-cache \
-        ca-certificates \
-        curl \
-        libgcc
-
-# Test if Conduit is still alive, uses the same endpoint as Element
-HEALTHCHECK --start-period=5s \
-    CMD curl --fail -s "http://localhost:$(grep -m1 -o 'port\s=\s[0-9]*' conduit.toml | grep -m1 -o '[0-9]*')/_matrix/client/versions" || \
-        curl -k --fail -s "https://localhost:$(grep -m1 -o 'port\s=\s[0-9]*' conduit.toml | grep -m1 -o '[0-9]*')/_matrix/client/versions" || \
-        exit 1
-
-# Set user to www-data
-USER www-data
-# Set container home directory
-WORKDIR /srv/conduit
-# Run Conduit
-ENTRYPOINT [ "/srv/conduit/conduit" ]
-
-
-# Copy the Conduit binary into the image at the latest possible moment to maximise caching:
-COPY ./conduit-x86_64-unknown-linux-musl /srv/conduit/conduit
@@ -12,8 +12,8 @@ services:
        # build:
        #     context: .
        #     args:
-        #         CREATED: '2021-03-16T08:18:27Z'
-        #         VERSION: '0.1.0'
+        #         CREATED:
+        #         VERSION:
        #         LOCAL: 'false'
        #         GIT_REF: origin/master
        restart: unless-stopped
@@ -25,12 +25,12 @@ services:
        networks:
            - proxy
        environment:
-            CONDUIT_SERVER_NAME: localhost:6167  # replace with your own name
+            CONDUIT_SERVER_NAME: localhost:8000  # replace with your own name
            CONDUIT_TRUSTED_SERVERS: '["matrix.org"]'
            ### Uncomment and change values as desired
-            # CONDUIT_ADDRESS: 0.0.0.0
-            # CONDUIT_PORT: 6167
-            # CONDUIT_CONFIG: '/srv/conduit/conduit.toml'  # if you want to configure purely by env vars, set this to an empty string ''
+            # CONDUIT_ADDRESS: 127.0.0.1
+            # CONDUIT_PORT: 8000
+            # CONDUIT_CONFIG: '/srv/conduit/conduit.toml'  # if want to configure purely by env vars, set this to an empty string ''
            # Available levels are: error, warn, info, debug, trace - more info at: https://docs.rs/env_logger/*/env_logger/#enabling-logging
            # CONDUIT_LOG: info  # default is: "info,rocket=off,_=off,sled=off"
            # CONDUIT_ALLOW_JAEGER: 'false'
@@ -59,7 +59,7 @@ volumes:
    db:

 networks:
-    # This is the network Traefik listens to, if your network has a different
+    # This is the network Traefik listens to, if you network has a different
    # name, don't forget to change it here and in the docker-compose.override.yml
    proxy:
        external: true
@@ -1 +1 @@
-1.52
+1.51.0
@@ -1,5 +1,6 @@
 use crate::{utils, Error, Result};
 use bytes::BytesMut;
+use log::warn;
 use ruma::api::{IncomingResponse, OutgoingRequest, SendAccessToken};
 use std::{
    convert::{TryFrom, TryInto},
@@ -7,7 +8,6 @@ use std::{
    mem,
    time::Duration,
 };
-use tracing::warn;

 pub async fn send_request<T: OutgoingRequest>(
    globals: &crate::database::globals::Globals,
@@ -47,8 +47,7 @@ where

    let url = reqwest_request.url().clone();
    let mut response = globals
-        .reqwest_client()?
-        .build()?
+        .reqwest_client()
        .execute(reqwest_request)
        .await?;

@@ -1,11 +1,8 @@
-use std::{
-    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
-    sync::Arc,
-};
+use std::{collections::BTreeMap, convert::TryInto, sync::Arc};

-use super::{DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
-use crate::{database::DatabaseGuard, pdu::PduBuilder, utils, ConduitResult, Error, Ruma};
+use super::{State, DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
+use crate::{pdu::PduBuilder, utils, ConduitResult, Database, Error, Ruma};
+use log::info;
 use ruma::{
    api::client::{
        error::ErrorKind,
@@ -14,7 +11,6 @@ use ruma::{
                change_password, deactivate, get_username_availability, register, whoami,
                ThirdPartyIdRemovalStatus,
            },
-            contact::get_contacts,
            uiaa::{AuthFlow, UiaaInfo},
        },
    },
@@ -25,10 +21,8 @@ use ruma::{
        },
        EventType,
    },
-    identifiers::RoomName,
    push, RoomAliasId, RoomId, RoomVersionId, UserId,
 };
-use tracing::info;

 use register::RegistrationKind;
 #[cfg(feature = "conduit_bin")]
@@ -48,7 +42,7 @@ const GUEST_NAME_LENGTH: usize = 10;
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_register_available_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_username_availability::Request<'_>>,
 ) -> ConduitResult<get_username_availability::Response> {
    // Validate user id
@@ -91,7 +85,7 @@ pub async fn get_register_available_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn register_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<register::Request<'_>>,
 ) -> ConduitResult<register::Response> {
    if !db.globals.allow_registration() && !body.from_appservice {
@@ -162,18 +156,16 @@ pub async fn register_route(
                return Err(Error::Uiaa(uiaainfo));
            }
        // Success!
-        } else if let Some(json) = body.json_body {
+        } else {
            uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
            db.uiaa.create(
                &UserId::parse_with_server_name("", db.globals.server_name())
                    .expect("we know this is valid"),
                "".into(),
                &uiaainfo,
-                &json,
+                &body.json_body.expect("body is json"),
            )?;
            return Err(Error::Uiaa(uiaainfo));
-        } else {
-            return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
        }
    }

@@ -193,11 +185,6 @@ pub async fn register_route(
    // Create user
    db.users.create(&user_id, password)?;

-    let displayname = format!("{} ⚡️", user_id.localpart());
-
-    db.users
-        .set_displayname(&user_id, Some(displayname.clone()))?;
-
    // Initial data
    db.account_data.update(
        None,
@@ -249,18 +236,6 @@ pub async fn register_route(

        let room_id = RoomId::new(db.globals.server_name());

-        db.rooms.get_or_create_shortroomid(&room_id, &db.globals)?;
-
-        let mutex_state = Arc::clone(
-            db.globals
-                .roomid_mutex_state
-                .write()
-                .unwrap()
-                .entry(room_id.clone())
-                .or_default(),
-        );
-        let state_lock = mutex_state.lock().await;
-
        let mut content = ruma::events::room::create::CreateEventContent::new(conduit_user.clone());
        content.federate = true;
        content.predecessor = None;
@@ -278,7 +253,6 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;

        // 2. Make conduit bot join
@@ -291,8 +265,6 @@ pub async fn register_route(
                    avatar_url: None,
                    is_direct: None,
                    third_party_invite: None,
-                    blurhash: None,
-                    reason: None,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -302,7 +274,6 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;

        // 3. Power levels
@@ -327,7 +298,6 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;

        // 4.1 Join Rules
@@ -345,7 +315,6 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;

        // 4.2 History Visibility
@@ -365,7 +334,6 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;

        // 4.3 Guest Access
@@ -383,18 +351,18 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;

        // 6. Events implied by name and topic
-        let room_name =
-            Box::<RoomName>::try_from(format!("{} Admin Room", db.globals.server_name()))
-                .expect("Room name is valid");
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomName,
-                content: serde_json::to_value(name::NameEventContent::new(Some(room_name)))
-                    .expect("event is valid, we just created it"),
+                content: serde_json::to_value(
+                    name::NameEventContent::new("Admin Room".to_owned()).map_err(|_| {
+                        Error::BadRequest(ErrorKind::InvalidParam, "Name is invalid.")
+                    })?,
+                )
+                .expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
                redacts: None,
@@ -402,7 +370,6 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;

        db.rooms.build_and_append_pdu(
@@ -419,7 +386,6 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;

        // Room alias
@@ -442,7 +408,6 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;

        db.rooms.set_alias(&alias, Some(&room_id), &db.globals)?;
@@ -457,8 +422,6 @@ pub async fn register_route(
                    avatar_url: None,
                    is_direct: None,
                    third_party_invite: None,
-                    blurhash: None,
-                    reason: None,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -468,19 +431,16 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomMember,
                content: serde_json::to_value(member::MemberEventContent {
                    membership: member::MembershipState::Join,
-                    displayname: Some(displayname),
+                    displayname: None,
                    avatar_url: None,
                    is_direct: None,
                    third_party_invite: None,
-                    blurhash: None,
-                    reason: None,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -490,7 +450,6 @@ pub async fn register_route(
            &user_id,
            &room_id,
            &db,
-            &state_lock,
        )?;

        // Send welcome message
@@ -509,13 +468,12 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
        )?;
    }

    info!("{} registered on this server", user_id);

-    db.flush()?;
+    db.flush().await?;

    Ok(register::Response {
        access_token: Some(token),
@@ -538,7 +496,7 @@ pub async fn register_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn change_password_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<change_password::Request<'_>>,
 ) -> ConduitResult<change_password::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -567,13 +525,15 @@ pub async fn change_password_route(
            return Err(Error::Uiaa(uiaainfo));
        }
    // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
    } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
    }

    db.users
@@ -591,9 +551,9 @@ pub async fn change_password_route(
        }
    }

-    db.flush()?;
+    db.flush().await?;

-    Ok(change_password::Response {}.into())
+    Ok(change_password::Response.into())
 }

 /// # `GET _matrix/client/r0/account/whoami`
@@ -628,7 +588,7 @@ pub async fn whoami_route(body: Ruma<whoami::Request>) -> ConduitResult<whoami::
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn deactivate_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<deactivate::Request<'_>>,
 ) -> ConduitResult<deactivate::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -657,27 +617,23 @@ pub async fn deactivate_route(
            return Err(Error::Uiaa(uiaainfo));
        }
    // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
    } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
    }

    // Leave all joined rooms and reject all invitations
-    let all_rooms = db
-        .rooms
-        .rooms_joined(&sender_user)
-        .chain(
-            db.rooms
-                .rooms_invited(&sender_user)
-                .map(|t| t.map(|(r, _)| r)),
-        )
-        .collect::<Vec<_>>();
-
-    for room_id in all_rooms {
+    for room_id in db.rooms.rooms_joined(&sender_user).chain(
+        db.rooms
+            .rooms_invited(&sender_user)
+            .map(|t| t.map(|(r, _)| r)),
+    ) {
        let room_id = room_id?;
        let event = member::MemberEventContent {
            membership: member::MembershipState::Leave,
@@ -685,20 +641,8 @@ pub async fn deactivate_route(
            avatar_url: None,
            is_direct: None,
            third_party_invite: None,
-            blurhash: None,
-            reason: None,
        };

-        let mutex_state = Arc::clone(
-            db.globals
-                .roomid_mutex_state
-                .write()
-                .unwrap()
-                .entry(room_id.clone())
-                .or_default(),
-        );
-        let state_lock = mutex_state.lock().await;
-
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomMember,
@@ -710,7 +654,6 @@ pub async fn deactivate_route(
            &sender_user,
            &room_id,
            &db,
-            &state_lock,
        )?;
    }

@@ -719,7 +662,7 @@ pub async fn deactivate_route(

    info!("{} deactivated their account", sender_user);

-    db.flush()?;
+    db.flush().await?;

    Ok(deactivate::Response {
        id_server_unbind_result: ThirdPartyIdRemovalStatus::NoSupport,
@@ -727,17 +670,16 @@ pub async fn deactivate_route(
    .into())
 }

-/// # `GET _matrix/client/r0/account/3pid`
-///
-/// Get a list of third party identifiers associated with this account.
+/*/
 #[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/client/r0/account/3pid", data = "<body>")
 )]
 pub async fn third_party_route(
-    body: Ruma<get_contacts::Request>,
-) -> ConduitResult<get_contacts::Response> {
-    let _sender_user = body.sender_user.as_ref().expect("user is authenticated");
+    body: Ruma<account::add_3pid::Request<'_>>,
+) -> ConduitResult<account::add_3pid::Response> {
+    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    Ok(get_contacts::Response::new(Vec::new()).into())
+    Ok(account::add_3pid::Response::default().into())
 }
+*/
@@ -1,4 +1,7 @@
-use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Ruma};
+use std::sync::Arc;
+
+use super::State;
+use crate::{ConduitResult, Database, Error, Ruma};
 use regex::Regex;
 use ruma::{
    api::{
@@ -21,7 +24,7 @@ use rocket::{delete, get, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn create_alias_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<create_alias::Request<'_>>,
 ) -> ConduitResult<create_alias::Response> {
    if db.rooms.id_from_alias(&body.room_alias)?.is_some() {
@@ -31,7 +34,7 @@ pub async fn create_alias_route(
    db.rooms
        .set_alias(&body.room_alias, Some(&body.room_id), &db.globals)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(create_alias::Response::new().into())
 }
@@ -42,12 +45,12 @@ pub async fn create_alias_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn delete_alias_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<delete_alias::Request<'_>>,
 ) -> ConduitResult<delete_alias::Response> {
    db.rooms.set_alias(&body.room_alias, None, &db.globals)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(delete_alias::Response::new().into())
 }
@@ -58,7 +61,7 @@ pub async fn delete_alias_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_alias_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_alias::Request<'_>>,
 ) -> ConduitResult<get_alias::Response> {
    get_alias_helper(&db, &body.room_alias).await
@@ -85,7 +88,8 @@ pub async fn get_alias_helper(
    match db.rooms.id_from_alias(&room_alias)? {
        Some(r) => room_id = Some(r),
        None => {
-            for (_id, registration) in db.appservice.all()? {
+            let iter = db.appservice.iter_all()?;
+            for (_id, registration) in iter.filter_map(|r| r.ok()) {
                let aliases = registration
                    .get("namespaces")
                    .and_then(|ns| ns.get("aliases"))
@@ -1,4 +1,7 @@
-use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
+use std::sync::Arc;
+
+use super::State;
+use crate::{ConduitResult, Database, Error, Ruma};
 use ruma::api::client::{
    error::ErrorKind,
    r0::backup::{
@@ -18,7 +21,7 @@ use rocket::{delete, get, post, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn create_backup_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<create_backup::Request>,
 ) -> ConduitResult<create_backup::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -26,7 +29,7 @@ pub async fn create_backup_route(
        .key_backups
        .create_backup(&sender_user, &body.algorithm, &db.globals)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(create_backup::Response { version }.into())
 }
@@ -37,16 +40,16 @@ pub async fn create_backup_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn update_backup_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<update_backup::Request<'_>>,
 ) -> ConduitResult<update_backup::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
    db.key_backups
        .update_backup(&sender_user, &body.version, &body.algorithm, &db.globals)?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(update_backup::Response {}.into())
+    Ok(update_backup::Response.into())
 }

 #[cfg_attr(
@@ -55,7 +58,7 @@ pub async fn update_backup_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_latest_backup_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_latest_backup::Request>,
 ) -> ConduitResult<get_latest_backup::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -83,7 +86,7 @@ pub async fn get_latest_backup_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_backup_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_backup::Request<'_>>,
 ) -> ConduitResult<get_backup::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -110,16 +113,16 @@ pub async fn get_backup_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn delete_backup_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<delete_backup::Request<'_>>,
 ) -> ConduitResult<delete_backup::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    db.key_backups.delete_backup(&sender_user, &body.version)?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(delete_backup::Response {}.into())
+    Ok(delete_backup::Response.into())
 }

 /// Add the received backup keys to the database.
@@ -129,7 +132,7 @@ pub async fn delete_backup_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn add_backup_keys_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<add_backup_keys::Request<'_>>,
 ) -> ConduitResult<add_backup_keys::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -147,7 +150,7 @@ pub async fn add_backup_keys_route(
        }
    }

-    db.flush()?;
+    db.flush().await?;

    Ok(add_backup_keys::Response {
        count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -163,7 +166,7 @@ pub async fn add_backup_keys_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn add_backup_key_sessions_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<add_backup_key_sessions::Request<'_>>,
 ) -> ConduitResult<add_backup_key_sessions::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -179,7 +182,7 @@ pub async fn add_backup_key_sessions_route(
        )?
    }

-    db.flush()?;
+    db.flush().await?;

    Ok(add_backup_key_sessions::Response {
        count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -195,7 +198,7 @@ pub async fn add_backup_key_sessions_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn add_backup_key_session_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<add_backup_key_session::Request<'_>>,
 ) -> ConduitResult<add_backup_key_session::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -209,7 +212,7 @@ pub async fn add_backup_key_session_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

    Ok(add_backup_key_session::Response {
        count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -224,7 +227,7 @@ pub async fn add_backup_key_session_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_backup_keys_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_backup_keys::Request<'_>>,
 ) -> ConduitResult<get_backup_keys::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -240,7 +243,7 @@ pub async fn get_backup_keys_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_backup_key_sessions_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_backup_key_sessions::Request<'_>>,
 ) -> ConduitResult<get_backup_key_sessions::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -258,7 +261,7 @@ pub async fn get_backup_key_sessions_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_backup_key_session_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_backup_key_session::Request<'_>>,
 ) -> ConduitResult<get_backup_key_session::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -280,7 +283,7 @@ pub async fn get_backup_key_session_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn delete_backup_keys_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<delete_backup_keys::Request<'_>>,
 ) -> ConduitResult<delete_backup_keys::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -288,7 +291,7 @@ pub async fn delete_backup_keys_route(
    db.key_backups
        .delete_all_keys(&sender_user, &body.version)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(delete_backup_keys::Response {
        count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -303,7 +306,7 @@ pub async fn delete_backup_keys_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn delete_backup_key_sessions_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<delete_backup_key_sessions::Request<'_>>,
 ) -> ConduitResult<delete_backup_key_sessions::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -311,7 +314,7 @@ pub async fn delete_backup_key_sessions_route(
    db.key_backups
        .delete_room_keys(&sender_user, &body.version, &body.room_id)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(delete_backup_key_sessions::Response {
        count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -326,7 +329,7 @@ pub async fn delete_backup_key_sessions_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn delete_backup_key_session_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<delete_backup_key_session::Request<'_>>,
 ) -> ConduitResult<delete_backup_key_session::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -334,7 +337,7 @@ pub async fn delete_backup_key_session_route(
    db.key_backups
        .delete_room_key(&sender_user, &body.version, &body.room_id, &body.session_id)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(delete_backup_key_session::Response {
        count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -1,5 +1,4 @@
 use crate::ConduitResult;
-use crate::Ruma;
 use ruma::{
    api::client::r0::capabilities::{
        get_capabilities, Capabilities, RoomVersionStability, RoomVersionsCapability,
@@ -14,16 +13,10 @@ use rocket::get;
 /// # `GET /_matrix/client/r0/capabilities`
 ///
 /// Get information on this server's supported feature set and other relevent capabilities.
-#[cfg_attr(
-    feature = "conduit_bin",
-    get("/_matrix/client/r0/capabilities", data = "<_body>")
-)]
-#[tracing::instrument(skip(_body))]
-pub async fn get_capabilities_route(
-    _body: Ruma<get_capabilities::Request>,
-) -> ConduitResult<get_capabilities::Response> {
+#[cfg_attr(feature = "conduit_bin", get("/_matrix/client/r0/capabilities"))]
+#[tracing::instrument]
+pub async fn get_capabilities_route() -> ConduitResult<get_capabilities::Response> {
    let mut available = BTreeMap::new();
-    available.insert(RoomVersionId::Version5, RoomVersionStability::Stable);
    available.insert(RoomVersionId::Version6, RoomVersionStability::Stable);

    let mut capabilities = Capabilities::new();
@@ -1,4 +1,7 @@
-use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
+use std::sync::Arc;
+
+use super::State;
+use crate::{ConduitResult, Database, Error, Ruma};
 use ruma::{
    api::client::{
        error::ErrorKind,
@@ -22,7 +25,7 @@ use rocket::{get, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_global_account_data_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_global_account_data::Request<'_>>,
 ) -> ConduitResult<set_global_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -43,9 +46,9 @@ pub async fn set_global_account_data_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_global_account_data::Response {}.into())
+    Ok(set_global_account_data::Response.into())
 }

 #[cfg_attr(
@@ -57,7 +60,7 @@ pub async fn set_global_account_data_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_room_account_data_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_room_account_data::Request<'_>>,
 ) -> ConduitResult<set_room_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -78,9 +81,9 @@ pub async fn set_room_account_data_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_room_account_data::Response {}.into())
+    Ok(set_room_account_data::Response.into())
 }

 #[cfg_attr(
@@ -89,7 +92,7 @@ pub async fn set_room_account_data_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_global_account_data_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_global_account_data::Request<'_>>,
 ) -> ConduitResult<get_global_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -98,7 +101,7 @@ pub async fn get_global_account_data_route(
        .account_data
        .get::<Box<RawJsonValue>>(None, sender_user, body.event_type.clone().into())?
        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
-    db.flush()?;
+    db.flush().await?;

    let account_data = serde_json::from_str::<ExtractGlobalEventContent>(event.get())
        .map_err(|_| Error::bad_database("Invalid account data event in db."))?
@@ -116,7 +119,7 @@ pub async fn get_global_account_data_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_room_account_data_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_room_account_data::Request<'_>>,
 ) -> ConduitResult<get_room_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -129,7 +132,7 @@ pub async fn get_room_account_data_route(
            body.event_type.clone().into(),
        )?
        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
-    db.flush()?;
+    db.flush().await?;

    let account_data = serde_json::from_str::<ExtractRoomEventContent>(event.get())
        .map_err(|_| Error::bad_database("Invalid account data event in db."))?
@@ -1,6 +1,7 @@
-use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
+use super::State;
+use crate::{ConduitResult, Database, Error, Ruma};
 use ruma::api::client::{error::ErrorKind, r0::context::get_context};
-use std::convert::TryFrom;
+use std::{convert::TryFrom, sync::Arc};

 #[cfg(feature = "conduit_bin")]
 use rocket::get;
@@ -11,7 +12,7 @@ use rocket::get;
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_context_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_context::Request<'_>>,
 ) -> ConduitResult<get_context::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -44,7 +45,7 @@ pub async fn get_context_route(

    let events_before = db
        .rooms
-        .pdus_until(&sender_user, &body.room_id, base_token)?
+        .pdus_until(&sender_user, &body.room_id, base_token)
        .take(
            u32::try_from(body.limit).map_err(|_| {
                Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.")
@@ -66,7 +67,7 @@ pub async fn get_context_route(

    let events_after = db
        .rooms
-        .pdus_after(&sender_user, &body.room_id, base_token)?
+        .pdus_after(&sender_user, &body.room_id, base_token)
        .take(
            u32::try_from(body.limit).map_err(|_| {
                Error::BadRequest(ErrorKind::InvalidParam, "Limit value is invalid.")
@@ -1,4 +1,7 @@
-use crate::{database::DatabaseGuard, utils, ConduitResult, Error, Ruma};
+use std::sync::Arc;
+
+use super::State;
+use crate::{utils, ConduitResult, Database, Error, Ruma};
 use ruma::api::client::{
    error::ErrorKind,
    r0::{
@@ -17,7 +20,7 @@ use rocket::{delete, get, post, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_devices_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_devices::Request>,
 ) -> ConduitResult<get_devices::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -37,7 +40,7 @@ pub async fn get_devices_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_device_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_device::Request<'_>>,
 ) -> ConduitResult<get_device::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -56,7 +59,7 @@ pub async fn get_device_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn update_device_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<update_device::Request<'_>>,
 ) -> ConduitResult<update_device::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -71,9 +74,9 @@ pub async fn update_device_route(
    db.users
        .update_device_metadata(&sender_user, &body.device_id, &device)?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(update_device::Response {}.into())
+    Ok(update_device::Response.into())
 }

 #[cfg_attr(
@@ -82,7 +85,7 @@ pub async fn update_device_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn delete_device_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<delete_device::Request<'_>>,
 ) -> ConduitResult<delete_device::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -112,20 +115,22 @@ pub async fn delete_device_route(
            return Err(Error::Uiaa(uiaainfo));
        }
    // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
    } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
    }

    db.users.remove_device(&sender_user, &body.device_id)?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(delete_device::Response {}.into())
+    Ok(delete_device::Response.into())
 }

 #[cfg_attr(
@@ -134,7 +139,7 @@ pub async fn delete_device_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn delete_devices_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<delete_devices::Request<'_>>,
 ) -> ConduitResult<delete_devices::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -164,20 +169,22 @@ pub async fn delete_devices_route(
            return Err(Error::Uiaa(uiaainfo));
        }
    // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
    } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
    }

    for device_id in &body.devices {
        db.users.remove_device(&sender_user, &device_id)?
    }

-    db.flush()?;
+    db.flush().await?;

-    Ok(delete_devices::Response {}.into())
+    Ok(delete_devices::Response.into())
 }
@@ -1,6 +1,8 @@
-use std::convert::TryInto;
+use std::sync::Arc;

-use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Result, Ruma};
+use super::State;
+use crate::{ConduitResult, Database, Error, Result, Ruma};
+use log::info;
 use ruma::{
    api::{
        client::{
@@ -23,7 +25,6 @@ use ruma::{
    serde::Raw,
    ServerName, UInt,
 };
-use tracing::{info, warn};

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post, put};
@@ -34,7 +35,7 @@ use rocket::{get, post, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_public_rooms_filtered_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_public_rooms_filtered::Request<'_>>,
 ) -> ConduitResult<get_public_rooms_filtered::Response> {
    get_public_rooms_filtered_helper(
@@ -54,7 +55,7 @@ pub async fn get_public_rooms_filtered_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_public_rooms_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_public_rooms::Request<'_>>,
 ) -> ConduitResult<get_public_rooms::Response> {
    let response = get_public_rooms_filtered_helper(
@@ -83,28 +84,28 @@ pub async fn get_public_rooms_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_room_visibility_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_room_visibility::Request<'_>>,
 ) -> ConduitResult<set_room_visibility::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    match &body.visibility {
-        room::Visibility::Public => {
-            db.rooms.set_public(&body.room_id, true)?;
-            info!("{} made {} public", sender_user, body.room_id);
-        }
-        room::Visibility::Private => db.rooms.set_public(&body.room_id, false)?,
-        _ => {
+        room::Visibility::_Custom(_s) => {
            return Err(Error::BadRequest(
                ErrorKind::InvalidParam,
                "Room visibility type is not supported.",
            ));
        }
+        room::Visibility::Public => {
+            db.rooms.set_public(&body.room_id, true)?;
+            info!("{} made {} public", sender_user, body.room_id);
+        }
+        room::Visibility::Private => db.rooms.set_public(&body.room_id, false)?,
    }

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_room_visibility::Response {}.into())
+    Ok(set_room_visibility::Response.into())
 }

 #[cfg_attr(
@@ -113,7 +114,7 @@ pub async fn set_room_visibility_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_room_visibility_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_room_visibility::Request<'_>>,
 ) -> ConduitResult<get_room_visibility::Response> {
    Ok(get_room_visibility::Response {
@@ -233,18 +234,10 @@ pub async fn get_public_rooms_filtered_helper(
                            .map_err(|_| {
                                Error::bad_database("Invalid room name event in database.")
                            })?
-                            .name
-                            .map(|n| n.to_owned().into()))
+                            .name()
+                            .map(|n| n.to_owned()))
                        })?,
-                    num_joined_members: db
-                        .rooms
-                        .room_joined_count(&room_id)?
-                        .unwrap_or_else(|| {
-                            warn!("Room {} has no member count", room_id);
-                            0
-                        })
-                        .try_into()
-                        .expect("user count should not be that big"),
+                    num_joined_members: (db.rooms.room_members(&room_id).count() as u32).into(),
                    topic: db
                        .rooms
                        .room_state_get(&room_id, &EventType::RoomTopic, "")?
@@ -326,7 +319,7 @@ pub async fn get_public_rooms_filtered_helper(
                    .map(|q| q.to_lowercase())
                {
                    if let Some(name) = &chunk.name {
-                        if name.as_str().to_lowercase().contains(&query) {
+                        if name.to_lowercase().contains(&query) {
                            return true;
                        }
                    }
@@ -1,25 +1,23 @@
-use super::SESSION_ID_LENGTH;
-use crate::{database::DatabaseGuard, utils, ConduitResult, Database, Error, Result, Ruma};
-use rocket::futures::{prelude::*, stream::FuturesUnordered};
+use super::{State, SESSION_ID_LENGTH};
+use crate::{utils, ConduitResult, Database, Error, Result, Ruma};
 use ruma::{
-    api::{
-        client::{
-            error::ErrorKind,
-            r0::{
-                keys::{
-                    claim_keys, get_key_changes, get_keys, upload_keys, upload_signatures,
-                    upload_signing_keys,
-                },
-                uiaa::{AuthFlow, UiaaInfo},
+    api::client::{
+        error::ErrorKind,
+        r0::{
+            keys::{
+                claim_keys, get_key_changes, get_keys, upload_keys, upload_signatures,
+                upload_signing_keys,
            },
+            uiaa::{AuthFlow, UiaaInfo},
        },
-        federation,
    },
    encryption::UnsignedDeviceInfo,
    DeviceId, DeviceKeyAlgorithm, UserId,
 };
-use serde_json::json;
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::{
+    collections::{BTreeMap, HashSet},
+    sync::Arc,
+};

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post};
@@ -30,7 +28,7 @@ use rocket::{get, post};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn upload_keys_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<upload_keys::Request>,
 ) -> ConduitResult<upload_keys::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -65,7 +63,7 @@ pub async fn upload_keys_route(
        }
    }

-    db.flush()?;
+    db.flush().await?;

    Ok(upload_keys::Response {
        one_time_key_counts: db.users.count_one_time_keys(sender_user, sender_device)?,
@@ -79,7 +77,7 @@ pub async fn upload_keys_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_keys_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_keys::Request<'_>>,
 ) -> ConduitResult<get_keys::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -89,8 +87,7 @@ pub async fn get_keys_route(
        &body.device_keys,
        |u| u == sender_user,
        &db,
-    )
-    .await?;
+    )?;

    Ok(response.into())
 }
@@ -101,12 +98,12 @@ pub async fn get_keys_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn claim_keys_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<claim_keys::Request>,
 ) -> ConduitResult<claim_keys::Response> {
-    let response = claim_keys_helper(&body.one_time_keys, &db).await?;
+    let response = claim_keys_helper(&body.one_time_keys, &db)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(response.into())
 }
@@ -117,7 +114,7 @@ pub async fn claim_keys_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn upload_signing_keys_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<upload_signing_keys::Request<'_>>,
 ) -> ConduitResult<upload_signing_keys::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -147,13 +144,15 @@ pub async fn upload_signing_keys_route(
            return Err(Error::Uiaa(uiaainfo));
        }
    // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
    } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
    }

    if let Some(master_key) = &body.master_key {
@@ -167,9 +166,9 @@ pub async fn upload_signing_keys_route(
        )?;
    }

-    db.flush()?;
+    db.flush().await?;

-    Ok(upload_signing_keys::Response {}.into())
+    Ok(upload_signing_keys::Response.into())
 }

 #[cfg_attr(
@@ -178,7 +177,7 @@ pub async fn upload_signing_keys_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn upload_signatures_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<upload_signatures::Request>,
 ) -> ConduitResult<upload_signatures::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -228,9 +227,9 @@ pub async fn upload_signatures_route(
        }
    }

-    db.flush()?;
+    db.flush().await?;

-    Ok(upload_signatures::Response {}.into())
+    Ok(upload_signatures::Response.into())
 }

 #[cfg_attr(
@@ -239,7 +238,7 @@ pub async fn upload_signatures_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_key_changes_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_key_changes::Request<'_>>,
 ) -> ConduitResult<get_key_changes::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -284,7 +283,7 @@ pub async fn get_key_changes_route(
    .into())
 }

-pub async fn get_keys_helper<F: Fn(&UserId) -> bool>(
+pub fn get_keys_helper<F: Fn(&UserId) -> bool>(
    sender_user: Option<&UserId>,
    device_keys_input: &BTreeMap<UserId, Vec<Box<DeviceId>>>,
    allowed_signatures: F,
@@ -295,17 +294,7 @@ pub async fn get_keys_helper<F: Fn(&UserId) -> bool>(
    let mut user_signing_keys = BTreeMap::new();
    let mut device_keys = BTreeMap::new();

-    let mut get_over_federation = HashMap::new();
-
    for (user_id, device_ids) in device_keys_input {
-        if user_id.server_name() != db.globals.server_name() {
-            get_over_federation
-                .entry(user_id.server_name())
-                .or_insert_with(Vec::new)
-                .push((user_id, device_ids));
-            continue;
-        }
-
        if device_ids.is_empty() {
            let mut container = BTreeMap::new();
            for device_id in db.users.all_device_ids(user_id) {
@@ -363,68 +352,21 @@ pub async fn get_keys_helper<F: Fn(&UserId) -> bool>(
        }
    }

-    let mut failures = BTreeMap::new();
-
-    let mut futures = get_over_federation
-        .into_iter()
-        .map(|(server, vec)| async move {
-            let mut device_keys_input_fed = BTreeMap::new();
-            for (user_id, keys) in vec {
-                device_keys_input_fed.insert(user_id.clone(), keys.clone());
-            }
-            (
-                server,
-                db.sending
-                    .send_federation_request(
-                        &db.globals,
-                        server,
-                        federation::keys::get_keys::v1::Request {
-                            device_keys: device_keys_input_fed,
-                        },
-                    )
-                    .await,
-            )
-        })
-        .collect::<FuturesUnordered<_>>();
-
-    while let Some((server, response)) = futures.next().await {
-        match response {
-            Ok(response) => {
-                master_keys.extend(response.master_keys);
-                self_signing_keys.extend(response.self_signing_keys);
-                device_keys.extend(response.device_keys);
-            }
-            Err(_e) => {
-                failures.insert(server.to_string(), json!({}));
-            }
-        }
-    }
-
    Ok(get_keys::Response {
        master_keys,
        self_signing_keys,
        user_signing_keys,
        device_keys,
-        failures,
+        failures: BTreeMap::new(),
    })
 }

-pub async fn claim_keys_helper(
+pub fn claim_keys_helper(
    one_time_keys_input: &BTreeMap<UserId, BTreeMap<Box<DeviceId>, DeviceKeyAlgorithm>>,
    db: &Database,
 ) -> Result<claim_keys::Response> {
    let mut one_time_keys = BTreeMap::new();
-
-    let mut get_over_federation = BTreeMap::new();
-
    for (user_id, map) in one_time_keys_input {
-        if user_id.server_name() != db.globals.server_name() {
-            get_over_federation
-                .entry(user_id.server_name())
-                .or_insert_with(Vec::new)
-                .push((user_id, map));
-        }
-
        let mut container = BTreeMap::new();
        for (device_id, key_algorithm) in map {
            if let Some(one_time_keys) =
@@ -439,33 +381,8 @@ pub async fn claim_keys_helper(
        one_time_keys.insert(user_id.clone(), container);
    }

-    let mut failures = BTreeMap::new();
-
-    for (server, vec) in get_over_federation {
-        let mut one_time_keys_input_fed = BTreeMap::new();
-        for (user_id, keys) in vec {
-            one_time_keys_input_fed.insert(user_id.clone(), keys.clone());
-        }
-        // Ignore failures
-        if let Ok(keys) = db
-            .sending
-            .send_federation_request(
-                &db.globals,
-                server,
-                federation::keys::claim_keys::v1::Request {
-                    one_time_keys: one_time_keys_input_fed,
-                },
-            )
-            .await
-        {
-            one_time_keys.extend(keys.one_time_keys);
-        } else {
-            failures.insert(server.to_string(), json!({}));
-        }
-    }
-
    Ok(claim_keys::Response {
-        failures,
+        failures: BTreeMap::new(),
        one_time_keys,
    })
 }
@@ -1,21 +1,20 @@
-use crate::{
-    database::media::FileMeta, database::DatabaseGuard, utils, ConduitResult, Error, Ruma,
-};
+use super::State;
+use crate::{database::media::FileMeta, utils, ConduitResult, Database, Error, Ruma};
 use ruma::api::client::{
    error::ErrorKind,
    r0::media::{create_content, get_content, get_content_thumbnail, get_media_config},
 };
-use std::convert::TryInto;

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post};
+use std::{convert::TryInto, sync::Arc};

 const MXC_LENGTH: usize = 32;

 #[cfg_attr(feature = "conduit_bin", get("/_matrix/media/r0/config"))]
 #[tracing::instrument(skip(db))]
 pub async fn get_media_config_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
 ) -> ConduitResult<get_media_config::Response> {
    Ok(get_media_config::Response {
        upload_size: db.globals.max_request_size().into(),
@@ -29,7 +28,7 @@ pub async fn get_media_config_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn create_content_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<create_content::Request<'_>>,
 ) -> ConduitResult<create_content::Response> {
    let mxc = format!(
@@ -52,7 +51,7 @@ pub async fn create_content_route(
        )
        .await?;

-    db.flush()?;
+    db.flush().await?;

    Ok(create_content::Response {
        content_uri: mxc.try_into().expect("Invalid mxc:// URI"),
@@ -67,7 +66,7 @@ pub async fn create_content_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_content_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_content::Request<'_>>,
 ) -> ConduitResult<get_content::Response> {
    let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
@@ -120,7 +119,7 @@ pub async fn get_content_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_content_thumbnail_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_content_thumbnail::Request<'_>>,
 ) -> ConduitResult<get_content_thumbnail::Response> {
    let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
@@ -1,9 +1,10 @@
+use super::State;
 use crate::{
    client_server,
-    database::DatabaseGuard,
    pdu::{PduBuilder, PduEvent},
    server_server, utils, ConduitResult, Database, Error, Result, Ruma,
 };
+use log::{debug, error, warn};
 use member::{MemberEventContent, MembershipState};
 use rocket::futures;
 use ruma::{
@@ -28,12 +29,11 @@ use ruma::{
    uint, EventId, RoomId, RoomVersionId, ServerName, UserId,
 };
 use std::{
-    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
+    collections::{btree_map::Entry, BTreeMap, HashSet},
    convert::{TryFrom, TryInto},
    sync::{Arc, RwLock},
    time::{Duration, Instant},
 };
-use tracing::{debug, error, warn};

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post};
@@ -44,7 +44,7 @@ use rocket::{get, post};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn join_room_by_id_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<join_room_by_id::Request<'_>>,
 ) -> ConduitResult<join_room_by_id::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -65,19 +65,14 @@ pub async fn join_room_by_id_route(

    servers.insert(body.room_id.server_name().to_owned());

-    let ret = join_room_by_id_helper(
+    join_room_by_id_helper(
        &db,
        body.sender_user.as_ref(),
        &body.room_id,
-        body.reason.clone(),
        &servers,
        body.third_party_signed.as_ref(),
    )
-    .await;
-
-    db.flush()?;
-
-    ret
+    .await
 }

 #[cfg_attr(
@@ -86,7 +81,7 @@ pub async fn join_room_by_id_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn join_room_by_id_or_alias_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<join_room_by_id_or_alias::Request<'_>>,
 ) -> ConduitResult<join_room_by_id_or_alias::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -121,13 +116,12 @@ pub async fn join_room_by_id_or_alias_route(
        &db,
        body.sender_user.as_ref(),
        &room_id,
-        body.reason.clone(),
        &servers,
        body.third_party_signed.as_ref(),
    )
    .await?;

-    db.flush()?;
+    db.flush().await?;

    Ok(join_room_by_id_or_alias::Response {
        room_id: join_room_response.0.room_id,
@@ -141,16 +135,14 @@ pub async fn join_room_by_id_or_alias_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn leave_room_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<leave_room::Request<'_>>,
 ) -> ConduitResult<leave_room::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    db.rooms
-        .leave_room(sender_user, &body.room_id, body.reason.clone(), &db)
-        .await?;
+    db.rooms.leave_room(sender_user, &body.room_id, &db).await?;

-    db.flush()?;
+    db.flush().await?;

    Ok(leave_room::Response::new().into())
 }
@@ -161,23 +153,15 @@ pub async fn leave_room_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn invite_user_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<invite_user::Request<'_>>,
 ) -> ConduitResult<invite_user::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    if let invite_user::IncomingInvitationRecipient::UserId { user_id } = &body.recipient {
-        invite_helper(
-            sender_user,
-            user_id,
-            &body.room_id,
-            body.reason.clone(),
-            &db,
-            false,
-        )
-        .await?;
-        db.flush()?;
-        Ok(invite_user::Response {}.into())
+        invite_helper(sender_user, user_id, &body.room_id, &db, false).await?;
+        db.flush().await?;
+        Ok(invite_user::Response.into())
    } else {
        Err(Error::BadRequest(ErrorKind::NotFound, "User not found."))
    }
@@ -189,7 +173,7 @@ pub async fn invite_user_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn kick_user_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<kick_user::Request<'_>>,
 ) -> ConduitResult<kick_user::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -213,17 +197,7 @@ pub async fn kick_user_route(
    .map_err(|_| Error::bad_database("Invalid member event in database."))?;

    event.membership = ruma::events::room::member::MembershipState::Leave;
-    event.reason = body.reason.clone();
-
-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(body.room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
+    // TODO: reason

    db.rooms.build_and_append_pdu(
        PduBuilder {
@@ -236,12 +210,9 @@ pub async fn kick_user_route(
        &sender_user,
        &body.room_id,
        &db,
-        &state_lock,
    )?;

-    drop(state_lock);
-
-    db.flush()?;
+    db.flush().await?;

    Ok(kick_user::Response::new().into())
 }
@@ -252,11 +223,13 @@ pub async fn kick_user_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn ban_user_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<ban_user::Request<'_>>,
 ) -> ConduitResult<ban_user::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

+    // TODO: reason
+
    let event = db
        .rooms
        .room_state_get(
@@ -271,8 +244,6 @@ pub async fn ban_user_route(
                avatar_url: db.users.avatar_url(&body.user_id)?,
                is_direct: None,
                third_party_invite: None,
-                blurhash: db.users.blurhash(&body.user_id)?,
-                reason: body.reason.clone(),
            }),
            |event| {
                let mut event = serde_json::from_value::<Raw<member::MemberEventContent>>(
@@ -282,21 +253,10 @@ pub async fn ban_user_route(
                .deserialize()
                .map_err(|_| Error::bad_database("Invalid member event in database."))?;
                event.membership = ruma::events::room::member::MembershipState::Ban;
-                event.reason = body.reason.clone();
                Ok(event)
            },
        )?;

-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(body.room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomMember,
@@ -308,12 +268,9 @@ pub async fn ban_user_route(
        &sender_user,
        &body.room_id,
        &db,
-        &state_lock,
    )?;

-    drop(state_lock);
-
-    db.flush()?;
+    db.flush().await?;

    Ok(ban_user::Response::new().into())
 }
@@ -324,7 +281,7 @@ pub async fn ban_user_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn unban_user_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<unban_user::Request<'_>>,
 ) -> ConduitResult<unban_user::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -348,17 +305,6 @@ pub async fn unban_user_route(
    .map_err(|_| Error::bad_database("Invalid member event in database."))?;

    event.membership = ruma::events::room::member::MembershipState::Leave;
-    event.reason = body.reason.clone();
-
-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(body.room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;

    db.rooms.build_and_append_pdu(
        PduBuilder {
@@ -371,12 +317,9 @@ pub async fn unban_user_route(
        &sender_user,
        &body.room_id,
        &db,
-        &state_lock,
    )?;

-    drop(state_lock);
-
-    db.flush()?;
+    db.flush().await?;

    Ok(unban_user::Response::new().into())
 }
@@ -387,14 +330,14 @@ pub async fn unban_user_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn forget_room_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<forget_room::Request<'_>>,
 ) -> ConduitResult<forget_room::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    db.rooms.forget(&body.room_id, &sender_user)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(forget_room::Response::new().into())
 }
@@ -405,7 +348,7 @@ pub async fn forget_room_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn joined_rooms_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<joined_rooms::Request>,
 ) -> ConduitResult<joined_rooms::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -426,7 +369,7 @@ pub async fn joined_rooms_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_member_events_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_member_events::Request<'_>>,
 ) -> ConduitResult<get_member_events::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -456,7 +399,7 @@ pub async fn get_member_events_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn joined_members_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<joined_members::Request<'_>>,
 ) -> ConduitResult<joined_members::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -494,22 +437,11 @@ async fn join_room_by_id_helper(
    db: &Database,
    sender_user: Option<&UserId>,
    room_id: &RoomId,
-    reason: Option<String>,
    servers: &HashSet<Box<ServerName>>,
    _third_party_signed: Option<&IncomingThirdPartySigned>,
 ) -> ConduitResult<join_room_by_id::Response> {
    let sender_user = sender_user.expect("user is authenticated");

-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
    // Ask a remote server if we don't have this room
    if !db.rooms.exists(&room_id)? && room_id.server_name() != db.globals.server_name() {
        let mut make_join_response_and_server = Err(Error::BadServerResponse(
@@ -525,7 +457,7 @@ async fn join_room_by_id_helper(
                    federation::membership::create_join_event_template::v1::Request {
                        room_id,
                        user_id: sender_user,
-                        ver: &[RoomVersionId::Version5, RoomVersionId::Version6],
+                        ver: &[RoomVersionId::Version6],
                    },
                )
                .await;
@@ -540,12 +472,7 @@ async fn join_room_by_id_helper(
        let (make_join_response, remote_server) = make_join_response_and_server?;

        let room_version = match make_join_response.room_version {
-            Some(room_version)
-                if room_version == RoomVersionId::Version5
-                    || room_version == RoomVersionId::Version6 =>
-            {
-                room_version
-            }
+            Some(room_version) if room_version == RoomVersionId::Version6 => room_version,
            _ => return Err(Error::BadServerResponse("Room version is not supported")),
        };

@@ -576,8 +503,6 @@ async fn join_room_by_id_helper(
                avatar_url: db.users.avatar_url(&sender_user)?,
                is_direct: None,
                third_party_invite: None,
-                blurhash: db.users.blurhash(&sender_user)?,
-                reason,
            })
            .expect("event is valid, we just created it"),
        );
@@ -624,12 +549,10 @@ async fn join_room_by_id_helper(
            )
            .await?;

-        db.rooms.get_or_create_shortroomid(&room_id, &db.globals)?;
-
        let pdu = PduEvent::from_id_val(&event_id, join_event.clone())
            .map_err(|_| Error::BadServerResponse("Invalid join event PDU."))?;

-        let mut state = HashMap::new();
+        let mut state = BTreeMap::new();
        let pub_key_map = RwLock::new(BTreeMap::new());

        for result in futures::future::join_all(
@@ -653,40 +576,23 @@ async fn join_room_by_id_helper(

            db.rooms.add_pdu_outlier(&event_id, &value)?;
            if let Some(state_key) = &pdu.state_key {
-                let shortstatekey =
-                    db.rooms
-                        .get_or_create_shortstatekey(&pdu.kind, state_key, &db.globals)?;
-                state.insert(shortstatekey, pdu.event_id.clone());
+                state.insert((pdu.kind.clone(), state_key.clone()), pdu.event_id.clone());
            }
        }

-        let incoming_shortstatekey = db.rooms.get_or_create_shortstatekey(
-            &pdu.kind,
-            pdu.state_key
-                .as_ref()
-                .expect("Pdu is a membership state event"),
-            &db.globals,
-        )?;
+        state.insert(
+            (
+                pdu.kind.clone(),
+                pdu.state_key.clone().expect("join event has state key"),
+            ),
+            pdu.event_id.clone(),
+        );

-        state.insert(incoming_shortstatekey, pdu.event_id.clone());
-
-        let create_shortstatekey = db
-            .rooms
-            .get_shortstatekey(&EventType::RoomCreate, "")?
-            .expect("Room exists");
-
-        if state.get(&create_shortstatekey).is_none() {
+        if state.get(&(EventType::RoomCreate, "".to_owned())).is_none() {
            return Err(Error::BadServerResponse("State contained no create event."));
        }

-        db.rooms.force_state(
-            room_id,
-            state
-                .into_iter()
-                .map(|(k, id)| db.rooms.compress_state_event(k, &id, &db.globals))
-                .collect::<Result<HashSet<_>>>()?,
-            &db,
-        )?;
+        db.rooms.force_state(room_id, state, &db)?;

        for result in futures::future::join_all(
            send_join_response
@@ -726,8 +632,6 @@ async fn join_room_by_id_helper(
            avatar_url: db.users.avatar_url(&sender_user)?,
            is_direct: None,
            third_party_invite: None,
-            blurhash: db.users.blurhash(&sender_user)?,
-            reason,
        };

        db.rooms.build_and_append_pdu(
@@ -741,13 +645,10 @@ async fn join_room_by_id_helper(
            &sender_user,
            &room_id,
            &db,
-            &state_lock,
        )?;
    }

-    drop(state_lock);
-
-    db.flush()?;
+    db.flush().await?;

    Ok(join_room_by_id::Response::new(room_id.clone()).into())
 }
@@ -816,177 +717,149 @@ async fn validate_and_add_event_id(
    Ok((event_id, value))
 }

-pub async fn invite_helper<'a>(
+pub async fn invite_helper(
    sender_user: &UserId,
    user_id: &UserId,
    room_id: &RoomId,
-    reason: Option<String>,
    db: &Database,
    is_direct: bool,
 ) -> Result<()> {
    if user_id.server_name() != db.globals.server_name() {
-        let (room_version_id, pdu_json, invite_room_state) = {
-            let mutex_state = Arc::clone(
-                db.globals
-                    .roomid_mutex_state
-                    .write()
-                    .unwrap()
-                    .entry(room_id.clone())
-                    .or_default(),
-            );
-            let state_lock = mutex_state.lock().await;
+        let prev_events = db
+            .rooms
+            .get_pdu_leaves(room_id)?
+            .into_iter()
+            .take(20)
+            .collect::<Vec<_>>();

-            let prev_events = db
-                .rooms
-                .get_pdu_leaves(room_id)?
-                .into_iter()
-                .take(20)
-                .collect::<Vec<_>>();
+        let create_event = db
+            .rooms
+            .room_state_get(room_id, &EventType::RoomCreate, "")?;

-            let create_event = db
-                .rooms
-                .room_state_get(room_id, &EventType::RoomCreate, "")?;
-
-            let create_event_content = create_event
-                .as_ref()
-                .map(|create_event| {
-                    serde_json::from_value::<Raw<CreateEventContent>>(create_event.content.clone())
-                        .expect("Raw::from_value always works.")
-                        .deserialize()
-                        .map_err(|e| {
-                            warn!("Invalid create event: {}", e);
-                            Error::bad_database("Invalid create event in db.")
-                        })
-                })
-                .transpose()?;
-
-            let create_prev_event = if prev_events.len() == 1
-                && Some(&prev_events[0]) == create_event.as_ref().map(|c| &c.event_id)
-            {
-                create_event
-            } else {
-                None
-            };
-
-            // If there was no create event yet, assume we are creating a version 6 room right now
-            let room_version_id = create_event_content
-                .map_or(RoomVersionId::Version6, |create_event| {
-                    create_event.room_version
-                });
-            let room_version =
-                RoomVersion::new(&room_version_id).expect("room version is supported");
-
-            let content = serde_json::to_value(MemberEventContent {
-                avatar_url: None,
-                displayname: None,
-                is_direct: Some(is_direct),
-                membership: MembershipState::Invite,
-                third_party_invite: None,
-                blurhash: None,
-                reason,
+        let create_event_content = create_event
+            .as_ref()
+            .map(|create_event| {
+                serde_json::from_value::<Raw<CreateEventContent>>(create_event.content.clone())
+                    .expect("Raw::from_value always works.")
+                    .deserialize()
+                    .map_err(|_| Error::bad_database("Invalid PowerLevels event in db."))
            })
-            .expect("member event is valid value");
+            .transpose()?;

-            let state_key = user_id.to_string();
-            let kind = EventType::RoomMember;
-
-            let auth_events = db.rooms.get_auth_events(
-                room_id,
-                &kind,
-                &sender_user,
-                Some(&state_key),
-                &content,
-            )?;
-
-            // Our depth is the maximum depth of prev_events + 1
-            let depth = prev_events
-                .iter()
-                .filter_map(|event_id| Some(db.rooms.get_pdu(event_id).ok()??.depth))
-                .max()
-                .unwrap_or_else(|| uint!(0))
-                + uint!(1);
-
-            let mut unsigned = BTreeMap::new();
-
-            if let Some(prev_pdu) = db.rooms.room_state_get(room_id, &kind, &state_key)? {
-                unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone());
-                unsigned.insert(
-                    "prev_sender".to_owned(),
-                    serde_json::to_value(&prev_pdu.sender).expect("UserId::to_value always works"),
-                );
-            }
-
-            let pdu = PduEvent {
-                event_id: ruma::event_id!("$thiswillbefilledinlater"),
-                room_id: room_id.clone(),
-                sender: sender_user.clone(),
-                origin_server_ts: utils::millis_since_unix_epoch()
-                    .try_into()
-                    .expect("time is valid"),
-                kind,
-                content,
-                state_key: Some(state_key),
-                prev_events,
-                depth,
-                auth_events: auth_events
-                    .iter()
-                    .map(|(_, pdu)| pdu.event_id.clone())
-                    .collect(),
-                redacts: None,
-                unsigned,
-                hashes: ruma::events::pdu::EventHash {
-                    sha256: "aaa".to_owned(),
-                },
-                signatures: BTreeMap::new(),
-            };
-
-            let auth_check = state_res::auth_check(
-                &room_version,
-                &Arc::new(pdu.clone()),
-                create_prev_event,
-                None, // TODO: third_party_invite
-                |k, s| auth_events.get(&(k.clone(), s.to_owned())).map(Arc::clone),
-            )
-            .map_err(|e| {
-                error!("{:?}", e);
-                Error::bad_database("Auth check failed.")
-            })?;
-
-            if !auth_check {
-                return Err(Error::BadRequest(
-                    ErrorKind::Forbidden,
-                    "Event is not authorized.",
-                ));
-            }
-
-            // Hash and sign
-            let mut pdu_json =
-                utils::to_canonical_object(&pdu).expect("event is valid, we just created it");
-
-            pdu_json.remove("event_id");
-
-            // Add origin because synapse likes that (and it's required in the spec)
-            pdu_json.insert(
-                "origin".to_owned(),
-                to_canonical_value(db.globals.server_name())
-                    .expect("server name is a valid CanonicalJsonValue"),
-            );
-
-            ruma::signatures::hash_and_sign_event(
-                db.globals.server_name().as_str(),
-                db.globals.keypair(),
-                &mut pdu_json,
-                &room_version_id,
-            )
-            .expect("event is valid, we just created it");
-
-            let invite_room_state = db.rooms.calculate_invite_state(&pdu)?;
-
-            drop(state_lock);
-
-            (room_version_id, pdu_json, invite_room_state)
+        let create_prev_event = if prev_events.len() == 1
+            && Some(&prev_events[0]) == create_event.as_ref().map(|c| &c.event_id)
+        {
+            create_event
+        } else {
+            None
        };

+        // If there was no create event yet, assume we are creating a version 6 room right now
+        let room_version_id = create_event_content
+            .map_or(RoomVersionId::Version6, |create_event| {
+                create_event.room_version
+            });
+        let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");
+
+        let content = serde_json::to_value(MemberEventContent {
+            avatar_url: None,
+            displayname: None,
+            is_direct: Some(is_direct),
+            membership: MembershipState::Invite,
+            third_party_invite: None,
+        })
+        .expect("member event is valid value");
+
+        let state_key = user_id.to_string();
+        let kind = EventType::RoomMember;
+
+        let auth_events =
+            db.rooms
+                .get_auth_events(room_id, &kind, &sender_user, Some(&state_key), &content)?;
+
+        // Our depth is the maximum depth of prev_events + 1
+        let depth = prev_events
+            .iter()
+            .filter_map(|event_id| Some(db.rooms.get_pdu(event_id).ok()??.depth))
+            .max()
+            .unwrap_or_else(|| uint!(0))
+            + uint!(1);
+
+        let mut unsigned = BTreeMap::new();
+
+        if let Some(prev_pdu) = db.rooms.room_state_get(room_id, &kind, &state_key)? {
+            unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone());
+            unsigned.insert(
+                "prev_sender".to_owned(),
+                serde_json::to_value(&prev_pdu.sender).expect("UserId::to_value always works"),
+            );
+        }
+
+        let pdu = PduEvent {
+            event_id: ruma::event_id!("$thiswillbefilledinlater"),
+            room_id: room_id.clone(),
+            sender: sender_user.clone(),
+            origin_server_ts: utils::millis_since_unix_epoch()
+                .try_into()
+                .expect("time is valid"),
+            kind,
+            content,
+            state_key: Some(state_key),
+            prev_events,
+            depth,
+            auth_events: auth_events
+                .iter()
+                .map(|(_, pdu)| pdu.event_id.clone())
+                .collect(),
+            redacts: None,
+            unsigned,
+            hashes: ruma::events::pdu::EventHash {
+                sha256: "aaa".to_owned(),
+            },
+            signatures: BTreeMap::new(),
+        };
+
+        let auth_check = state_res::auth_check(
+            &room_version,
+            &Arc::new(pdu.clone()),
+            create_prev_event,
+            &auth_events,
+            None, // TODO: third_party_invite
+        )
+        .map_err(|e| {
+            error!("{:?}", e);
+            Error::bad_database("Auth check failed.")
+        })?;
+
+        if !auth_check {
+            return Err(Error::BadRequest(
+                ErrorKind::Forbidden,
+                "Event is not authorized.",
+            ));
+        }
+
+        // Hash and sign
+        let mut pdu_json =
+            utils::to_canonical_object(&pdu).expect("event is valid, we just created it");
+
+        pdu_json.remove("event_id");
+
+        // Add origin because synapse likes that (and it's required in the spec)
+        pdu_json.insert(
+            "origin".to_owned(),
+            to_canonical_value(db.globals.server_name())
+                .expect("server name is a valid CanonicalJsonValue"),
+        );
+
+        ruma::signatures::hash_and_sign_event(
+            db.globals.server_name().as_str(),
+            db.globals.keypair(),
+            &mut pdu_json,
+            &room_version_id,
+        )
+        .expect("event is valid, we just created it");
+
+        let invite_room_state = db.rooms.calculate_invite_state(&pdu)?;
        let response = db
            .sending
            .send_federation_request(
@@ -995,7 +868,7 @@ pub async fn invite_helper<'a>(
                create_invite::v2::Request {
                    room_id: room_id.clone(),
                    event_id: ruma::event_id!("$receivingservershouldsetthis"),
-                    room_version: room_version_id,
+                    room_version: RoomVersionId::Version6,
                    event: PduEvent::convert_to_outgoing_federation_event(pdu_json),
                    invite_room_state,
                },
@@ -1025,6 +898,16 @@ pub async fn invite_helper<'a>(
        )
        .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Origin field is invalid."))?;

+        let mutex = Arc::clone(
+            db.globals
+                .roomid_mutex
+                .write()
+                .unwrap()
+                .entry(room_id.clone())
+                .or_default(),
+        );
+        let mutex_lock = mutex.lock().await;
+
        let pdu_id = server_server::handle_incoming_pdu(
            &origin,
            &event_id,
@@ -1045,6 +928,7 @@ pub async fn invite_helper<'a>(
            ErrorKind::InvalidParam,
            "Could not accept incoming PDU as timeline event.",
        ))?;
+        drop(mutex_lock);

        for server in db
            .rooms
@@ -1058,16 +942,6 @@ pub async fn invite_helper<'a>(
        return Ok(());
    }

-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomMember,
@@ -1077,8 +951,6 @@ pub async fn invite_helper<'a>(
                avatar_url: db.users.avatar_url(&user_id)?,
                is_direct: Some(is_direct),
                third_party_invite: None,
-                blurhash: db.users.blurhash(&user_id)?,
-                reason,
            })
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -1088,10 +960,7 @@ pub async fn invite_helper<'a>(
        &sender_user,
        room_id,
        &db,
-        &state_lock,
    )?;

-    drop(state_lock);
-
    Ok(())
 }
@@ -1,4 +1,5 @@
-use crate::{database::DatabaseGuard, pdu::PduBuilder, utils, ConduitResult, Error, Ruma};
+use super::State;
+use crate::{pdu::PduBuilder, utils, ConduitResult, Database, Error, Ruma};
 use ruma::{
    api::client::{
        error::ErrorKind,
@@ -22,22 +23,12 @@ use rocket::{get, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn send_message_event_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<send_message_event::Request<'_>>,
 ) -> ConduitResult<send_message_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
    let sender_device = body.sender_device.as_deref();

-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(body.room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
    // Check if this is a new transaction id
    if let Some(response) =
        db.transaction_ids
@@ -75,7 +66,6 @@ pub async fn send_message_event_route(
        &sender_user,
        &body.room_id,
        &db,
-        &state_lock,
    )?;

    db.transaction_ids.add_txnid(
@@ -85,9 +75,7 @@ pub async fn send_message_event_route(
        event_id.as_bytes(),
    )?;

-    drop(state_lock);
-
-    db.flush()?;
+    db.flush().await?;

    Ok(send_message_event::Response::new(event_id).into())
 }
@@ -98,7 +86,7 @@ pub async fn send_message_event_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_message_events_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_message_events::Request<'_>>,
 ) -> ConduitResult<get_message_events::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -128,7 +116,7 @@ pub async fn get_message_events_route(
        get_message_events::Direction::Forward => {
            let events_after = db
                .rooms
-                .pdus_after(&sender_user, &body.room_id, from)?
+                .pdus_after(&sender_user, &body.room_id, from)
                .take(limit)
                .filter_map(|r| r.ok()) // Filter out buggy events
                .filter_map(|(pdu_id, pdu)| {
@@ -158,7 +146,7 @@ pub async fn get_message_events_route(
        get_message_events::Direction::Backward => {
            let events_before = db
                .rooms
-                .pdus_until(&sender_user, &body.room_id, from)?
+                .pdus_until(&sender_user, &body.room_id, from)
                .take(limit)
                .filter_map(|r| r.ok()) // Filter out buggy events
                .filter_map(|(pdu_id, pdu)| {
@@ -64,7 +64,9 @@ pub use voip::*;
 use super::State;
 #[cfg(feature = "conduit_bin")]
 use {
-    crate::ConduitResult, rocket::options, ruma::api::client::r0::to_device::send_event_to_device,
+    crate::ConduitResult,
+    rocket::{options, State},
+    ruma::api::client::r0::to_device::send_event_to_device,
 };

 pub const DEVICE_ID_LENGTH: usize = 10;
@@ -75,5 +77,5 @@ pub const SESSION_ID_LENGTH: usize = 256;
 #[options("/<_..>")]
 #[tracing::instrument]
 pub async fn options_route() -> ConduitResult<send_event_to_device::Response> {
-    Ok(send_event_to_device::Response {}.into())
+    Ok(send_event_to_device::Response.into())
 }
@@ -1,6 +1,7 @@
-use crate::{database::DatabaseGuard, utils, ConduitResult, Ruma};
+use super::State;
+use crate::{utils, ConduitResult, Database, Ruma};
 use ruma::api::client::r0::presence::{get_presence, set_presence};
-use std::{convert::TryInto, time::Duration};
+use std::{convert::TryInto, sync::Arc, time::Duration};

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, put};
@@ -11,7 +12,7 @@ use rocket::{get, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_presence_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_presence::Request<'_>>,
 ) -> ConduitResult<set_presence::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -41,9 +42,9 @@ pub async fn set_presence_route(
        )?;
    }

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_presence::Response {}.into())
+    Ok(set_presence::Response.into())
 }

 #[cfg_attr(
@@ -52,7 +53,7 @@ pub async fn set_presence_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_presence_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_presence::Request<'_>>,
 ) -> ConduitResult<get_presence::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -1,21 +1,19 @@
-use crate::{database::DatabaseGuard, pdu::PduBuilder, utils, ConduitResult, Error, Ruma};
+use super::State;
+use crate::{pdu::PduBuilder, utils, ConduitResult, Database, Error, Ruma};
 use ruma::{
-    api::{
-        client::{
-            error::ErrorKind,
-            r0::profile::{
-                get_avatar_url, get_display_name, get_profile, set_avatar_url, set_display_name,
-            },
+    api::client::{
+        error::ErrorKind,
+        r0::profile::{
+            get_avatar_url, get_display_name, get_profile, set_avatar_url, set_display_name,
        },
-        federation::{self, query::get_profile_information::v1::ProfileField},
    },
    events::EventType,
    serde::Raw,
 };
-use std::{convert::TryInto, sync::Arc};

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, put};
+use std::{convert::TryInto, sync::Arc};

 #[cfg_attr(
    feature = "conduit_bin",
@@ -23,7 +21,7 @@ use rocket::{get, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_displayname_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_display_name::Request<'_>>,
 ) -> ConduitResult<set_display_name::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -32,10 +30,9 @@ pub async fn set_displayname_route(
        .set_displayname(&sender_user, body.displayname.clone())?;

    // Send a new membership event and presence update into all joined rooms
-    let all_rooms_joined = db.rooms.rooms_joined(&sender_user).collect::<Vec<_>>();
-
-    for (pdu_builder, room_id) in all_rooms_joined
-        .into_iter()
+    for (pdu_builder, room_id) in db
+        .rooms
+        .rooms_joined(&sender_user)
        .filter_map(|r| r.ok())
        .map(|room_id| {
            Ok::<_, Error>((
@@ -73,19 +70,9 @@ pub async fn set_displayname_route(
        })
        .filter_map(|r| r.ok())
    {
-        let mutex_state = Arc::clone(
-            db.globals
-                .roomid_mutex_state
-                .write()
-                .unwrap()
-                .entry(room_id.clone())
-                .or_default(),
-        );
-        let state_lock = mutex_state.lock().await;
-
-        let _ =
-            db.rooms
-                .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock);
+        let _ = db
+            .rooms
+            .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db);

        // Presence update
        db.rooms.edus.update_presence(
@@ -110,9 +97,9 @@ pub async fn set_displayname_route(
        )?;
    }

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_display_name::Response {}.into())
+    Ok(set_display_name::Response.into())
 }

 #[cfg_attr(
@@ -121,28 +108,9 @@ pub async fn set_displayname_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_displayname_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_display_name::Request<'_>>,
 ) -> ConduitResult<get_display_name::Response> {
-    if body.user_id.server_name() != db.globals.server_name() {
-        let response = db
-            .sending
-            .send_federation_request(
-                &db.globals,
-                body.user_id.server_name(),
-                federation::query::get_profile_information::v1::Request {
-                    user_id: &body.user_id,
-                    field: Some(&ProfileField::DisplayName),
-                },
-            )
-            .await?;
-
-        return Ok(get_display_name::Response {
-            displayname: response.displayname,
-        }
-        .into());
-    }
-
    Ok(get_display_name::Response {
        displayname: db.users.displayname(&body.user_id)?,
    }
@@ -155,7 +123,7 @@ pub async fn get_displayname_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_avatar_url_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_avatar_url::Request<'_>>,
 ) -> ConduitResult<set_avatar_url::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -163,13 +131,10 @@ pub async fn set_avatar_url_route(
    db.users
        .set_avatar_url(&sender_user, body.avatar_url.clone())?;

-    db.users.set_blurhash(&sender_user, body.blurhash.clone())?;
-
    // Send a new membership event and presence update into all joined rooms
-    let all_joined_rooms = db.rooms.rooms_joined(&sender_user).collect::<Vec<_>>();
-
-    for (pdu_builder, room_id) in all_joined_rooms
-        .into_iter()
+    for (pdu_builder, room_id) in db
+        .rooms
+        .rooms_joined(&sender_user)
        .filter_map(|r| r.ok())
        .map(|room_id| {
            Ok::<_, Error>((
@@ -207,19 +172,9 @@ pub async fn set_avatar_url_route(
        })
        .filter_map(|r| r.ok())
    {
-        let mutex_state = Arc::clone(
-            db.globals
-                .roomid_mutex_state
-                .write()
-                .unwrap()
-                .entry(room_id.clone())
-                .or_default(),
-        );
-        let state_lock = mutex_state.lock().await;
-
-        let _ =
-            db.rooms
-                .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock);
+        let _ = db
+            .rooms
+            .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db);

        // Presence update
        db.rooms.edus.update_presence(
@@ -244,9 +199,9 @@ pub async fn set_avatar_url_route(
        )?;
    }

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_avatar_url::Response {}.into())
+    Ok(set_avatar_url::Response.into())
 }

 #[cfg_attr(
@@ -255,32 +210,11 @@ pub async fn set_avatar_url_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_avatar_url_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_avatar_url::Request<'_>>,
 ) -> ConduitResult<get_avatar_url::Response> {
-    if body.user_id.server_name() != db.globals.server_name() {
-        let response = db
-            .sending
-            .send_federation_request(
-                &db.globals,
-                body.user_id.server_name(),
-                federation::query::get_profile_information::v1::Request {
-                    user_id: &body.user_id,
-                    field: Some(&ProfileField::AvatarUrl),
-                },
-            )
-            .await?;
-
-        return Ok(get_avatar_url::Response {
-            avatar_url: response.avatar_url,
-            blurhash: response.blurhash,
-        }
-        .into());
-    }
-
    Ok(get_avatar_url::Response {
        avatar_url: db.users.avatar_url(&body.user_id)?,
-        blurhash: db.users.blurhash(&body.user_id)?,
    }
    .into())
 }
@@ -291,30 +225,9 @@ pub async fn get_avatar_url_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_profile_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_profile::Request<'_>>,
 ) -> ConduitResult<get_profile::Response> {
-    if body.user_id.server_name() != db.globals.server_name() {
-        let response = db
-            .sending
-            .send_federation_request(
-                &db.globals,
-                body.user_id.server_name(),
-                federation::query::get_profile_information::v1::Request {
-                    user_id: &body.user_id,
-                    field: None,
-                },
-            )
-            .await?;
-
-        return Ok(get_profile::Response {
-            displayname: response.displayname,
-            avatar_url: response.avatar_url,
-            blurhash: response.blurhash,
-        }
-        .into());
-    }
-
    if !db.users.exists(&body.user_id)? {
        // Return 404 if this user doesn't exist
        return Err(Error::BadRequest(
@@ -325,7 +238,6 @@ pub async fn get_profile_route(

    Ok(get_profile::Response {
        avatar_url: db.users.avatar_url(&body.user_id)?,
-        blurhash: db.users.blurhash(&body.user_id)?,
        displayname: db.users.displayname(&body.user_id)?,
    }
    .into())
@@ -1,4 +1,7 @@
-use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
+use std::sync::Arc;
+
+use super::State;
+use crate::{ConduitResult, Database, Error, Ruma};
 use ruma::{
    api::client::{
        error::ErrorKind,
@@ -21,7 +24,7 @@ use rocket::{delete, get, post, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_pushrules_all_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_pushrules_all::Request>,
 ) -> ConduitResult<get_pushrules_all::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -46,7 +49,7 @@ pub async fn get_pushrules_all_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_pushrule_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_pushrule::Request<'_>>,
 ) -> ConduitResult<get_pushrule::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -81,7 +84,7 @@ pub async fn get_pushrule_route(
            .content
            .get(body.rule_id.as_str())
            .map(|rule| rule.clone().into()),
-        _ => None,
+        RuleKind::_Custom(_) => None,
    };

    if let Some(rule) = rule {
@@ -100,7 +103,7 @@ pub async fn get_pushrule_route(
 )]
 #[tracing::instrument(skip(db, req))]
 pub async fn set_pushrule_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    req: Ruma<set_pushrule::Request<'_>>,
 ) -> ConduitResult<set_pushrule::Response> {
    let sender_user = req.sender_user.as_ref().expect("user is authenticated");
@@ -181,7 +184,7 @@ pub async fn set_pushrule_route(
                .into(),
            );
        }
-        _ => {}
+        RuleKind::_Custom(_) => {}
    }

    db.account_data.update(
@@ -192,9 +195,9 @@ pub async fn set_pushrule_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_pushrule::Response {}.into())
+    Ok(set_pushrule::Response.into())
 }

 #[cfg_attr(
@@ -203,7 +206,7 @@ pub async fn set_pushrule_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_pushrule_actions_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_pushrule_actions::Request<'_>>,
 ) -> ConduitResult<get_pushrule_actions::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -245,10 +248,10 @@ pub async fn get_pushrule_actions_route(
            .content
            .get(body.rule_id.as_str())
            .map(|rule| rule.actions.clone()),
-        _ => None,
+        RuleKind::_Custom(_) => None,
    };

-    db.flush()?;
+    db.flush().await?;

    Ok(get_pushrule_actions::Response {
        actions: actions.unwrap_or_default(),
@@ -262,7 +265,7 @@ pub async fn get_pushrule_actions_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_pushrule_actions_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_pushrule_actions::Request<'_>>,
 ) -> ConduitResult<set_pushrule_actions::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -314,7 +317,7 @@ pub async fn set_pushrule_actions_route(
                global.content.replace(rule);
            }
        }
-        _ => {}
+        RuleKind::_Custom(_) => {}
    };

    db.account_data.update(
@@ -325,9 +328,9 @@ pub async fn set_pushrule_actions_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_pushrule_actions::Response {}.into())
+    Ok(set_pushrule_actions::Response.into())
 }

 #[cfg_attr(
@@ -336,7 +339,7 @@ pub async fn set_pushrule_actions_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_pushrule_enabled_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_pushrule_enabled::Request<'_>>,
 ) -> ConduitResult<get_pushrule_enabled::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -383,10 +386,10 @@ pub async fn get_pushrule_enabled_route(
            .iter()
            .find(|rule| rule.rule_id == body.rule_id)
            .map_or(false, |rule| rule.enabled),
-        _ => false,
+        RuleKind::_Custom(_) => false,
    };

-    db.flush()?;
+    db.flush().await?;

    Ok(get_pushrule_enabled::Response { enabled }.into())
 }
@@ -397,7 +400,7 @@ pub async fn get_pushrule_enabled_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_pushrule_enabled_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_pushrule_enabled::Request<'_>>,
 ) -> ConduitResult<set_pushrule_enabled::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -454,7 +457,7 @@ pub async fn set_pushrule_enabled_route(
                global.content.insert(rule);
            }
        }
-        _ => {}
+        RuleKind::_Custom(_) => {}
    }

    db.account_data.update(
@@ -465,9 +468,9 @@ pub async fn set_pushrule_enabled_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_pushrule_enabled::Response {}.into())
+    Ok(set_pushrule_enabled::Response.into())
 }

 #[cfg_attr(
@@ -476,7 +479,7 @@ pub async fn set_pushrule_enabled_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn delete_pushrule_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<delete_pushrule::Request<'_>>,
 ) -> ConduitResult<delete_pushrule::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -523,7 +526,7 @@ pub async fn delete_pushrule_route(
                global.content.remove(&rule);
            }
        }
-        _ => {}
+        RuleKind::_Custom(_) => {}
    }

    db.account_data.update(
@@ -534,9 +537,9 @@ pub async fn delete_pushrule_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(delete_pushrule::Response {}.into())
+    Ok(delete_pushrule::Response.into())
 }

 #[cfg_attr(
@@ -545,7 +548,7 @@ pub async fn delete_pushrule_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_pushers_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_pushers::Request>,
 ) -> ConduitResult<get_pushers::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -562,7 +565,7 @@ pub async fn get_pushers_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_pushers_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_pusher::Request>,
 ) -> ConduitResult<set_pusher::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -570,7 +573,7 @@ pub async fn set_pushers_route(

    db.pusher.set_pusher(sender_user, pusher)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(set_pusher::Response::default().into())
 }
@@ -1,4 +1,5 @@
-use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
+use super::State;
+use crate::{ConduitResult, Database, Error, Ruma};
 use ruma::{
    api::client::{
        error::ErrorKind,
@@ -8,10 +9,10 @@ use ruma::{
    receipt::ReceiptType,
    MilliSecondsSinceUnixEpoch,
 };
-use std::collections::BTreeMap;

 #[cfg(feature = "conduit_bin")]
 use rocket::post;
+use std::{collections::BTreeMap, sync::Arc};

 #[cfg_attr(
    feature = "conduit_bin",
@@ -19,7 +20,7 @@ use rocket::post;
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_read_marker_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<set_read_marker::Request<'_>>,
 ) -> ConduitResult<set_read_marker::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -75,9 +76,9 @@ pub async fn set_read_marker_route(
        )?;
    }

-    db.flush()?;
+    db.flush().await?;

-    Ok(set_read_marker::Response {}.into())
+    Ok(set_read_marker::Response.into())
 }

 #[cfg_attr(
@@ -86,7 +87,7 @@ pub async fn set_read_marker_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn create_receipt_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<create_receipt::Request<'_>>,
 ) -> ConduitResult<create_receipt::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -128,7 +129,7 @@ pub async fn create_receipt_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(create_receipt::Response {}.into())
+    Ok(create_receipt::Response.into())
 }
@@ -1,10 +1,10 @@
-use std::sync::Arc;
-
-use crate::{database::DatabaseGuard, pdu::PduBuilder, ConduitResult, Ruma};
+use super::State;
+use crate::{pdu::PduBuilder, ConduitResult, Database, Ruma};
 use ruma::{
    api::client::r0::redact::redact_event,
    events::{room::redaction, EventType},
 };
+use std::sync::Arc;

 #[cfg(feature = "conduit_bin")]
 use rocket::put;
@@ -15,21 +15,11 @@ use rocket::put;
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn redact_event_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<redact_event::Request<'_>>,
 ) -> ConduitResult<redact_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(body.room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
    let event_id = db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomRedaction,
@@ -44,12 +34,9 @@ pub async fn redact_event_route(
        &sender_user,
        &body.room_id,
        &db,
-        &state_lock,
    )?;

-    drop(state_lock);
-
-    db.flush()?;
+    db.flush().await?;

    Ok(redact_event::Response { event_id }.into())
 }
@@ -1,11 +1,10 @@
-use crate::{
-    client_server::invite_helper, database::DatabaseGuard, pdu::PduBuilder, ConduitResult, Error,
-    Ruma,
-};
+use super::State;
+use crate::{client_server::invite_helper, pdu::PduBuilder, ConduitResult, Database, Error, Ruma};
+use log::info;
 use ruma::{
    api::client::{
        error::ErrorKind,
-        r0::room::{self, aliases, create_room, get_room_event, upgrade_room},
+        r0::room::{self, create_room, get_room_event, upgrade_room},
    },
    events::{
        room::{guest_access, history_visibility, join_rules, member, name, topic},
@@ -15,7 +14,6 @@ use ruma::{
    RoomAliasId, RoomId, RoomVersionId,
 };
 use std::{cmp::max, collections::BTreeMap, convert::TryFrom, sync::Arc};
-use tracing::{info, warn};

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post};
@@ -26,60 +24,36 @@ use rocket::{get, post};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn create_room_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<create_room::Request<'_>>,
 ) -> ConduitResult<create_room::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

    let room_id = RoomId::new(db.globals.server_name());

-    db.rooms.get_or_create_shortroomid(&room_id, &db.globals)?;
+    let alias = body
+        .room_alias_name
+        .as_ref()
+        .map_or(Ok(None), |localpart| {
+            // TODO: Check for invalid characters and maximum length
+            let alias =
+                RoomAliasId::try_from(format!("#{}:{}", localpart, db.globals.server_name()))
+                    .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;

-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
-    let alias: Option<RoomAliasId> =
-        body.room_alias_name
-            .as_ref()
-            .map_or(Ok(None), |localpart| {
-                // TODO: Check for invalid characters and maximum length
-                let alias =
-                    RoomAliasId::try_from(format!("#{}:{}", localpart, db.globals.server_name()))
-                        .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;
-
-                if db.rooms.id_from_alias(&alias)?.is_some() {
-                    Err(Error::BadRequest(
-                        ErrorKind::RoomInUse,
-                        "Room alias already exists.",
-                    ))
-                } else {
-                    Ok(Some(alias))
-                }
-            })?;
+            if db.rooms.id_from_alias(&alias)?.is_some() {
+                Err(Error::BadRequest(
+                    ErrorKind::RoomInUse,
+                    "Room alias already exists.",
+                ))
+            } else {
+                Ok(Some(alias))
+            }
+        })?;

    let mut content = ruma::events::room::create::CreateEventContent::new(sender_user.clone());
    content.federate = body.creation_content.federate;
    content.predecessor = body.creation_content.predecessor.clone();
-    content.room_version = match body.room_version.clone() {
-        Some(room_version) => {
-            if room_version == RoomVersionId::Version5 || room_version == RoomVersionId::Version6 {
-                room_version
-            } else {
-                return Err(Error::BadRequest(
-                    ErrorKind::UnsupportedRoomVersion,
-                    "This server does not support that room version.",
-                ));
-            }
-        }
-        None => RoomVersionId::Version6,
-    };
+    content.room_version = RoomVersionId::Version6;

    // 1. The room create event
    db.rooms.build_and_append_pdu(
@@ -93,7 +67,6 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
    )?;

    // 2. Let the room creator join
@@ -106,8 +79,6 @@ pub async fn create_room_route(
                avatar_url: db.users.avatar_url(&sender_user)?,
                is_direct: Some(body.is_direct),
                third_party_invite: None,
-                blurhash: db.users.blurhash(&sender_user)?,
-                reason: None,
            })
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -117,7 +88,6 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
    )?;

    // 3. Power levels
@@ -129,7 +99,7 @@ pub async fn create_room_route(
        .unwrap_or_else(|| match &body.visibility {
            room::Visibility::Private => create_room::RoomPreset::PrivateChat,
            room::Visibility::Public => create_room::RoomPreset::PublicChat,
-            _ => create_room::RoomPreset::PrivateChat, // Room visibility should not be custom
+            room::Visibility::_Custom(_) => create_room::RoomPreset::PrivateChat, // Room visibility should not be custom
        });

    let mut users = BTreeMap::new();
@@ -172,35 +142,11 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
    )?;

-    // 4. Canonical room alias
-    if let Some(room_alias_id) = &alias {
-        db.rooms.build_and_append_pdu(
-            PduBuilder {
-                event_type: EventType::RoomCanonicalAlias,
-                content: serde_json::to_value(
-                    ruma::events::room::canonical_alias::CanonicalAliasEventContent {
-                        alias: Some(room_alias_id.clone()),
-                        alt_aliases: vec![],
-                    },
-                )
-                .expect("We checked that alias earlier, it must be fine"),
-                unsigned: None,
-                state_key: Some("".to_owned()),
-                redacts: None,
-            },
-            &sender_user,
-            &room_id,
-            &db,
-            &state_lock,
-        )?;
-    }
+    // 4. Events set by preset

-    // 5. Events set by preset
-
-    // 5.1 Join Rules
+    // 4.1 Join Rules
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomJoinRules,
@@ -222,10 +168,9 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
    )?;

-    // 5.2 History Visibility
+    // 4.2 History Visibility
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomHistoryVisibility,
@@ -240,10 +185,9 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
    )?;

-    // 5.3 Guest Access
+    // 4.3 Guest Access
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomGuestAccess,
@@ -266,15 +210,14 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
    )?;

-    // 6. Events listed in initial_state
+    // 5. Events listed in initial_state
    for event in &body.initial_state {
-        let pdu_builder = PduBuilder::from(event.deserialize().map_err(|e| {
-            warn!("Invalid initial state event: {:?}", e);
-            Error::BadRequest(ErrorKind::InvalidParam, "Invalid initial state event.")
-        })?);
+        let pdu_builder = serde_json::from_str::<PduBuilder>(
+            &serde_json::to_string(&event).expect("AnyInitialStateEvent::to_string always works"),
+        )
+        .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid initial state event."))?;

        // Silently skip encryption events if they are not allowed
        if pdu_builder.event_type == EventType::RoomEncryption && !db.globals.allow_encryption() {
@@ -282,16 +225,20 @@ pub async fn create_room_route(
        }

        db.rooms
-            .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock)?;
+            .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db)?;
    }

-    // 7. Events implied by name and topic
+    // 6. Events implied by name and topic
    if let Some(name) = &body.name {
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomName,
-                content: serde_json::to_value(name::NameEventContent::new(Some(name.clone())))
-                    .expect("event is valid, we just created it"),
+                content: serde_json::to_value(
+                    name::NameEventContent::new(name.clone()).map_err(|_| {
+                        Error::BadRequest(ErrorKind::InvalidParam, "Name is invalid.")
+                    })?,
+                )
+                .expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
                redacts: None,
@@ -299,7 +246,6 @@ pub async fn create_room_route(
            &sender_user,
            &room_id,
            &db,
-            &state_lock,
        )?;
    }

@@ -318,12 +264,10 @@ pub async fn create_room_route(
            &sender_user,
            &room_id,
            &db,
-            &state_lock,
        )?;
    }

-    // 8. Events implied by invite (and TODO: invite_3pid)
-    drop(state_lock);
+    // 7. Events implied by invite (and TODO: invite_3pid)
    for user_id in &body.invite {
        let _ = invite_helper(sender_user, user_id, &room_id, &db, body.is_direct).await;
    }
@@ -339,7 +283,7 @@ pub async fn create_room_route(

    info!("{} created a room", sender_user);

-    db.flush()?;
+    db.flush().await?;

    Ok(create_room::Response::new(room_id).into())
 }
@@ -350,7 +294,7 @@ pub async fn create_room_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_room_event_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_room_event::Request<'_>>,
 ) -> ConduitResult<get_room_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -374,47 +318,17 @@ pub async fn get_room_event_route(

 #[cfg_attr(
    feature = "conduit_bin",
-    get("/_matrix/client/r0/rooms/<_>/aliases", data = "<body>")
-)]
-#[tracing::instrument(skip(db, body))]
-pub async fn get_room_aliases_route(
-    db: DatabaseGuard,
-    body: Ruma<aliases::Request<'_>>,
-) -> ConduitResult<aliases::Response> {
-    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-
-    if !db.rooms.is_joined(sender_user, &body.room_id)? {
-        return Err(Error::BadRequest(
-            ErrorKind::Forbidden,
-            "You don't have permission to view this room.",
-        ));
-    }
-
-    Ok(aliases::Response {
-        aliases: db
-            .rooms
-            .room_aliases(&body.room_id)
-            .filter_map(|a| a.ok())
-            .collect(),
-    }
-    .into())
-}
-
-#[cfg_attr(
-    feature = "conduit_bin",
-    post("/_matrix/client/r0/rooms/<_>/upgrade", data = "<body>")
+    post("/_matrix/client/r0/rooms/<_room_id>/upgrade", data = "<body>")
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn upgrade_room_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<upgrade_room::Request<'_>>,
+    _room_id: String,
 ) -> ConduitResult<upgrade_room::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    if !matches!(
-        body.new_version,
-        RoomVersionId::Version5 | RoomVersionId::Version6
-    ) {
+    if !matches!(body.new_version, RoomVersionId::Version6) {
        return Err(Error::BadRequest(
            ErrorKind::UnsupportedRoomVersion,
            "This server does not support that room version.",
@@ -423,18 +337,6 @@ pub async fn upgrade_room_route(

    // Create a replacement room
    let replacement_room = RoomId::new(db.globals.server_name());
-    db.rooms
-        .get_or_create_shortroomid(&replacement_room, &db.globals)?;
-
-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(body.room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;

    // Send a m.room.tombstone event to the old room to indicate that it is not intended to be used any further
    // Fail if the sender does not have the required permissions
@@ -453,21 +355,8 @@ pub async fn upgrade_room_route(
        sender_user,
        &body.room_id,
        &db,
-        &state_lock,
    )?;

-    // Change lock to replacement room
-    drop(state_lock);
-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(replacement_room.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
    // Get the old room federations status
    let federate = serde_json::from_value::<Raw<ruma::events::room::create::CreateEventContent>>(
        db.rooms
@@ -506,7 +395,6 @@ pub async fn upgrade_room_route(
        sender_user,
        &replacement_room,
        &db,
-        &state_lock,
    )?;

    // Join the new room
@@ -519,8 +407,6 @@ pub async fn upgrade_room_route(
                avatar_url: db.users.avatar_url(&sender_user)?,
                is_direct: None,
                third_party_invite: None,
-                blurhash: db.users.blurhash(&sender_user)?,
-                reason: None,
            })
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -530,7 +416,6 @@ pub async fn upgrade_room_route(
        sender_user,
        &replacement_room,
        &db,
-        &state_lock,
    )?;

    // Recommended transferable state events list from the specs
@@ -564,7 +449,6 @@ pub async fn upgrade_room_route(
            sender_user,
            &replacement_room,
            &db,
-            &state_lock,
        )?;
    }

@@ -608,12 +492,9 @@ pub async fn upgrade_room_route(
        sender_user,
        &body.room_id,
        &db,
-        &state_lock,
    )?;

-    drop(state_lock);
-
-    db.flush()?;
+    db.flush().await?;

    // Return the replacement room id
    Ok(upgrade_room::Response { replacement_room }.into())
@@ -1,5 +1,7 @@
-use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
+use super::State;
+use crate::{ConduitResult, Database, Error, Ruma};
 use ruma::api::client::{error::ErrorKind, r0::search::search_events};
+use std::sync::Arc;

 #[cfg(feature = "conduit_bin")]
 use rocket::post;
@@ -12,7 +14,7 @@ use std::collections::BTreeMap;
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn search_events_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<search_events::Request<'_>>,
 ) -> ConduitResult<search_events::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -1,17 +1,16 @@
-use super::{DEVICE_ID_LENGTH, TOKEN_LENGTH};
-use crate::{database::DatabaseGuard, utils, ConduitResult, Error, Ruma};
+use std::sync::Arc;
+
+use super::{State, DEVICE_ID_LENGTH, TOKEN_LENGTH};
+use crate::{utils, ConduitResult, Database, Error, Ruma};
+use log::info;
 use ruma::{
    api::client::{
        error::ErrorKind,
-        r0::{
-            session::{get_login_types, login, logout, logout_all},
-            uiaa::IncomingUserIdentifier,
-        },
+        r0::session::{get_login_types, login, logout, logout_all},
    },
    UserId,
 };
 use serde::Deserialize;
-use tracing::info;

 #[derive(Debug, Deserialize)]
 struct Claims {
@@ -53,7 +52,7 @@ pub async fn get_login_types_route() -> ConduitResult<get_login_types::Response>
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn login_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<login::Request<'_>>,
 ) -> ConduitResult<login::Response> {
    // Validate login method
@@ -63,7 +62,7 @@ pub async fn login_route(
            identifier,
            password,
        } => {
-            let username = if let IncomingUserIdentifier::MatrixId(matrix_id) = identifier {
+            let username = if let login::IncomingUserIdentifier::MatrixId(matrix_id) = identifier {
                matrix_id
            } else {
                return Err(Error::BadRequest(ErrorKind::Forbidden, "Bad login type."));
@@ -146,7 +145,7 @@ pub async fn login_route(

    info!("{} logged in", user_id);

-    db.flush()?;
+    db.flush().await?;

    Ok(login::Response {
        user_id,
@@ -170,7 +169,7 @@ pub async fn login_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn logout_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<logout::Request>,
 ) -> ConduitResult<logout::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -178,7 +177,7 @@ pub async fn logout_route(

    db.users.remove_device(&sender_user, sender_device)?;

-    db.flush()?;
+    db.flush().await?;

    Ok(logout::Response::new().into())
 }
@@ -198,7 +197,7 @@ pub async fn logout_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn logout_all_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<logout_all::Request>,
 ) -> ConduitResult<logout_all::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -207,7 +206,7 @@ pub async fn logout_all_route(
        db.users.remove_device(&sender_user, &device_id)?;
    }

-    db.flush()?;
+    db.flush().await?;

    Ok(logout_all::Response::new().into())
 }
@@ -1,8 +1,7 @@
 use std::sync::Arc;

-use crate::{
-    database::DatabaseGuard, pdu::PduBuilder, ConduitResult, Database, Error, Result, Ruma,
-};
+use super::State;
+use crate::{pdu::PduBuilder, ConduitResult, Database, Error, Result, Ruma};
 use ruma::{
    api::client::{
        error::ErrorKind,
@@ -28,7 +27,7 @@ use rocket::{get, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn send_state_event_for_key_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<send_state_event::Request<'_>>,
 ) -> ConduitResult<send_state_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -43,7 +42,7 @@ pub async fn send_state_event_for_key_route(
    )
    .await?;

-    db.flush()?;
+    db.flush().await?;

    Ok(send_state_event::Response { event_id }.into())
 }
@@ -54,7 +53,7 @@ pub async fn send_state_event_for_key_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn send_state_event_for_empty_key_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<send_state_event::Request<'_>>,
 ) -> ConduitResult<send_state_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -69,7 +68,7 @@ pub async fn send_state_event_for_empty_key_route(
    )
    .await?;

-    db.flush()?;
+    db.flush().await?;

    Ok(send_state_event::Response { event_id }.into())
 }
@@ -80,7 +79,7 @@ pub async fn send_state_event_for_empty_key_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_state_events_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_state_events::Request<'_>>,
 ) -> ConduitResult<get_state_events::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -127,7 +126,7 @@ pub async fn get_state_events_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_state_events_for_key_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_state_events_for_key::Request<'_>>,
 ) -> ConduitResult<get_state_events_for_key::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -178,7 +177,7 @@ pub async fn get_state_events_for_key_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_state_events_for_empty_key_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_state_events_for_key::Request<'_>>,
 ) -> ConduitResult<get_state_events_for_key::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -259,16 +258,6 @@ pub async fn send_state_event_for_key_helper(
        }
    }

-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
    let event_id = db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type,
@@ -280,7 +269,6 @@ pub async fn send_state_event_for_key_helper(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
    )?;

    Ok(event_id)
@@ -1,4 +1,6 @@
-use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Result, Ruma, RumaResponse};
+use super::State;
+use crate::{ConduitResult, Database, Error, Result, Ruma, RumaResponse};
+use log::error;
 use ruma::{
    api::client::r0::{sync::sync_events, uiaa::UiaaResponse},
    events::{room::member::MembershipState, AnySyncEphemeralRoomEvent, EventType},
@@ -6,13 +8,12 @@ use ruma::{
    DeviceId, RoomId, UserId,
 };
 use std::{
-    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
+    collections::{btree_map::Entry, hash_map, BTreeMap, HashMap, HashSet},
    convert::{TryFrom, TryInto},
    sync::Arc,
    time::Duration,
 };
 use tokio::sync::watch::Sender;
-use tracing::error;

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, tokio};
@@ -34,15 +35,13 @@ use rocket::{get, tokio};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn sync_events_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<sync_events::Request<'_>>,
 ) -> std::result::Result<RumaResponse<sync_events::Response>, RumaResponse<UiaaResponse>> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
    let sender_device = body.sender_device.as_ref().expect("user is authenticated");

-    let arc_db = Arc::new(db);
-
-    let mut rx = match arc_db
+    let mut rx = match db
        .globals
        .sync_receivers
        .write()
@@ -53,7 +52,7 @@ pub async fn sync_events_route(
            let (tx, rx) = tokio::sync::watch::channel(None);

            tokio::spawn(sync_helper_wrapper(
-                Arc::clone(&arc_db),
+                Arc::clone(&db),
                sender_user.clone(),
                sender_device.clone(),
                body.since.clone(),
@@ -69,7 +68,7 @@ pub async fn sync_events_route(
                let (tx, rx) = tokio::sync::watch::channel(None);

                tokio::spawn(sync_helper_wrapper(
-                    Arc::clone(&arc_db),
+                    Arc::clone(&db),
                    sender_user.clone(),
                    sender_device.clone(),
                    body.since.clone(),
@@ -107,7 +106,7 @@ pub async fn sync_events_route(
 }

 pub async fn sync_helper_wrapper(
-    db: Arc<DatabaseGuard>,
+    db: Arc<Database>,
    sender_user: UserId,
    sender_device: Box<DeviceId>,
    since: Option<String>,
@@ -145,13 +144,11 @@ pub async fn sync_helper_wrapper(
        }
    }

-    drop(db);
-
    let _ = tx.send(Some(r.map(|(r, _)| r.into())));
 }

 async fn sync_helper(
-    db: Arc<DatabaseGuard>,
+    db: Arc<Database>,
    sender_user: UserId,
    sender_device: Box<DeviceId>,
    since: Option<String>,
@@ -186,26 +183,12 @@ async fn sync_helper(
            .filter_map(|r| r.ok()),
    );

-    let all_joined_rooms = db.rooms.rooms_joined(&sender_user).collect::<Vec<_>>();
-    for room_id in all_joined_rooms {
+    for room_id in db.rooms.rooms_joined(&sender_user) {
        let room_id = room_id?;

-        // Get and drop the lock to wait for remaining operations to finish
-        // This will make sure the we have all events until next_batch
-        let mutex_insert = Arc::clone(
-            db.globals
-                .roomid_mutex_insert
-                .write()
-                .unwrap()
-                .entry(room_id.clone())
-                .or_default(),
-        );
-        let insert_lock = mutex_insert.lock().unwrap();
-        drop(insert_lock);
-
        let mut non_timeline_pdus = db
            .rooms
-            .pdus_until(&sender_user, &room_id, u64::MAX)?
+            .pdus_until(&sender_user, &room_id, u64::MAX)
            .filter_map(|r| {
                // Filter out buggy events
                if r.is_err() {
@@ -246,13 +229,27 @@ async fn sync_helper(
            .current_shortstatehash(&room_id)?
            .expect("All rooms have state");

+        let first_pdu_before_since = db
+            .rooms
+            .pdus_until(&sender_user, &room_id, since)
+            .next()
+            .transpose()?;
+
        let pdus_after_since = db
            .rooms
-            .pdus_after(&sender_user, &room_id, since)?
+            .pdus_after(&sender_user, &room_id, since)
            .next()
            .is_some();

-        let since_shortstatehash = db.rooms.get_token_shortstatehash(&room_id, since)?;
+        let since_shortstatehash = first_pdu_before_since
+            .as_ref()
+            .map(|pdu| {
+                db.rooms
+                    .pdu_shortstatehash(&pdu.1.event_id)
+                    .transpose()
+                    .expect("all pdus have state")
+            })
+            .transpose()?;

        // Calculates joined_member_count, invited_member_count and heroes
        let calculate_counts = || {
@@ -268,7 +265,7 @@ async fn sync_helper(

                for hero in db
                    .rooms
-                    .all_pdus(&sender_user, &room_id)?
+                    .all_pdus(&sender_user, &room_id)
                    .filter_map(|pdu| pdu.ok()) // Ignore all broken pdus
                    .filter(|(_, pdu)| pdu.kind == EventType::RoomMember)
                    .map(|(_, pdu)| {
@@ -310,11 +307,11 @@ async fn sync_helper(
                }
            }

-            Ok::<_, Error>((
+            (
                Some(joined_member_count),
                Some(invited_member_count),
                heroes,
-            ))
+            )
        };

        let (
@@ -325,12 +322,12 @@ async fn sync_helper(
            state_events,
        ) = if since_shortstatehash.is_none() {
            // Probably since = 0, we will do an initial sync
-            let (joined_member_count, invited_member_count, heroes) = calculate_counts()?;
+            let (joined_member_count, invited_member_count, heroes) = calculate_counts();

            let current_state_ids = db.rooms.state_full_ids(current_shortstatehash)?;
            let state_events = current_state_ids
                .iter()
-                .map(|(_, id)| db.rooms.get_pdu(id))
+                .map(|id| db.rooms.get_pdu(id))
                .filter_map(|r| r.ok().flatten())
                .collect::<Vec<_>>();

@@ -339,9 +336,9 @@ async fn sync_helper(
                joined_member_count,
                invited_member_count,
                true,
-                state_events,
+                state_events
            )
-        } else if !pdus_after_since && since_shortstatehash == Some(current_shortstatehash) {
+        } else if !pdus_after_since || since_shortstatehash == Some(current_shortstatehash) {
            // No state changes
            (Vec::new(), None, None, false, Vec::new())
        } else {
@@ -375,14 +372,18 @@ async fn sync_helper(
            let state_events = if joined_since_last_sync {
                current_state_ids
                    .iter()
-                    .map(|(_, id)| db.rooms.get_pdu(id))
+                    .map(|id| db.rooms.get_pdu(id))
                    .filter_map(|r| r.ok().flatten())
                    .collect::<Vec<_>>()
            } else {
                current_state_ids
-                    .iter()
-                    .filter(|(key, id)| since_state_ids.get(key) != Some(id))
-                    .map(|(_, id)| db.rooms.get_pdu(id))
+                    .difference(&since_state_ids)
+                    .filter(|id| {
+                        !timeline_pdus
+                            .iter()
+                            .any(|(_, timeline_pdu)| timeline_pdu.event_id == **id)
+                    })
+                    .map(|id| db.rooms.get_pdu(id))
                    .filter_map(|r| r.ok().flatten())
                    .collect()
            };
@@ -401,10 +402,7 @@ async fn sync_helper(

            let send_member_count = state_events
                .iter()
-                .any(|event| event.kind == EventType::RoomMember)
-                || timeline_pdus.iter().any(|(_, event)| {
-                    event.state_key.is_some() && event.kind == EventType::RoomMember
-                });
+                .any(|event| event.kind == EventType::RoomMember);

            if encrypted_room {
                for (user_id, current_member) in db
@@ -488,7 +486,7 @@ async fn sync_helper(
            }

            let (joined_member_count, invited_member_count, heroes) = if send_member_count {
-                calculate_counts()?
+                calculate_counts()
            } else {
                (None, None, Vec::new())
            };
@@ -562,10 +560,6 @@ async fn sync_helper(
            );
        }

-        // Save the state after this sync so we can send the correct state diff next sync
-        db.rooms
-            .associate_token_shortstatehash(&room_id, next_batch, current_shortstatehash)?;
-
        let joined_room = sync_events::JoinedRoom {
            account_data: sync_events::RoomAccountData {
                events: db
@@ -613,10 +607,10 @@ async fn sync_helper(
                .presence_since(&room_id, since, &db.rooms, &db.globals)?
        {
            match presence_updates.entry(user_id) {
-                Entry::Vacant(v) => {
+                hash_map::Entry::Vacant(v) => {
                    v.insert(presence);
                }
-                Entry::Occupied(mut o) => {
+                hash_map::Entry::Occupied(mut o) => {
                    let p = o.get_mut();

                    // Update existing presence event with more info
@@ -642,22 +636,8 @@ async fn sync_helper(
    }

    let mut left_rooms = BTreeMap::new();
-    let all_left_rooms = db.rooms.rooms_left(&sender_user).collect::<Vec<_>>();
-    for result in all_left_rooms {
+    for result in db.rooms.rooms_left(&sender_user) {
        let (room_id, left_state_events) = result?;
-
-        // Get and drop the lock to wait for remaining operations to finish
-        let mutex_insert = Arc::clone(
-            db.globals
-                .roomid_mutex_insert
-                .write()
-                .unwrap()
-                .entry(room_id.clone())
-                .or_default(),
-        );
-        let insert_lock = mutex_insert.lock().unwrap();
-        drop(insert_lock);
-
        let left_count = db.rooms.get_left_count(&room_id, &sender_user)?;

        // Left before last sync
@@ -682,22 +662,8 @@ async fn sync_helper(
    }

    let mut invited_rooms = BTreeMap::new();
-    let all_invited_rooms = db.rooms.rooms_invited(&sender_user).collect::<Vec<_>>();
-    for result in all_invited_rooms {
+    for result in db.rooms.rooms_invited(&sender_user) {
        let (room_id, invite_state_events) = result?;
-
-        // Get and drop the lock to wait for remaining operations to finish
-        let mutex_insert = Arc::clone(
-            db.globals
-                .roomid_mutex_insert
-                .write()
-                .unwrap()
-                .entry(room_id.clone())
-                .or_default(),
-        );
-        let insert_lock = mutex_insert.lock().unwrap();
-        drop(insert_lock);
-
        let invite_count = db.rooms.get_invite_count(&room_id, &sender_user)?;

        // Invited before last sync
@@ -746,7 +712,6 @@ async fn sync_helper(
            leave: left_rooms,
            join: joined_rooms,
            invite: invited_rooms,
-            knock: BTreeMap::new(), // TODO
        },
        presence: sync_events::Presence {
            events: presence_updates
@@ -1,9 +1,10 @@
-use crate::{database::DatabaseGuard, ConduitResult, Ruma};
+use super::State;
+use crate::{ConduitResult, Database, Ruma};
 use ruma::{
    api::client::r0::tag::{create_tag, delete_tag, get_tags},
    events::EventType,
 };
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, sync::Arc};

 #[cfg(feature = "conduit_bin")]
 use rocket::{delete, get, put};
@@ -14,7 +15,7 @@ use rocket::{delete, get, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn update_tag_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<create_tag::Request<'_>>,
 ) -> ConduitResult<create_tag::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -40,9 +41,9 @@ pub async fn update_tag_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(create_tag::Response {}.into())
+    Ok(create_tag::Response.into())
 }

 #[cfg_attr(
@@ -51,7 +52,7 @@ pub async fn update_tag_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn delete_tag_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<delete_tag::Request<'_>>,
 ) -> ConduitResult<delete_tag::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -74,9 +75,9 @@ pub async fn delete_tag_route(
        &db.globals,
    )?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(delete_tag::Response {}.into())
+    Ok(delete_tag::Response.into())
 }

 #[cfg_attr(
@@ -85,7 +86,7 @@ pub async fn delete_tag_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_tags_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<get_tags::Request<'_>>,
 ) -> ConduitResult<get_tags::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -1,12 +1,9 @@
-use std::collections::BTreeMap;
+use std::sync::Arc;

-use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
+use super::State;
+use crate::{ConduitResult, Database, Error, Ruma};
 use ruma::{
-    api::{
-        client::{error::ErrorKind, r0::to_device::send_event_to_device},
-        federation::{self, transactions::edu::DirectDeviceContent},
-    },
-    events::EventType,
+    api::client::{error::ErrorKind, r0::to_device::send_event_to_device},
    to_device::DeviceIdOrAllDevices,
 };

@@ -19,7 +16,7 @@ use rocket::put;
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn send_event_to_device_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<send_event_to_device::Request<'_>>,
 ) -> ConduitResult<send_event_to_device::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -39,29 +36,6 @@ pub async fn send_event_to_device_route(

    for (target_user_id, map) in &body.messages {
        for (target_device_id_maybe, event) in map {
-            if target_user_id.server_name() != db.globals.server_name() {
-                let mut map = BTreeMap::new();
-                map.insert(target_device_id_maybe.clone(), event.clone());
-                let mut messages = BTreeMap::new();
-                messages.insert(target_user_id.clone(), map);
-
-                db.sending.send_reliable_edu(
-                    target_user_id.server_name(),
-                    serde_json::to_vec(&federation::transactions::edu::Edu::DirectToDevice(
-                        DirectDeviceContent {
-                            sender: sender_user.clone(),
-                            ev_type: EventType::from(&body.event_type),
-                            message_id: body.txn_id.clone(),
-                            messages,
-                        },
-                    ))
-                    .expect("DirectToDevice EDU can be serialized"),
-                    db.globals.next_count()?,
-                )?;
-
-                continue;
-            }
-
            match target_device_id_maybe {
                DeviceIdOrAllDevices::DeviceId(target_device_id) => db.users.add_to_device_event(
                    sender_user,
@@ -96,7 +70,7 @@ pub async fn send_event_to_device_route(
    db.transaction_ids
        .add_txnid(sender_user, sender_device, &body.txn_id, &[])?;

-    db.flush()?;
+    db.flush().await?;

-    Ok(send_event_to_device::Response {}.into())
+    Ok(send_event_to_device::Response.into())
 }
@@ -1,4 +1,7 @@
-use crate::{database::DatabaseGuard, utils, ConduitResult, Ruma};
+use std::sync::Arc;
+
+use super::State;
+use crate::{utils, ConduitResult, Database, Ruma};
 use create_typing_event::Typing;
 use ruma::api::client::r0::typing::create_typing_event;

@@ -11,7 +14,7 @@ use rocket::put;
 )]
 #[tracing::instrument(skip(db, body))]
 pub fn create_typing_event_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<create_typing_event::Request<'_>>,
 ) -> ConduitResult<create_typing_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -29,5 +32,5 @@ pub fn create_typing_event_route(
            .typing_remove(&sender_user, &body.room_id, &db.globals)?;
    }

-    Ok(create_typing_event::Response {}.into())
+    Ok(create_typing_event::Response.into())
 }
@@ -1,4 +1,7 @@
-use crate::{database::DatabaseGuard, ConduitResult, Ruma};
+use std::sync::Arc;
+
+use super::State;
+use crate::{ConduitResult, Database, Ruma};
 use ruma::api::client::r0::user_directory::search_users;

 #[cfg(feature = "conduit_bin")]
@@ -10,7 +13,7 @@ use rocket::post;
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn search_users_route(
-    db: DatabaseGuard,
+    db: State<'_, Arc<Database>>,
    body: Ruma<search_users::Request<'_>>,
 ) -> ConduitResult<search_users::Response> {
    let limit = u64::from(body.limit) as usize;
@@ -25,22 +28,20 @@ pub async fn search_users_route(
            avatar_url: db.users.avatar_url(&user_id).ok()?,
        };

-        let user_id_matches = user
+        if !user
            .user_id
            .to_string()
            .to_lowercase()
-            .contains(&body.search_term.to_lowercase());
-
-        let user_displayname_matches = user
-            .display_name
-            .as_ref()
-            .filter(|name| {
-                name.to_lowercase()
-                    .contains(&body.search_term.to_lowercase())
-            })
-            .is_some();
-
-        if !user_id_matches && !user_displayname_matches {
+            .contains(&body.search_term.to_lowercase())
+            && user
+                .display_name
+                .as_ref()
+                .filter(|name| {
+                    name.to_lowercase()
+                        .contains(&body.search_term.to_lowercase())
+                })
+                .is_none()
+        {
            return None;
        }

@@ -6,7 +6,6 @@ pub mod appservice;
 pub mod globals;
 pub mod key_backups;
 pub mod media;
-pub mod proxy;
 pub mod pusher;
 pub mod rooms;
 pub mod sending;
@@ -17,38 +16,25 @@ pub mod users;
 use crate::{utils, Error, Result};
 use abstraction::DatabaseEngine;
 use directories::ProjectDirs;
+use log::error;
 use lru_cache::LruCache;
-use rocket::{
-    futures::{channel::mpsc, stream::FuturesUnordered, StreamExt},
-    outcome::{try_outcome, IntoOutcome},
-    request::{FromRequest, Request},
-    Shutdown, State,
-};
-use ruma::{DeviceId, EventId, RoomId, ServerName, UserId};
-use serde::{de::IgnoredAny, Deserialize};
+use rocket::futures::{channel::mpsc, stream::FuturesUnordered, StreamExt};
+use ruma::{DeviceId, ServerName, UserId};
+use serde::Deserialize;
 use std::{
-    collections::{BTreeMap, HashMap, HashSet},
-    convert::{TryFrom, TryInto},
+    collections::HashMap,
    fs::{self, remove_dir_all},
    io::Write,
-    mem::size_of,
-    ops::Deref,
-    path::Path,
-    sync::{Arc, Mutex, RwLock},
+    sync::{Arc, RwLock},
 };
-use tokio::sync::{OwnedRwLockReadGuard, RwLock as TokioRwLock, Semaphore};
-use tracing::{debug, error, warn};
-
-use self::proxy::ProxyConfig;
+use tokio::sync::Semaphore;

 #[derive(Clone, Debug, Deserialize)]
 pub struct Config {
    server_name: Box<ServerName>,
    database_path: String,
-    #[serde(default = "default_db_cache_capacity_mb")]
-    db_cache_capacity_mb: f64,
-    #[serde(default = "default_sqlite_wal_clean_second_interval")]
-    sqlite_wal_clean_second_interval: u32,
+    #[serde(default = "default_cache_capacity")]
+    cache_capacity: u32,
    #[serde(default = "default_max_request_size")]
    max_request_size: u32,
    #[serde(default = "default_max_concurrent_requests")]
@@ -61,38 +47,11 @@ pub struct Config {
    allow_federation: bool,
    #[serde(default = "false_fn")]
    pub allow_jaeger: bool,
-    #[serde(default = "false_fn")]
-    pub tracing_flame: bool,
-    #[serde(default)]
-    proxy: ProxyConfig,
    jwt_secret: Option<String>,
    #[serde(default = "Vec::new")]
    trusted_servers: Vec<Box<ServerName>>,
    #[serde(default = "default_log")]
    pub log: String,
-
-    #[serde(flatten)]
-    catchall: BTreeMap<String, IgnoredAny>,
-}
-
-const DEPRECATED_KEYS: &[&str] = &["cache_capacity"];
-
-impl Config {
-    pub fn warn_deprecated(&self) {
-        let mut was_deprecated = false;
-        for key in self
-            .catchall
-            .keys()
-            .filter(|key| DEPRECATED_KEYS.iter().any(|s| s == key))
-        {
-            warn!("Config parameter {} is deprecated", key);
-            was_deprecated = true;
-        }
-
-        if was_deprecated {
-            warn!("Read conduit documentation and check your configuration if any new configuration parameters should be adjusted");
-        }
-    }
 }

 fn false_fn() -> bool {
@@ -103,12 +62,8 @@ fn true_fn() -> bool {
    true
 }

-fn default_db_cache_capacity_mb() -> f64 {
-    200.0
-}
-
-fn default_sqlite_wal_clean_second_interval() -> u32 {
-    1 * 60 // every minute
+fn default_cache_capacity() -> u32 {
+    1024 * 1024 * 1024
 }

 fn default_max_request_size() -> u32 {
@@ -124,16 +79,12 @@ fn default_log() -> String {
 }

 #[cfg(feature = "sled")]
-pub type Engine = abstraction::sled::Engine;
+pub type Engine = abstraction::SledEngine;

-#[cfg(feature = "sqlite")]
-pub type Engine = abstraction::sqlite::Engine;
-
-#[cfg(feature = "heed")]
-pub type Engine = abstraction::heed::Engine;
+#[cfg(feature = "rocksdb")]
+pub type Engine = abstraction::RocksDbEngine;

 pub struct Database {
-    _db: Arc<Engine>,
    pub globals: globals::Globals,
    pub users: users::Users,
    pub uiaa: uiaa::Uiaa,
@@ -161,37 +112,8 @@ impl Database {
        Ok(())
    }

-    fn check_sled_or_sqlite_db(config: &Config) -> Result<()> {
-        #[cfg(feature = "backend_sqlite")]
-        {
-            let path = Path::new(&config.database_path);
-
-            let sled_exists = path.join("db").exists();
-            let sqlite_exists = path.join("conduit.db").exists();
-            if sled_exists {
-                if sqlite_exists {
-                    // most likely an in-place directory, only warn
-                    warn!("Both sled and sqlite databases are detected in database directory");
-                    warn!("Currently running from the sqlite database, but consider removing sled database files to free up space")
-                } else {
-                    error!(
-                        "Sled database detected, conduit now uses sqlite for database operations"
-                    );
-                    error!("This database must be converted to sqlite, go to https://github.com/ShadowJonathan/conduit_toolbox#conduit_sled_to_sqlite");
-                    return Err(Error::bad_config(
-                        "sled database detected, migrate to sqlite",
-                    ));
-                }
-            }
-        }
-
-        Ok(())
-    }
-
    /// Load an existing database or create a new one.
-    pub async fn load_or_create(config: &Config) -> Result<Arc<TokioRwLock<Self>>> {
-        Self::check_sled_or_sqlite_db(&config)?;
-
+    pub async fn load_or_create(config: Config) -> Result<Arc<Self>> {
        let builder = Engine::open(&config)?;

        if config.max_request_size < 1024 {
@@ -201,13 +123,11 @@ impl Database {
        let (admin_sender, admin_receiver) = mpsc::unbounded();
        let (sending_sender, sending_receiver) = mpsc::unbounded();

-        let db = Arc::new(TokioRwLock::from(Self {
-            _db: builder.clone(),
+        let db = Arc::new(Self {
            users: users::Users {
                userid_password: builder.open_tree("userid_password")?,
                userid_displayname: builder.open_tree("userid_displayname")?,
                userid_avatarurl: builder.open_tree("userid_avatarurl")?,
-                userid_blurhash: builder.open_tree("userid_blurhash")?,
                userdeviceid_token: builder.open_tree("userdeviceid_token")?,
                userdeviceid_metadata: builder.open_tree("userdeviceid_metadata")?,
                userid_devicelistversion: builder.open_tree("userid_devicelistversion")?,
@@ -251,7 +171,6 @@ impl Database {
                serverroomids: builder.open_tree("serverroomids")?,
                userroomid_joined: builder.open_tree("userroomid_joined")?,
                roomuserid_joined: builder.open_tree("roomuserid_joined")?,
-                roomid_joinedcount: builder.open_tree("roomid_joinedcount")?,
                roomuseroncejoinedids: builder.open_tree("roomuseroncejoinedids")?,
                userroomid_invitestate: builder.open_tree("userroomid_invitestate")?,
                roomuserid_invitecount: builder.open_tree("roomuserid_invitecount")?,
@@ -262,33 +181,19 @@ impl Database {
                userroomid_highlightcount: builder.open_tree("userroomid_highlightcount")?,

                statekey_shortstatekey: builder.open_tree("statekey_shortstatekey")?,
-                shortstatekey_statekey: builder.open_tree("shortstatekey_statekey")?,
-
-                shorteventid_authchain: builder.open_tree("shorteventid_authchain")?,
-
-                roomid_shortroomid: builder.open_tree("roomid_shortroomid")?,
-
-                shortstatehash_statediff: builder.open_tree("shortstatehash_statediff")?,
+                stateid_shorteventid: builder.open_tree("stateid_shorteventid")?,
                eventid_shorteventid: builder.open_tree("eventid_shorteventid")?,
                shorteventid_eventid: builder.open_tree("shorteventid_eventid")?,
                shorteventid_shortstatehash: builder.open_tree("shorteventid_shortstatehash")?,
                roomid_shortstatehash: builder.open_tree("roomid_shortstatehash")?,
-                roomsynctoken_shortstatehash: builder.open_tree("roomsynctoken_shortstatehash")?,
                statehash_shortstatehash: builder.open_tree("statehash_shortstatehash")?,

                eventid_outlierpdu: builder.open_tree("eventid_outlierpdu")?,
-                referencedevents: builder.open_tree("referencedevents")?,
-                pdu_cache: Mutex::new(LruCache::new(100_000)),
-                auth_chain_cache: Mutex::new(LruCache::new(1_000_000)),
-                shorteventid_cache: Mutex::new(LruCache::new(1_000_000)),
-                eventidshort_cache: Mutex::new(LruCache::new(1_000_000)),
-                shortstatekey_cache: Mutex::new(LruCache::new(1_000_000)),
-                statekeyshort_cache: Mutex::new(LruCache::new(1_000_000)),
-                stateinfo_cache: Mutex::new(LruCache::new(1000)),
+                prevevent_parent: builder.open_tree("prevevent_parent")?,
+                pdu_cache: RwLock::new(LruCache::new(1_000_000)),
            },
            account_data: account_data::AccountData {
                roomuserdataid_accountdata: builder.open_tree("roomuserdataid_accountdata")?,
-                roomusertype_roomuserdataid: builder.open_tree("roomusertype_roomuserdataid")?,
            },
            media: media::Media {
                mediaid_file: builder.open_tree("mediaid_file")?,
@@ -303,8 +208,8 @@ impl Database {
            },
            sending: sending::Sending {
                servername_educount: builder.open_tree("servername_educount")?,
-                servernameevent_data: builder.open_tree("servernameevent_data")?,
-                servercurrentevent_data: builder.open_tree("servercurrentevent_data")?,
+                servernamepduids: builder.open_tree("servernamepduids")?,
+                servercurrentevents: builder.open_tree("servercurrentevents")?,
                maximum_requests: Arc::new(Semaphore::new(config.max_concurrent_requests as usize)),
                sender: sending_sender,
            },
@@ -321,442 +226,104 @@ impl Database {
            globals: globals::Globals::load(
                builder.open_tree("global")?,
                builder.open_tree("server_signingkeys")?,
-                config.clone(),
+                config,
            )?,
-        }));
+        });

-        {
-            let db = db.read().await;
-            // MIGRATIONS
-            // TODO: database versions of new dbs should probably not be 0
-            if db.globals.database_version()? < 1 {
-                for (roomserverid, _) in db.rooms.roomserverids.iter() {
-                    let mut parts = roomserverid.split(|&b| b == 0xff);
-                    let room_id = parts.next().expect("split always returns one element");
-                    let servername = match parts.next() {
-                        Some(s) => s,
-                        None => {
-                            error!("Migration: Invalid roomserverid in db.");
-                            continue;
-                        }
-                    };
-                    let mut serverroomid = servername.to_vec();
-                    serverroomid.push(0xff);
-                    serverroomid.extend_from_slice(room_id);
-
-                    db.rooms.serverroomids.insert(&serverroomid, &[])?;
-                }
-
-                db.globals.bump_database_version(1)?;
-
-                println!("Migration: 0 -> 1 finished");
-            }
-
-            if db.globals.database_version()? < 2 {
-                // We accidentally inserted hashed versions of "" into the db instead of just ""
-                for (userid, password) in db.users.userid_password.iter() {
-                    let password = utils::string_from_bytes(&password);
-
-                    let empty_hashed_password = password.map_or(false, |password| {
-                        argon2::verify_encoded(&password, b"").unwrap_or(false)
-                    });
-
-                    if empty_hashed_password {
-                        db.users.userid_password.insert(&userid, b"")?;
-                    }
-                }
-
-                db.globals.bump_database_version(2)?;
-
-                println!("Migration: 1 -> 2 finished");
-            }
-
-            if db.globals.database_version()? < 3 {
-                // Move media to filesystem
-                for (key, content) in db.media.mediaid_file.iter() {
-                    if content.is_empty() {
+        // MIGRATIONS
+        // TODO: database versions of new dbs should probably not be 0
+        if db.globals.database_version()? < 1 {
+            for (roomserverid, _) in db.rooms.roomserverids.iter() {
+                let mut parts = roomserverid.split(|&b| b == 0xff);
+                let room_id = parts.next().expect("split always returns one element");
+                let servername = match parts.next() {
+                    Some(s) => s,
+                    None => {
+                        error!("Migration: Invalid roomserverid in db.");
                        continue;
                    }
+                };
+                let mut serverroomid = servername.to_vec();
+                serverroomid.push(0xff);
+                serverroomid.extend_from_slice(room_id);

-                    let path = db.globals.get_media_file(&key);
-                    let mut file = fs::File::create(path)?;
-                    file.write_all(&content)?;
-                    db.media.mediaid_file.insert(&key, &[])?;
-                }
-
-                db.globals.bump_database_version(3)?;
-
-                println!("Migration: 2 -> 3 finished");
+                db.rooms.serverroomids.insert(&serverroomid, &[])?;
            }

-            if db.globals.database_version()? < 4 {
-                // Add federated users to db as deactivated
-                for our_user in db.users.iter() {
-                    let our_user = our_user?;
-                    if db.users.is_deactivated(&our_user)? {
-                        continue;
-                    }
-                    for room in db.rooms.rooms_joined(&our_user) {
-                        for user in db.rooms.room_members(&room?) {
-                            let user = user?;
-                            if user.server_name() != db.globals.server_name() {
-                                println!("Migration: Creating user {}", user);
-                                db.users.create(&user, None)?;
-                            }
-                        }
-                    }
-                }
+            db.globals.bump_database_version(1)?;

-                db.globals.bump_database_version(4)?;
-
-                println!("Migration: 3 -> 4 finished");
-            }
-
-            if db.globals.database_version()? < 5 {
-                // Upgrade user data store
-                for (roomuserdataid, _) in db.account_data.roomuserdataid_accountdata.iter() {
-                    let mut parts = roomuserdataid.split(|&b| b == 0xff);
-                    let room_id = parts.next().unwrap();
-                    let user_id = parts.next().unwrap();
-                    let event_type = roomuserdataid.rsplit(|&b| b == 0xff).next().unwrap();
-
-                    let mut key = room_id.to_vec();
-                    key.push(0xff);
-                    key.extend_from_slice(user_id);
-                    key.push(0xff);
-                    key.extend_from_slice(event_type);
-
-                    db.account_data
-                        .roomusertype_roomuserdataid
-                        .insert(&key, &roomuserdataid)?;
-                }
-
-                db.globals.bump_database_version(5)?;
-
-                println!("Migration: 4 -> 5 finished");
-            }
-
-            if db.globals.database_version()? < 6 {
-                // Set room member count
-                for (roomid, _) in db.rooms.roomid_shortstatehash.iter() {
-                    let room_id =
-                        RoomId::try_from(utils::string_from_bytes(&roomid).unwrap()).unwrap();
-
-                    db.rooms.update_joined_count(&room_id)?;
-                }
-
-                db.globals.bump_database_version(6)?;
-
-                println!("Migration: 5 -> 6 finished");
-            }
-
-            if db.globals.database_version()? < 7 {
-                // Upgrade state store
-                let mut last_roomstates: HashMap<RoomId, u64> = HashMap::new();
-                let mut current_sstatehash: Option<u64> = None;
-                let mut current_room = None;
-                let mut current_state = HashSet::new();
-                let mut counter = 0;
-
-                let mut handle_state =
-                    |current_sstatehash: u64,
-                     current_room: &RoomId,
-                     current_state: HashSet<_>,
-                     last_roomstates: &mut HashMap<_, _>| {
-                        counter += 1;
-                        println!("counter: {}", counter);
-                        let last_roomsstatehash = last_roomstates.get(current_room);
-
-                        let states_parents = last_roomsstatehash.map_or_else(
-                            || Ok(Vec::new()),
-                            |&last_roomsstatehash| {
-                                db.rooms.load_shortstatehash_info(dbg!(last_roomsstatehash))
-                            },
-                        )?;
-
-                        let (statediffnew, statediffremoved) =
-                            if let Some(parent_stateinfo) = states_parents.last() {
-                                let statediffnew = current_state
-                                    .difference(&parent_stateinfo.1)
-                                    .cloned()
-                                    .collect::<HashSet<_>>();
-
-                                let statediffremoved = parent_stateinfo
-                                    .1
-                                    .difference(&current_state)
-                                    .cloned()
-                                    .collect::<HashSet<_>>();
-
-                                (statediffnew, statediffremoved)
-                            } else {
-                                (current_state, HashSet::new())
-                            };
-
-                        db.rooms.save_state_from_diff(
-                            dbg!(current_sstatehash),
-                            statediffnew,
-                            statediffremoved,
-                            2, // every state change is 2 event changes on average
-                            states_parents,
-                        )?;
-
-                        /*
-                        let mut tmp = db.rooms.load_shortstatehash_info(&current_sstatehash, &db)?;
-                        let state = tmp.pop().unwrap();
-                        println!(
-                            "{}\t{}{:?}: {:?} + {:?} - {:?}",
-                            current_room,
-                            "  ".repeat(tmp.len()),
-                            utils::u64_from_bytes(&current_sstatehash).unwrap(),
-                            tmp.last().map(|b| utils::u64_from_bytes(&b.0).unwrap()),
-                            state
-                                .2
-                                .iter()
-                                .map(|b| utils::u64_from_bytes(&b[size_of::<u64>()..]).unwrap())
-                                .collect::<Vec<_>>(),
-                            state
-                                .3
-                                .iter()
-                                .map(|b| utils::u64_from_bytes(&b[size_of::<u64>()..]).unwrap())
-                                .collect::<Vec<_>>()
-                        );
-                        */
-
-                        Ok::<_, Error>(())
-                    };
-
-                for (k, seventid) in db._db.open_tree("stateid_shorteventid")?.iter() {
-                    let sstatehash = utils::u64_from_bytes(&k[0..size_of::<u64>()])
-                        .expect("number of bytes is correct");
-                    let sstatekey = k[size_of::<u64>()..].to_vec();
-                    if Some(sstatehash) != current_sstatehash {
-                        if let Some(current_sstatehash) = current_sstatehash {
-                            handle_state(
-                                current_sstatehash,
-                                current_room.as_ref().unwrap(),
-                                current_state,
-                                &mut last_roomstates,
-                            )?;
-                            last_roomstates
-                                .insert(current_room.clone().unwrap(), current_sstatehash);
-                        }
-                        current_state = HashSet::new();
-                        current_sstatehash = Some(sstatehash);
-
-                        let event_id = db
-                            .rooms
-                            .shorteventid_eventid
-                            .get(&seventid)
-                            .unwrap()
-                            .unwrap();
-                        let event_id =
-                            EventId::try_from(utils::string_from_bytes(&event_id).unwrap())
-                                .unwrap();
-                        let pdu = db.rooms.get_pdu(&event_id).unwrap().unwrap();
-
-                        if Some(&pdu.room_id) != current_room.as_ref() {
-                            current_room = Some(pdu.room_id.clone());
-                        }
-                    }
-
-                    let mut val = sstatekey;
-                    val.extend_from_slice(&seventid);
-                    current_state.insert(val.try_into().expect("size is correct"));
-                }
-
-                if let Some(current_sstatehash) = current_sstatehash {
-                    handle_state(
-                        current_sstatehash,
-                        current_room.as_ref().unwrap(),
-                        current_state,
-                        &mut last_roomstates,
-                    )?;
-                }
-
-                db.globals.bump_database_version(7)?;
-
-                println!("Migration: 6 -> 7 finished");
-            }
-
-            if db.globals.database_version()? < 8 {
-                // Generate short room ids for all rooms
-                for (room_id, _) in db.rooms.roomid_shortstatehash.iter() {
-                    let shortroomid = db.globals.next_count()?.to_be_bytes();
-                    db.rooms.roomid_shortroomid.insert(&room_id, &shortroomid)?;
-                    println!("Migration: 8");
-                }
-                // Update pduids db layout
-                let mut batch = db.rooms.pduid_pdu.iter().filter_map(|(key, v)| {
-                    if !key.starts_with(b"!") {
-                        return None;
-                    }
-                    let mut parts = key.splitn(2, |&b| b == 0xff);
-                    let room_id = parts.next().unwrap();
-                    let count = parts.next().unwrap();
-
-                    let short_room_id = db
-                        .rooms
-                        .roomid_shortroomid
-                        .get(&room_id)
-                        .unwrap()
-                        .expect("shortroomid should exist");
-
-                    let mut new_key = short_room_id;
-                    new_key.extend_from_slice(count);
-
-                    Some((new_key, v))
-                });
-
-                db.rooms.pduid_pdu.insert_batch(&mut batch)?;
-
-                let mut batch2 = db.rooms.eventid_pduid.iter().filter_map(|(k, value)| {
-                    if !value.starts_with(b"!") {
-                        return None;
-                    }
-                    let mut parts = value.splitn(2, |&b| b == 0xff);
-                    let room_id = parts.next().unwrap();
-                    let count = parts.next().unwrap();
-
-                    let short_room_id = db
-                        .rooms
-                        .roomid_shortroomid
-                        .get(&room_id)
-                        .unwrap()
-                        .expect("shortroomid should exist");
-
-                    let mut new_value = short_room_id;
-                    new_value.extend_from_slice(count);
-
-                    Some((k, new_value))
-                });
-
-                db.rooms.eventid_pduid.insert_batch(&mut batch2)?;
-
-                db.globals.bump_database_version(8)?;
-
-                println!("Migration: 7 -> 8 finished");
-            }
-
-            if db.globals.database_version()? < 9 {
-                // Update tokenids db layout
-                let batch = db
-                    .rooms
-                    .tokenids
-                    .iter()
-                    .filter_map(|(key, _)| {
-                        if !key.starts_with(b"!") {
-                            return None;
-                        }
-                        let mut parts = key.splitn(4, |&b| b == 0xff);
-                        let room_id = parts.next().unwrap();
-                        let word = parts.next().unwrap();
-                        let _pdu_id_room = parts.next().unwrap();
-                        let pdu_id_count = parts.next().unwrap();
-
-                        let short_room_id = db
-                            .rooms
-                            .roomid_shortroomid
-                            .get(&room_id)
-                            .unwrap()
-                            .expect("shortroomid should exist");
-                        let mut new_key = short_room_id;
-                        new_key.extend_from_slice(word);
-                        new_key.push(0xff);
-                        new_key.extend_from_slice(pdu_id_count);
-                        println!("old {:?}", key);
-                        println!("new {:?}", new_key);
-                        Some((new_key, Vec::new()))
-                    })
-                    .collect::<Vec<_>>();
-
-                let mut iter = batch.into_iter().peekable();
-
-                while iter.peek().is_some() {
-                    db.rooms
-                        .tokenids
-                        .insert_batch(&mut iter.by_ref().take(1000))?;
-                    println!("smaller batch done");
-                }
-
-                println!("Deleting starts");
-
-                let batch2 = db
-                    .rooms
-                    .tokenids
-                    .iter()
-                    .filter_map(|(key, _)| {
-                        if key.starts_with(b"!") {
-                            println!("del {:?}", key);
-                            Some(key)
-                        } else {
-                            None
-                        }
-                    })
-                    .collect::<Vec<_>>();
-
-                for key in batch2 {
-                    println!("del");
-                    db.rooms.tokenids.remove(&key)?;
-                }
-
-                db.globals.bump_database_version(9)?;
-
-                println!("Migration: 8 -> 9 finished");
-            }
-
-            if db.globals.database_version()? < 10 {
-                // Add other direction for shortstatekeys
-                for (statekey, shortstatekey) in db.rooms.statekey_shortstatekey.iter() {
-                    db.rooms
-                        .shortstatekey_statekey
-                        .insert(&shortstatekey, &statekey)?;
-                }
-
-                // Force E2EE device list updates so we can send them over federation
-                for user_id in db.users.iter().filter_map(|r| r.ok()) {
-                    db.users
-                        .mark_device_key_update(&user_id, &db.rooms, &db.globals)?;
-                }
-
-                db.globals.bump_database_version(10)?;
-
-                println!("Migration: 9 -> 10 finished");
-            }
+            println!("Migration: 0 -> 1 finished");
        }

-        let guard = db.read().await;
+        if db.globals.database_version()? < 2 {
+            // We accidentally inserted hashed versions of "" into the db instead of just ""
+            for (userid, password) in db.users.userid_password.iter() {
+                let password = utils::string_from_bytes(&password);
+
+                let empty_hashed_password = password.map_or(false, |password| {
+                    argon2::verify_encoded(&password, b"").unwrap_or(false)
+                });
+
+                if empty_hashed_password {
+                    db.users.userid_password.insert(&userid, b"")?;
+                }
+            }
+
+            db.globals.bump_database_version(2)?;
+
+            println!("Migration: 1 -> 2 finished");
+        }
+
+        if db.globals.database_version()? < 3 {
+            // Move media to filesystem
+            for (key, content) in db.media.mediaid_file.iter() {
+                if content.len() == 0 {
+                    continue;
+                }
+
+                let path = db.globals.get_media_file(&key);
+                let mut file = fs::File::create(path)?;
+                file.write_all(&content)?;
+                db.media.mediaid_file.insert(&key, &[])?;
+            }
+
+            db.globals.bump_database_version(3)?;
+
+            println!("Migration: 2 -> 3 finished");
+        }
+
+        if db.globals.database_version()? < 4 {
+            // Add federated users to db as deactivated
+            for our_user in db.users.iter() {
+                let our_user = our_user?;
+                if db.users.is_deactivated(&our_user)? {
+                    continue;
+                }
+                for room in db.rooms.rooms_joined(&our_user) {
+                    for user in db.rooms.room_members(&room?) {
+                        let user = user?;
+                        if user.server_name() != db.globals.server_name() {
+                            println!("Migration: Creating user {}", user);
+                            db.users.create(&user, None)?;
+                        }
+                    }
+                }
+            }
+
+            db.globals.bump_database_version(4)?;
+
+            println!("Migration: 3 -> 4 finished");
+        }

        // This data is probably outdated
-        guard.rooms.edus.presenceid_presence.clear()?;
+        db.rooms.edus.presenceid_presence.clear()?;

-        guard.admin.start_handler(Arc::clone(&db), admin_receiver);
-        guard
-            .sending
-            .start_handler(Arc::clone(&db), sending_receiver);
-
-        drop(guard);
-
-        #[cfg(feature = "sqlite")]
-        {
-            Self::start_wal_clean_task(Arc::clone(&db), &config).await;
-        }
+        db.admin.start_handler(Arc::clone(&db), admin_receiver);
+        db.sending.start_handler(Arc::clone(&db), sending_receiver);

        Ok(db)
    }

-    #[cfg(feature = "conduit_bin")]
-    pub async fn start_on_shutdown_tasks(db: Arc<TokioRwLock<Self>>, shutdown: Shutdown) {
-        use tracing::info;
-
-        tokio::spawn(async move {
-            shutdown.await;
-
-            info!(target: "shutdown-sync", "Received shutdown notification, notifying sync helpers...");
-
-            db.read().await.globals.rotate.fire();
-        });
-    }
-
    pub async fn watch(&self, user_id: &UserId, device_id: &DeviceId) {
        let userid_bytes = user_id.as_bytes().to_vec();
        let mut userid_prefix = userid_bytes.clone();
@@ -783,16 +350,6 @@ impl Database {
                .watch_prefix(&userid_prefix),
        );
        futures.push(self.rooms.userroomid_leftstate.watch_prefix(&userid_prefix));
-        futures.push(
-            self.rooms
-                .userroomid_notificationcount
-                .watch_prefix(&userid_prefix),
-        );
-        futures.push(
-            self.rooms
-                .userroomid_highlightcount
-                .watch_prefix(&userid_prefix),
-        );

        // Events for rooms we are in
        for room_id in self.rooms.rooms_joined(user_id).filter_map(|r| r.ok()) {
@@ -827,7 +384,7 @@ impl Database {

            futures.push(
                self.account_data
-                    .roomusertype_roomuserdataid
+                    .roomuserdataid_accountdata
                    .watch_prefix(&roomuser_prefix),
            );
        }
@@ -837,7 +394,7 @@ impl Database {

        futures.push(
            self.account_data
-                .roomusertype_roomuserdataid
+                .roomuserdataid_accountdata
                .watch_prefix(&globaluserdata_prefix),
        );

@@ -851,97 +408,13 @@ impl Database {
                .watch_prefix(&userid_bytes),
        );

-        futures.push(Box::pin(self.globals.rotate.watch()));
-
        // Wait until one of them finds something
        futures.next().await;
    }

-    #[tracing::instrument(skip(self))]
-    pub fn flush(&self) -> Result<()> {
-        let start = std::time::Instant::now();
-
-        let res = self._db.flush();
-
-        debug!("flush: took {:?}", start.elapsed());
-
-        res
-    }
-
-    #[cfg(feature = "sqlite")]
-    #[tracing::instrument(skip(self))]
-    pub fn flush_wal(&self) -> Result<()> {
-        self._db.flush_wal()
-    }
-
-    #[cfg(feature = "sqlite")]
-    #[tracing::instrument(skip(db, config))]
-    pub async fn start_wal_clean_task(db: Arc<TokioRwLock<Self>>, config: &Config) {
-        use tokio::time::interval;
-
-        #[cfg(unix)]
-        use tokio::signal::unix::{signal, SignalKind};
-        use tracing::info;
-
-        use std::time::{Duration, Instant};
-
-        let timer_interval = Duration::from_secs(config.sqlite_wal_clean_second_interval as u64);
-
-        tokio::spawn(async move {
-            let mut i = interval(timer_interval);
-            #[cfg(unix)]
-            let mut s = signal(SignalKind::hangup()).unwrap();
-
-            loop {
-                #[cfg(unix)]
-                tokio::select! {
-                    _ = i.tick() => {
-                        info!("wal-trunc: Timer ticked");
-                    }
-                    _ = s.recv() => {
-                        info!("wal-trunc: Received SIGHUP");
-                    }
-                };
-                #[cfg(not(unix))]
-                {
-                    i.tick().await;
-                    info!("wal-trunc: Timer ticked")
-                }
-
-                let start = Instant::now();
-                if let Err(e) = db.read().await.flush_wal() {
-                    error!("wal-trunc: Errored: {}", e);
-                } else {
-                    info!("wal-trunc: Flushed in {:?}", start.elapsed());
-                }
-            }
-        });
-    }
-}
-
-pub struct DatabaseGuard(OwnedRwLockReadGuard<Database>);
-
-impl Deref for DatabaseGuard {
-    type Target = OwnedRwLockReadGuard<Database>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-#[rocket::async_trait]
-impl<'r> FromRequest<'r> for DatabaseGuard {
-    type Error = ();
-
-    async fn from_request(req: &'r Request<'_>) -> rocket::request::Outcome<Self, ()> {
-        let db = try_outcome!(req.guard::<&State<Arc<TokioRwLock<Database>>>>().await);
-
-        Ok(DatabaseGuard(Arc::clone(&db).read_owned().await)).or_forward(())
-    }
-}
-
-impl From<OwnedRwLockReadGuard<Database>> for DatabaseGuard {
-    fn from(val: OwnedRwLockReadGuard<Database>) -> Self {
-        Self(val)
+    pub async fn flush(&self) -> Result<()> {
+        // noop while we don't use sled 1.0
+        //self._db.flush_async().await?;
+        Ok(())
    }
 }
@@ -1,46 +1,51 @@
 use super::Config;
-use crate::Result;
-
+use crate::{utils, Result};
+use log::warn;
 use std::{future::Future, pin::Pin, sync::Arc};

+#[cfg(feature = "rocksdb")]
+use std::{collections::BTreeMap, sync::RwLock};
+
 #[cfg(feature = "sled")]
-pub mod sled;
+pub struct SledEngine(sled::Db);
+#[cfg(feature = "sled")]
+pub struct SledEngineTree(sled::Tree);

-#[cfg(feature = "sqlite")]
-pub mod sqlite;
-
-#[cfg(feature = "heed")]
-pub mod heed;
+#[cfg(feature = "rocksdb")]
+pub struct RocksDbEngine(rocksdb::DBWithThreadMode<rocksdb::MultiThreaded>);
+#[cfg(feature = "rocksdb")]
+pub struct RocksDbEngineTree<'a> {
+    db: Arc<RocksDbEngine>,
+    name: &'a str,
+    watchers: RwLock<BTreeMap<Vec<u8>, Vec<tokio::sync::oneshot::Sender<()>>>>,
+}

 pub trait DatabaseEngine: Sized {
    fn open(config: &Config) -> Result<Arc<Self>>;
    fn open_tree(self: &Arc<Self>, name: &'static str) -> Result<Arc<dyn Tree>>;
-    fn flush(self: &Arc<Self>) -> Result<()>;
 }

 pub trait Tree: Send + Sync {
    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>>;

    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()>;
-    fn insert_batch<'a>(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()>;

    fn remove(&self, key: &[u8]) -> Result<()>;

-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a>;
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + Send + Sync + 'a>;

    fn iter_from<'a>(
        &'a self,
        from: &[u8],
        backwards: bool,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a>;
+    ) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + 'a>;

    fn increment(&self, key: &[u8]) -> Result<Vec<u8>>;
-    fn increment_batch<'a>(&self, iter: &mut dyn Iterator<Item = Vec<u8>>) -> Result<()>;

    fn scan_prefix<'a>(
        &'a self,
        prefix: Vec<u8>,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a>;
+    ) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + Send + 'a>;

    fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>>;

@@ -52,3 +57,273 @@ pub trait Tree: Send + Sync {
        Ok(())
    }
 }
+
+#[cfg(feature = "sled")]
+impl DatabaseEngine for SledEngine {
+    fn open(config: &Config) -> Result<Arc<Self>> {
+        Ok(Arc::new(SledEngine(
+            sled::Config::default()
+                .path(&config.database_path)
+                .cache_capacity(config.cache_capacity as u64)
+                .use_compression(true)
+                .open()?,
+        )))
+    }
+
+    fn open_tree(self: &Arc<Self>, name: &'static str) -> Result<Arc<dyn Tree>> {
+        Ok(Arc::new(SledEngineTree(self.0.open_tree(name)?)))
+    }
+}
+
+#[cfg(feature = "sled")]
+impl Tree for SledEngineTree {
+    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
+        Ok(self.0.get(key)?.map(|v| v.to_vec()))
+    }
+
+    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()> {
+        self.0.insert(key, value)?;
+        Ok(())
+    }
+
+    fn remove(&self, key: &[u8]) -> Result<()> {
+        self.0.remove(key)?;
+        Ok(())
+    }
+
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + Send + Sync + 'a> {
+        Box::new(
+            self.0
+                .iter()
+                .filter_map(|r| {
+                    if let Err(e) = &r {
+                        warn!("Error: {}", e);
+                    }
+                    r.ok()
+                })
+                .map(|(k, v)| (k.to_vec().into(), v.to_vec().into())),
+        )
+    }
+
+    fn iter_from(
+        &self,
+        from: &[u8],
+        backwards: bool,
+    ) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)>> {
+        let iter = if backwards {
+            self.0.range(..=from)
+        } else {
+            self.0.range(from..)
+        };
+
+        let iter = iter
+            .filter_map(|r| {
+                if let Err(e) = &r {
+                    warn!("Error: {}", e);
+                }
+                r.ok()
+            })
+            .map(|(k, v)| (k.to_vec().into(), v.to_vec().into()));
+
+        if backwards {
+            Box::new(iter.rev())
+        } else {
+            Box::new(iter)
+        }
+    }
+
+    fn increment(&self, key: &[u8]) -> Result<Vec<u8>> {
+        Ok(self
+            .0
+            .update_and_fetch(key, utils::increment)
+            .map(|o| o.expect("increment always sets a value").to_vec())?)
+    }
+
+    fn scan_prefix<'a>(
+        &'a self,
+        prefix: Vec<u8>,
+    ) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + Send + 'a> {
+        let iter = self
+            .0
+            .scan_prefix(prefix)
+            .filter_map(|r| {
+                if let Err(e) = &r {
+                    warn!("Error: {}", e);
+                }
+                r.ok()
+            })
+            .map(|(k, v)| (k.to_vec().into(), v.to_vec().into()));
+
+        Box::new(iter)
+    }
+
+    fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
+        let prefix = prefix.to_vec();
+        Box::pin(async move {
+            self.0.watch_prefix(prefix).await;
+        })
+    }
+}
+
+#[cfg(feature = "rocksdb")]
+impl DatabaseEngine for RocksDbEngine {
+    fn open(config: &Config) -> Result<Arc<Self>> {
+        let mut db_opts = rocksdb::Options::default();
+        db_opts.create_if_missing(true);
+        db_opts.set_max_open_files(16);
+        db_opts.set_compaction_style(rocksdb::DBCompactionStyle::Level);
+        db_opts.set_compression_type(rocksdb::DBCompressionType::Snappy);
+        db_opts.set_target_file_size_base(256 << 20);
+        db_opts.set_write_buffer_size(256 << 20);
+
+        let mut block_based_options = rocksdb::BlockBasedOptions::default();
+        block_based_options.set_block_size(512 << 10);
+        db_opts.set_block_based_table_factory(&block_based_options);
+
+        let cfs = rocksdb::DBWithThreadMode::<rocksdb::MultiThreaded>::list_cf(
+            &db_opts,
+            &config.database_path,
+        )
+        .unwrap_or_default();
+
+        let mut options = rocksdb::Options::default();
+        options.set_merge_operator_associative("increment", utils::increment_rocksdb);
+
+        let db = rocksdb::DBWithThreadMode::<rocksdb::MultiThreaded>::open_cf_descriptors(
+            &db_opts,
+            &config.database_path,
+            cfs.iter()
+                .map(|name| rocksdb::ColumnFamilyDescriptor::new(name, options.clone())),
+        )?;
+
+        Ok(Arc::new(RocksDbEngine(db)))
+    }
+
+    fn open_tree(self: &Arc<Self>, name: &'static str) -> Result<Arc<dyn Tree>> {
+        let mut options = rocksdb::Options::default();
+        options.set_merge_operator_associative("increment", utils::increment_rocksdb);
+
+        // Create if it doesn't exist
+        let _ = self.0.create_cf(name, &options);
+
+        Ok(Arc::new(RocksDbEngineTree {
+            name,
+            db: Arc::clone(self),
+            watchers: RwLock::new(BTreeMap::new()),
+        }))
+    }
+}
+
+#[cfg(feature = "rocksdb")]
+impl RocksDbEngineTree<'_> {
+    fn cf(&self) -> rocksdb::BoundColumnFamily<'_> {
+        self.db.0.cf_handle(self.name).unwrap()
+    }
+}
+
+#[cfg(feature = "rocksdb")]
+impl Tree for RocksDbEngineTree<'_> {
+    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
+        Ok(self.db.0.get_cf(self.cf(), key)?)
+    }
+
+    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()> {
+        let watchers = self.watchers.read().unwrap();
+        let mut triggered = Vec::new();
+
+        for length in 0..=key.len() {
+            if watchers.contains_key(&key[..length]) {
+                triggered.push(&key[..length]);
+            }
+        }
+
+        drop(watchers);
+
+        if !triggered.is_empty() {
+            let mut watchers = self.watchers.write().unwrap();
+            for prefix in triggered {
+                if let Some(txs) = watchers.remove(prefix) {
+                    for tx in txs {
+                        let _ = tx.send(());
+                    }
+                }
+            }
+        }
+
+        Ok(self.db.0.put_cf(self.cf(), key, value)?)
+    }
+
+    fn remove(&self, key: &[u8]) -> Result<()> {
+        Ok(self.db.0.delete_cf(self.cf(), key)?)
+    }
+
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + Send + Sync + 'a> {
+        Box::new(
+            self.db
+                .0
+                .iterator_cf(self.cf(), rocksdb::IteratorMode::Start),
+        )
+    }
+
+    fn iter_from<'a>(
+        &'a self,
+        from: &[u8],
+        backwards: bool,
+    ) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + 'a> {
+        Box::new(self.db.0.iterator_cf(
+            self.cf(),
+            rocksdb::IteratorMode::From(
+                from,
+                if backwards {
+                    rocksdb::Direction::Reverse
+                } else {
+                    rocksdb::Direction::Forward
+                },
+            ),
+        ))
+    }
+
+    fn increment(&self, key: &[u8]) -> Result<Vec<u8>> {
+        let stats = rocksdb::perf::get_memory_usage_stats(Some(&[&self.db.0]), None).unwrap();
+        dbg!(stats.mem_table_total);
+        dbg!(stats.mem_table_unflushed);
+        dbg!(stats.mem_table_readers_total);
+        dbg!(stats.cache_total);
+        // TODO: atomic?
+        let old = self.get(key)?;
+        let new = utils::increment(old.as_deref()).unwrap();
+        self.insert(key, &new)?;
+        Ok(new)
+    }
+
+    fn scan_prefix<'a>(
+        &'a self,
+        prefix: Vec<u8>,
+    ) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + Send + 'a> {
+        Box::new(
+            self.db
+                .0
+                .iterator_cf(
+                    self.cf(),
+                    rocksdb::IteratorMode::From(&prefix, rocksdb::Direction::Forward),
+                )
+                .take_while(move |(k, _)| k.starts_with(&prefix)),
+        )
+    }
+
+    fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
+        let (tx, rx) = tokio::sync::oneshot::channel();
+
+        self.watchers
+            .write()
+            .unwrap()
+            .entry(prefix.to_vec())
+            .or_default()
+            .push(tx);
+
+        Box::pin(async move {
+            // Tx is never destroyed
+            rx.await.unwrap();
+        })
+    }
+}
@@ -1,240 +0,0 @@
-use super::super::Config;
-use crossbeam::channel::{bounded, Sender as ChannelSender};
-use threadpool::ThreadPool;
-
-use crate::{Error, Result};
-use std::{
-    collections::HashMap,
-    future::Future,
-    pin::Pin,
-    sync::{Arc, Mutex, RwLock},
-};
-use tokio::sync::oneshot::Sender;
-
-use super::{DatabaseEngine, Tree};
-
-type TupleOfBytes = (Vec<u8>, Vec<u8>);
-
-pub struct Engine {
-    env: heed::Env,
-    iter_pool: Mutex<ThreadPool>,
-}
-
-pub struct EngineTree {
-    engine: Arc<Engine>,
-    tree: Arc<heed::UntypedDatabase>,
-    watchers: RwLock<HashMap<Vec<u8>, Vec<Sender<()>>>>,
-}
-
-fn convert_error(error: heed::Error) -> Error {
-    Error::HeedError {
-        error: error.to_string(),
-    }
-}
-
-impl DatabaseEngine for Engine {
-    fn open(config: &Config) -> Result<Arc<Self>> {
-        let mut env_builder = heed::EnvOpenOptions::new();
-        env_builder.map_size(1024 * 1024 * 1024 * 1024); // 1 Terabyte
-        env_builder.max_readers(126);
-        env_builder.max_dbs(128);
-        unsafe {
-            env_builder.flag(heed::flags::Flags::MdbWriteMap);
-            env_builder.flag(heed::flags::Flags::MdbMapAsync);
-        }
-
-        Ok(Arc::new(Engine {
-            env: env_builder
-                .open(&config.database_path)
-                .map_err(convert_error)?,
-            iter_pool: Mutex::new(ThreadPool::new(10)),
-        }))
-    }
-
-    fn open_tree(self: &Arc<Self>, name: &'static str) -> Result<Arc<dyn Tree>> {
-        // Creates the db if it doesn't exist already
-        Ok(Arc::new(EngineTree {
-            engine: Arc::clone(self),
-            tree: Arc::new(
-                self.env
-                    .create_database(Some(name))
-                    .map_err(convert_error)?,
-            ),
-            watchers: RwLock::new(HashMap::new()),
-        }))
-    }
-
-    fn flush(self: &Arc<Self>) -> Result<()> {
-        self.env.force_sync().map_err(convert_error)?;
-        Ok(())
-    }
-}
-
-impl EngineTree {
-    #[tracing::instrument(skip(self, tree, from, backwards))]
-    fn iter_from_thread(
-        &self,
-        tree: Arc<heed::UntypedDatabase>,
-        from: Vec<u8>,
-        backwards: bool,
-    ) -> Box<dyn Iterator<Item = TupleOfBytes> + Send + Sync> {
-        let (s, r) = bounded::<TupleOfBytes>(100);
-        let engine = Arc::clone(&self.engine);
-
-        let lock = self.engine.iter_pool.lock().await;
-        if lock.active_count() < lock.max_count() {
-            lock.execute(move || {
-                iter_from_thread_work(tree, &engine.env.read_txn().unwrap(), from, backwards, &s);
-            });
-        } else {
-            std::thread::spawn(move || {
-                iter_from_thread_work(tree, &engine.env.read_txn().unwrap(), from, backwards, &s);
-            });
-        }
-
-        Box::new(r.into_iter())
-    }
-}
-
-#[tracing::instrument(skip(tree, txn, from, backwards))]
-fn iter_from_thread_work(
-    tree: Arc<heed::UntypedDatabase>,
-    txn: &heed::RoTxn<'_>,
-    from: Vec<u8>,
-    backwards: bool,
-    s: &ChannelSender<(Vec<u8>, Vec<u8>)>,
-) {
-    if backwards {
-        for (k, v) in tree.rev_range(txn, ..=&*from).unwrap().map(|r| r.unwrap()) {
-            if s.send((k.to_vec(), v.to_vec())).is_err() {
-                return;
-            }
-        }
-    } else {
-        if from.is_empty() {
-            for (k, v) in tree.iter(txn).unwrap().map(|r| r.unwrap()) {
-                if s.send((k.to_vec(), v.to_vec())).is_err() {
-                    return;
-                }
-            }
-        } else {
-            for (k, v) in tree.range(txn, &*from..).unwrap().map(|r| r.unwrap()) {
-                if s.send((k.to_vec(), v.to_vec())).is_err() {
-                    return;
-                }
-            }
-        }
-    }
-}
-
-impl Tree for EngineTree {
-    #[tracing::instrument(skip(self, key))]
-    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
-        let txn = self.engine.env.read_txn().map_err(convert_error)?;
-        Ok(self
-            .tree
-            .get(&txn, &key)
-            .map_err(convert_error)?
-            .map(|s| s.to_vec()))
-    }
-
-    #[tracing::instrument(skip(self, key, value))]
-    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()> {
-        let mut txn = self.engine.env.write_txn().map_err(convert_error)?;
-        self.tree
-            .put(&mut txn, &key, &value)
-            .map_err(convert_error)?;
-        txn.commit().map_err(convert_error)?;
-
-        let watchers = self.watchers.read().unwrap();
-        let mut triggered = Vec::new();
-
-        for length in 0..=key.len() {
-            if watchers.contains_key(&key[..length]) {
-                triggered.push(&key[..length]);
-            }
-        }
-
-        drop(watchers);
-
-        if !triggered.is_empty() {
-            let mut watchers = self.watchers.write().unwrap();
-            for prefix in triggered {
-                if let Some(txs) = watchers.remove(prefix) {
-                    for tx in txs {
-                        let _ = tx.send(());
-                    }
-                }
-            }
-        };
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, key))]
-    fn remove(&self, key: &[u8]) -> Result<()> {
-        let mut txn = self.engine.env.write_txn().map_err(convert_error)?;
-        self.tree.delete(&mut txn, &key).map_err(convert_error)?;
-        txn.commit().map_err(convert_error)?;
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self))]
-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> {
-        self.iter_from(&[], false)
-    }
-
-    #[tracing::instrument(skip(self, from, backwards))]
-    fn iter_from(
-        &self,
-        from: &[u8],
-        backwards: bool,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send> {
-        self.iter_from_thread(Arc::clone(&self.tree), from.to_vec(), backwards)
-    }
-
-    #[tracing::instrument(skip(self, key))]
-    fn increment(&self, key: &[u8]) -> Result<Vec<u8>> {
-        let mut txn = self.engine.env.write_txn().map_err(convert_error)?;
-
-        let old = self.tree.get(&txn, &key).map_err(convert_error)?;
-        let new =
-            crate::utils::increment(old.as_deref()).expect("utils::increment always returns Some");
-
-        self.tree
-            .put(&mut txn, &key, &&*new)
-            .map_err(convert_error)?;
-
-        txn.commit().map_err(convert_error)?;
-
-        Ok(new)
-    }
-
-    #[tracing::instrument(skip(self, prefix))]
-    fn scan_prefix<'a>(
-        &'a self,
-        prefix: Vec<u8>,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> {
-        Box::new(
-            self.iter_from(&prefix, false)
-                .take_while(move |(key, _)| key.starts_with(&prefix)),
-        )
-    }
-
-    #[tracing::instrument(skip(self, prefix))]
-    fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
-        let (tx, rx) = tokio::sync::oneshot::channel();
-
-        self.watchers
-            .write()
-            .unwrap()
-            .entry(prefix.to_vec())
-            .or_default()
-            .push(tx);
-
-        Box::pin(async move {
-            // Tx is never destroyed
-            rx.await.unwrap();
-        })
-    }
-}
@@ -1,128 +0,0 @@
-use super::super::Config;
-use crate::{utils, Result};
-use std::{future::Future, pin::Pin, sync::Arc};
-use tracing::warn;
-
-use super::{DatabaseEngine, Tree};
-
-pub struct Engine(sled::Db);
-
-pub struct SledEngineTree(sled::Tree);
-
-impl DatabaseEngine for Engine {
-    fn open(config: &Config) -> Result<Arc<Self>> {
-        Ok(Arc::new(Engine(
-            sled::Config::default()
-                .path(&config.database_path)
-                .cache_capacity((config.db_cache_capacity_mb * 1024.0 * 1024.0) as u64)
-                .use_compression(true)
-                .open()?,
-        )))
-    }
-
-    fn open_tree(self: &Arc<Self>, name: &'static str) -> Result<Arc<dyn Tree>> {
-        Ok(Arc::new(SledEngineTree(self.0.open_tree(name)?)))
-    }
-
-    fn flush(self: &Arc<Self>) -> Result<()> {
-        Ok(()) // noop
-    }
-}
-
-impl Tree for SledEngineTree {
-    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
-        Ok(self.0.get(key)?.map(|v| v.to_vec()))
-    }
-
-    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()> {
-        self.0.insert(key, value)?;
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, iter))]
-    fn insert_batch<'a>(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()> {
-        for (key, value) in iter {
-            self.0.insert(key, value)?;
-        }
-
-        Ok(())
-    }
-
-    fn remove(&self, key: &[u8]) -> Result<()> {
-        self.0.remove(key)?;
-        Ok(())
-    }
-
-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> {
-        Box::new(
-            self.0
-                .iter()
-                .filter_map(|r| {
-                    if let Err(e) = &r {
-                        warn!("Error: {}", e);
-                    }
-                    r.ok()
-                })
-                .map(|(k, v)| (k.to_vec().into(), v.to_vec().into())),
-        )
-    }
-
-    fn iter_from(
-        &self,
-        from: &[u8],
-        backwards: bool,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)>> {
-        let iter = if backwards {
-            self.0.range(..=from)
-        } else {
-            self.0.range(from..)
-        };
-
-        let iter = iter
-            .filter_map(|r| {
-                if let Err(e) = &r {
-                    warn!("Error: {}", e);
-                }
-                r.ok()
-            })
-            .map(|(k, v)| (k.to_vec().into(), v.to_vec().into()));
-
-        if backwards {
-            Box::new(iter.rev())
-        } else {
-            Box::new(iter)
-        }
-    }
-
-    fn increment(&self, key: &[u8]) -> Result<Vec<u8>> {
-        Ok(self
-            .0
-            .update_and_fetch(key, utils::increment)
-            .map(|o| o.expect("increment always sets a value").to_vec())?)
-    }
-
-    fn scan_prefix<'a>(
-        &'a self,
-        prefix: Vec<u8>,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> {
-        let iter = self
-            .0
-            .scan_prefix(prefix)
-            .filter_map(|r| {
-                if let Err(e) = &r {
-                    warn!("Error: {}", e);
-                }
-                r.ok()
-            })
-            .map(|(k, v)| (k.to_vec().into(), v.to_vec().into()));
-
-        Box::new(iter)
-    }
-
-    fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
-        let prefix = prefix.to_vec();
-        Box::pin(async move {
-            self.0.watch_prefix(prefix).await;
-        })
-    }
-}
@@ -1,393 +0,0 @@
-use super::{DatabaseEngine, Tree};
-use crate::{database::Config, Result};
-use parking_lot::{Mutex, MutexGuard, RwLock};
-use rusqlite::{Connection, DatabaseName::Main, OptionalExtension};
-use std::{
-    cell::RefCell,
-    collections::HashMap,
-    future::Future,
-    path::{Path, PathBuf},
-    pin::Pin,
-    sync::Arc,
-};
-use tokio::sync::oneshot::Sender;
-use tracing::debug;
-
-thread_local! {
-    static READ_CONNECTION: RefCell<Option<&'static Connection>> = RefCell::new(None);
-    static READ_CONNECTION_ITERATOR: RefCell<Option<&'static Connection>> = RefCell::new(None);
-}
-
-struct PreparedStatementIterator<'a> {
-    pub iterator: Box<dyn Iterator<Item = TupleOfBytes> + 'a>,
-    pub statement_ref: NonAliasingBox<rusqlite::Statement<'a>>,
-}
-
-impl Iterator for PreparedStatementIterator<'_> {
-    type Item = TupleOfBytes;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iterator.next()
-    }
-}
-
-struct NonAliasingBox<T>(*mut T);
-impl<T> Drop for NonAliasingBox<T> {
-    fn drop(&mut self) {
-        unsafe { Box::from_raw(self.0) };
-    }
-}
-
-pub struct Engine {
-    writer: Mutex<Connection>,
-
-    path: PathBuf,
-    cache_size_per_thread: u32,
-}
-
-impl Engine {
-    fn prepare_conn(path: &Path, cache_size_kb: u32) -> Result<Connection> {
-        let conn = Connection::open(&path)?;
-
-        conn.pragma_update(Some(Main), "page_size", &2048)?;
-        conn.pragma_update(Some(Main), "journal_mode", &"WAL")?;
-        conn.pragma_update(Some(Main), "synchronous", &"NORMAL")?;
-        conn.pragma_update(Some(Main), "cache_size", &(-i64::from(cache_size_kb)))?;
-        conn.pragma_update(Some(Main), "wal_autocheckpoint", &2000)?;
-
-        Ok(conn)
-    }
-
-    fn write_lock(&self) -> MutexGuard<'_, Connection> {
-        self.writer.lock()
-    }
-
-    fn read_lock(&self) -> &'static Connection {
-        READ_CONNECTION.with(|cell| {
-            let connection = &mut cell.borrow_mut();
-
-            if (*connection).is_none() {
-                let c = Box::leak(Box::new(
-                    Self::prepare_conn(&self.path, self.cache_size_per_thread).unwrap(),
-                ));
-                **connection = Some(c);
-            }
-
-            connection.unwrap()
-        })
-    }
-
-    fn read_lock_iterator(&self) -> &'static Connection {
-        READ_CONNECTION_ITERATOR.with(|cell| {
-            let connection = &mut cell.borrow_mut();
-
-            if (*connection).is_none() {
-                let c = Box::leak(Box::new(
-                    Self::prepare_conn(&self.path, self.cache_size_per_thread).unwrap(),
-                ));
-                **connection = Some(c);
-            }
-
-            connection.unwrap()
-        })
-    }
-
-    pub fn flush_wal(self: &Arc<Self>) -> Result<()> {
-        // We use autocheckpoints
-        //self.write_lock()
-        //.pragma_update(Some(Main), "wal_checkpoint", &"TRUNCATE")?;
-        Ok(())
-    }
-}
-
-impl DatabaseEngine for Engine {
-    fn open(config: &Config) -> Result<Arc<Self>> {
-        let path = Path::new(&config.database_path).join("conduit.db");
-
-        // calculates cache-size per permanent connection
-        // 1. convert MB to KiB
-        // 2. divide by permanent connections
-        // 3. round down to nearest integer
-        let cache_size_per_thread: u32 =
-            ((config.db_cache_capacity_mb * 1024.0) / (num_cpus::get().max(1) + 1) as f64) as u32;
-
-        let writer = Mutex::new(Self::prepare_conn(&path, cache_size_per_thread)?);
-
-        let arc = Arc::new(Engine {
-            writer,
-            path,
-            cache_size_per_thread,
-        });
-
-        Ok(arc)
-    }
-
-    fn open_tree(self: &Arc<Self>, name: &str) -> Result<Arc<dyn Tree>> {
-        self.write_lock().execute(&format!("CREATE TABLE IF NOT EXISTS {} ( \"key\" BLOB PRIMARY KEY, \"value\" BLOB NOT NULL )", name), [])?;
-
-        Ok(Arc::new(SqliteTable {
-            engine: Arc::clone(self),
-            name: name.to_owned(),
-            watchers: RwLock::new(HashMap::new()),
-        }))
-    }
-
-    fn flush(self: &Arc<Self>) -> Result<()> {
-        // we enabled PRAGMA synchronous=normal, so this should not be necessary
-        Ok(())
-    }
-}
-
-pub struct SqliteTable {
-    engine: Arc<Engine>,
-    name: String,
-    watchers: RwLock<HashMap<Vec<u8>, Vec<Sender<()>>>>,
-}
-
-type TupleOfBytes = (Vec<u8>, Vec<u8>);
-
-impl SqliteTable {
-    #[tracing::instrument(skip(self, guard, key))]
-    fn get_with_guard(&self, guard: &Connection, key: &[u8]) -> Result<Option<Vec<u8>>> {
-        Ok(guard
-            .prepare(format!("SELECT value FROM {} WHERE key = ?", self.name).as_str())?
-            .query_row([key], |row| row.get(0))
-            .optional()?)
-    }
-
-    #[tracing::instrument(skip(self, guard, key, value))]
-    fn insert_with_guard(&self, guard: &Connection, key: &[u8], value: &[u8]) -> Result<()> {
-        guard.execute(
-            format!(
-                "INSERT OR REPLACE INTO {} (key, value) VALUES (?, ?)",
-                self.name
-            )
-            .as_str(),
-            [key, value],
-        )?;
-        Ok(())
-    }
-
-    pub fn iter_with_guard<'a>(
-        &'a self,
-        guard: &'a Connection,
-    ) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
-        let statement = Box::leak(Box::new(
-            guard
-                .prepare(&format!(
-                    "SELECT key, value FROM {} ORDER BY key ASC",
-                    &self.name
-                ))
-                .unwrap(),
-        ));
-
-        let statement_ref = NonAliasingBox(statement);
-
-        let iterator = Box::new(
-            statement
-                .query_map([], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
-                .unwrap()
-                .map(|r| r.unwrap()),
-        );
-
-        Box::new(PreparedStatementIterator {
-            iterator,
-            statement_ref,
-        })
-    }
-}
-
-impl Tree for SqliteTable {
-    #[tracing::instrument(skip(self, key))]
-    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
-        self.get_with_guard(&self.engine.read_lock(), key)
-    }
-
-    #[tracing::instrument(skip(self, key, value))]
-    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()> {
-        let guard = self.engine.write_lock();
-        self.insert_with_guard(&guard, key, value)?;
-        drop(guard);
-
-        let watchers = self.watchers.read();
-        let mut triggered = Vec::new();
-
-        for length in 0..=key.len() {
-            if watchers.contains_key(&key[..length]) {
-                triggered.push(&key[..length]);
-            }
-        }
-
-        drop(watchers);
-
-        if !triggered.is_empty() {
-            let mut watchers = self.watchers.write();
-            for prefix in triggered {
-                if let Some(txs) = watchers.remove(prefix) {
-                    for tx in txs {
-                        let _ = tx.send(());
-                    }
-                }
-            }
-        };
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, iter))]
-    fn insert_batch<'a>(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()> {
-        let guard = self.engine.write_lock();
-
-        guard.execute("BEGIN", [])?;
-        for (key, value) in iter {
-            self.insert_with_guard(&guard, &key, &value)?;
-        }
-        guard.execute("COMMIT", [])?;
-
-        drop(guard);
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, iter))]
-    fn increment_batch<'a>(&self, iter: &mut dyn Iterator<Item = Vec<u8>>) -> Result<()> {
-        let guard = self.engine.write_lock();
-
-        guard.execute("BEGIN", [])?;
-        for key in iter {
-            let old = self.get_with_guard(&guard, &key)?;
-            let new = crate::utils::increment(old.as_deref())
-                .expect("utils::increment always returns Some");
-            self.insert_with_guard(&guard, &key, &new)?;
-        }
-        guard.execute("COMMIT", [])?;
-
-        drop(guard);
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, key))]
-    fn remove(&self, key: &[u8]) -> Result<()> {
-        let guard = self.engine.write_lock();
-
-        guard.execute(
-            format!("DELETE FROM {} WHERE key = ?", self.name).as_str(),
-            [key],
-        )?;
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self))]
-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
-        let guard = self.engine.read_lock_iterator();
-
-        self.iter_with_guard(&guard)
-    }
-
-    #[tracing::instrument(skip(self, from, backwards))]
-    fn iter_from<'a>(
-        &'a self,
-        from: &[u8],
-        backwards: bool,
-    ) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
-        let guard = self.engine.read_lock_iterator();
-        let from = from.to_vec(); // TODO change interface?
-
-        if backwards {
-            let statement = Box::leak(Box::new(
-                guard
-                    .prepare(&format!(
-                        "SELECT key, value FROM {} WHERE key <= ? ORDER BY key DESC",
-                        &self.name
-                    ))
-                    .unwrap(),
-            ));
-
-            let statement_ref = NonAliasingBox(statement);
-
-            let iterator = Box::new(
-                statement
-                    .query_map([from], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
-                    .unwrap()
-                    .map(|r| r.unwrap()),
-            );
-            Box::new(PreparedStatementIterator {
-                iterator,
-                statement_ref,
-            })
-        } else {
-            let statement = Box::leak(Box::new(
-                guard
-                    .prepare(&format!(
-                        "SELECT key, value FROM {} WHERE key >= ? ORDER BY key ASC",
-                        &self.name
-                    ))
-                    .unwrap(),
-            ));
-
-            let statement_ref = NonAliasingBox(statement);
-
-            let iterator = Box::new(
-                statement
-                    .query_map([from], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
-                    .unwrap()
-                    .map(|r| r.unwrap()),
-            );
-
-            Box::new(PreparedStatementIterator {
-                iterator,
-                statement_ref,
-            })
-        }
-    }
-
-    #[tracing::instrument(skip(self, key))]
-    fn increment(&self, key: &[u8]) -> Result<Vec<u8>> {
-        let guard = self.engine.write_lock();
-
-        let old = self.get_with_guard(&guard, key)?;
-
-        let new =
-            crate::utils::increment(old.as_deref()).expect("utils::increment always returns Some");
-
-        self.insert_with_guard(&guard, key, &new)?;
-
-        Ok(new)
-    }
-
-    #[tracing::instrument(skip(self, prefix))]
-    fn scan_prefix<'a>(&'a self, prefix: Vec<u8>) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
-        Box::new(
-            self.iter_from(&prefix, false)
-                .take_while(move |(key, _)| key.starts_with(&prefix)),
-        )
-    }
-
-    #[tracing::instrument(skip(self, prefix))]
-    fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
-        let (tx, rx) = tokio::sync::oneshot::channel();
-
-        self.watchers
-            .write()
-            .entry(prefix.to_vec())
-            .or_default()
-            .push(tx);
-
-        Box::pin(async move {
-            // Tx is never destroyed
-            rx.await.unwrap();
-        })
-    }
-
-    #[tracing::instrument(skip(self))]
-    fn clear(&self) -> Result<()> {
-        debug!("clear: running");
-        self.engine
-            .write_lock()
-            .execute(format!("DELETE FROM {}", self.name).as_str(), [])?;
-        debug!("clear: ran");
-        Ok(())
-    }
-}
@@ -12,12 +12,10 @@ use super::abstraction::Tree;

 pub struct AccountData {
    pub(super) roomuserdataid_accountdata: Arc<dyn Tree>, // RoomUserDataId = Room + User + Count + Type
-    pub(super) roomusertype_roomuserdataid: Arc<dyn Tree>, // RoomUserType = Room + User + Type
 }

 impl AccountData {
    /// Places one event in the account data of the user and removes the previous entry.
-    #[tracing::instrument(skip(self, room_id, user_id, event_type, data, globals))]
    pub fn update<T: Serialize>(
        &self,
        room_id: Option<&RoomId>,
@@ -35,13 +33,15 @@ impl AccountData {
        prefix.extend_from_slice(&user_id.as_bytes());
        prefix.push(0xff);

-        let mut roomuserdataid = prefix.clone();
-        roomuserdataid.extend_from_slice(&globals.next_count()?.to_be_bytes());
-        roomuserdataid.push(0xff);
-        roomuserdataid.extend_from_slice(&event_type.as_bytes());
+        // Remove old entry
+        if let Some((old_key, _)) = self.find_event(room_id, user_id, &event_type)? {
+            self.roomuserdataid_accountdata.remove(&old_key)?;
+        }

-        let mut key = prefix.clone();
-        key.extend_from_slice(event_type.as_bytes());
+        let mut key = prefix;
+        key.extend_from_slice(&globals.next_count()?.to_be_bytes());
+        key.push(0xff);
+        key.extend_from_slice(event_type.as_ref().as_bytes());

        let json = serde_json::to_value(data).expect("all types here can be serialized"); // TODO: maybe add error handling
        if json.get("type").is_none() || json.get("content").is_none() {
@@ -52,58 +52,29 @@ impl AccountData {
        }

        self.roomuserdataid_accountdata.insert(
-            &roomuserdataid,
+            &key,
            &serde_json::to_vec(&json).expect("to_vec always works on json values"),
        )?;

-        let prev = self.roomusertype_roomuserdataid.get(&key)?;
-
-        self.roomusertype_roomuserdataid
-            .insert(&key, &roomuserdataid)?;
-
-        // Remove old entry
-        if let Some(prev) = prev {
-            self.roomuserdataid_accountdata.remove(&prev)?;
-        }
-
        Ok(())
    }

    /// Searches the account data for a specific kind.
-    #[tracing::instrument(skip(self, room_id, user_id, kind))]
    pub fn get<T: DeserializeOwned>(
        &self,
        room_id: Option<&RoomId>,
        user_id: &UserId,
        kind: EventType,
    ) -> Result<Option<T>> {
-        let mut key = room_id
-            .map(|r| r.to_string())
-            .unwrap_or_default()
-            .as_bytes()
-            .to_vec();
-        key.push(0xff);
-        key.extend_from_slice(&user_id.as_bytes());
-        key.push(0xff);
-        key.extend_from_slice(kind.as_ref().as_bytes());
-
-        self.roomusertype_roomuserdataid
-            .get(&key)?
-            .and_then(|roomuserdataid| {
-                self.roomuserdataid_accountdata
-                    .get(&roomuserdataid)
-                    .transpose()
-            })
-            .transpose()?
-            .map(|data| {
-                serde_json::from_slice(&data)
-                    .map_err(|_| Error::bad_database("could not deserialize"))
+        self.find_event(room_id, user_id, &kind)?
+            .map(|(_, v)| {
+                serde_json::from_slice(&v).map_err(|_| Error::bad_database("could not deserialize"))
            })
            .transpose()
    }

    /// Returns all changes to the account data that happened after `since`.
-    #[tracing::instrument(skip(self, room_id, user_id, since))]
+    #[tracing::instrument(skip(self))]
    pub fn changes_since(
        &self,
        room_id: Option<&RoomId>,
@@ -150,4 +121,36 @@ impl AccountData {

        Ok(userdata)
    }
+
+    fn find_event(
+        &self,
+        room_id: Option<&RoomId>,
+        user_id: &UserId,
+        kind: &EventType,
+    ) -> Result<Option<(Box<[u8]>, Box<[u8]>)>> {
+        let mut prefix = room_id
+            .map(|r| r.to_string())
+            .unwrap_or_default()
+            .as_bytes()
+            .to_vec();
+        prefix.push(0xff);
+        prefix.extend_from_slice(&user_id.as_bytes());
+        prefix.push(0xff);
+
+        let mut last_possible_key = prefix.clone();
+        last_possible_key.extend_from_slice(&u64::MAX.to_be_bytes());
+
+        let kind = kind.clone();
+
+        Ok(self
+            .roomuserdataid_accountdata
+            .iter_from(&last_possible_key, true)
+            .take_while(move |(k, _)| k.starts_with(&prefix))
+            .find(move |(k, _)| {
+                k.rsplit(|&b| b == 0xff)
+                    .next()
+                    .map(|current_event_type| current_event_type == kind.as_ref().as_bytes())
+                    .unwrap_or(false)
+            }))
+    }
 }
@@ -4,13 +4,12 @@ use std::{
 };

 use crate::{pdu::PduBuilder, Database};
+use log::warn;
 use rocket::futures::{channel::mpsc, stream::StreamExt};
 use ruma::{
    events::{room::message, EventType},
    UserId,
 };
-use tokio::sync::{MutexGuard, RwLock, RwLockReadGuard};
-use tracing::warn;

 pub enum AdminCommand {
    RegisterAppservice(serde_yaml::Value),
@@ -26,97 +25,73 @@ pub struct Admin {
 impl Admin {
    pub fn start_handler(
        &self,
-        db: Arc<RwLock<Database>>,
+        db: Arc<Database>,
        mut receiver: mpsc::UnboundedReceiver<AdminCommand>,
    ) {
        tokio::spawn(async move {
            // TODO: Use futures when we have long admin commands
            //let mut futures = FuturesUnordered::new();

-            let guard = db.read().await;
+            let conduit_user = UserId::try_from(format!("@conduit:{}", db.globals.server_name()))
+                .expect("@conduit:server_name is valid");

-            let conduit_user =
-                UserId::try_from(format!("@conduit:{}", guard.globals.server_name()))
-                    .expect("@conduit:server_name is valid");
-
-            let conduit_room = guard
+            let conduit_room = db
                .rooms
                .id_from_alias(
-                    &format!("#admins:{}", guard.globals.server_name())
+                    &format!("#admins:{}", db.globals.server_name())
                        .try_into()
                        .expect("#admins:server_name is a valid room alias"),
                )
                .unwrap();

-            let conduit_room = match conduit_room {
-                None => {
-                    warn!("Conduit instance does not have an #admins room. Logging to that room will not work. Restart Conduit after creating a user to fix this.");
-                    return;
+            if conduit_room.is_none() {
+                warn!("Conduit instance does not have an #admins room. Logging to that room will not work. Restart Conduit after creating a user to fix this.");
+            }
+
+            let send_message = |message: message::MessageEventContent| {
+                if let Some(conduit_room) = &conduit_room {
+                    db.rooms
+                        .build_and_append_pdu(
+                            PduBuilder {
+                                event_type: EventType::RoomMessage,
+                                content: serde_json::to_value(message)
+                                    .expect("event is valid, we just created it"),
+                                unsigned: None,
+                                state_key: None,
+                                redacts: None,
+                            },
+                            &conduit_user,
+                            &conduit_room,
+                            &db,
+                        )
+                        .unwrap();
                }
-                Some(r) => r,
-            };
-
-            drop(guard);
-
-            let send_message = |message: message::MessageEventContent,
-                                guard: RwLockReadGuard<'_, Database>,
-                                mutex_lock: &MutexGuard<'_, ()>| {
-                guard
-                    .rooms
-                    .build_and_append_pdu(
-                        PduBuilder {
-                            event_type: EventType::RoomMessage,
-                            content: serde_json::to_value(message)
-                                .expect("event is valid, we just created it"),
-                            unsigned: None,
-                            state_key: None,
-                            redacts: None,
-                        },
-                        &conduit_user,
-                        &conduit_room,
-                        &guard,
-                        mutex_lock,
-                    )
-                    .unwrap();
            };

            loop {
                tokio::select! {
                    Some(event) = receiver.next() => {
-                        let guard = db.read().await;
-                        let mutex_state = Arc::clone(
-                            guard.globals
-                                .roomid_mutex_state
-                                .write()
-                                .unwrap()
-                                .entry(conduit_room.clone())
-                                .or_default(),
-                        );
-                        let state_lock = mutex_state.lock().await;
-
                        match event {
                            AdminCommand::RegisterAppservice(yaml) => {
-                                guard.appservice.register_appservice(yaml).unwrap(); // TODO handle error
+                                db.appservice.register_appservice(yaml).unwrap(); // TODO handle error
                            }
                            AdminCommand::ListAppservices => {
-                                if let Ok(appservices) = guard.appservice.iter_ids().map(|ids| ids.collect::<Vec<_>>()) {
+                                if let Ok(appservices) = db.appservice.iter_ids().map(|ids| ids.collect::<Vec<_>>()) {
                                    let count = appservices.len();
                                    let output = format!(
                                        "Appservices ({}): {}",
                                        count,
                                        appservices.into_iter().filter_map(|r| r.ok()).collect::<Vec<_>>().join(", ")
                                    );
-                                    send_message(message::MessageEventContent::text_plain(output), guard, &state_lock);
+                                    send_message(message::MessageEventContent::text_plain(output));
                                } else {
-                                    send_message(message::MessageEventContent::text_plain("Failed to get appservices."), guard, &state_lock);
+                                    send_message(message::MessageEventContent::text_plain("Failed to get appservices."));
                                }
                            }
                            AdminCommand::SendMessage(message) => {
-                                send_message(message, guard, &state_lock);
+                                send_message(message);
                            }
                        }
-
-                        drop(state_lock);
                    }
                }
            }
@@ -49,23 +49,22 @@ impl Appservice {
            )
    }

-    pub fn iter_ids(&self) -> Result<impl Iterator<Item = Result<String>> + '_> {
+    pub fn iter_ids(&self) -> Result<impl Iterator<Item = Result<String>> + Send + Sync + '_> {
        Ok(self.id_appserviceregistrations.iter().map(|(id, _)| {
            utils::string_from_bytes(&id)
                .map_err(|_| Error::bad_database("Invalid id bytes in id_appserviceregistrations."))
        }))
    }

-    pub fn all(&self) -> Result<Vec<(String, serde_yaml::Value)>> {
-        self.iter_ids()?
-            .filter_map(|id| id.ok())
-            .map(move |id| {
-                Ok((
-                    id.clone(),
-                    self.get_registration(&id)?
-                        .expect("iter_ids only returns appservices that exist"),
-                ))
-            })
-            .collect()
+    pub fn iter_all(
+        &self,
+    ) -> Result<impl Iterator<Item = Result<(String, serde_yaml::Value)>> + '_ + Send + Sync> {
+        Ok(self.iter_ids()?.filter_map(|id| id.ok()).map(move |id| {
+            Ok((
+                id.clone(),
+                self.get_registration(&id)?
+                    .expect("iter_ids only returns appservices that exist"),
+            ))
+        }))
    }
 }
@@ -1,83 +1,82 @@
-use crate::{database::Config, server_server::FedDest, utils, ConduitResult, Error, Result};
-use ruma::{
-    api::{
+use crate::{database::Config, utils, ConduitResult, Error, Result};
+use log::{error, info};
+use ruma::{DeviceId, EventId, MilliSecondsSinceUnixEpoch, RoomId, ServerName, ServerSigningKeyId, UserId, api::{
        client::r0::sync::sync_events,
        federation::discovery::{ServerSigningKeys, VerifyKey},
-    },
-    DeviceId, EventId, MilliSecondsSinceUnixEpoch, RoomId, ServerName, ServerSigningKeyId, UserId,
-};
+    }};
+use rustls::{ServerCertVerifier, WebPKIVerifier};
 use std::{
    collections::{BTreeMap, HashMap},
    fs,
-    future::Future,
-    net::IpAddr,
    path::PathBuf,
-    sync::{Arc, Mutex, RwLock},
+    sync::{Arc, RwLock},
    time::{Duration, Instant},
 };
-use tokio::sync::{broadcast, watch::Receiver, Mutex as TokioMutex, Semaphore};
-use tracing::error;
+use tokio::sync::{Mutex, Semaphore};
 use trust_dns_resolver::TokioAsyncResolver;

 use super::abstraction::Tree;

 pub const COUNTER: &[u8] = b"c";

-type WellKnownMap = HashMap<Box<ServerName>, (FedDest, String)>;
-type TlsNameMap = HashMap<String, Vec<IpAddr>>;
+type WellKnownMap = HashMap<Box<ServerName>, (String, String)>;
+type TlsNameMap = HashMap<String, webpki::DNSName>;
 type RateLimitState = (Instant, u32); // Time if last failed try, number of failed tries
-type SyncHandle = (
-    Option<String>,                                         // since
-    Receiver<Option<ConduitResult<sync_events::Response>>>, // rx
-);
-
 pub struct Globals {
    pub actual_destination_cache: Arc<RwLock<WellKnownMap>>, // actual_destination, host
    pub tls_name_override: Arc<RwLock<TlsNameMap>>,
    pub(super) globals: Arc<dyn Tree>,
    config: Config,
    keypair: Arc<ruma::signatures::Ed25519KeyPair>,
+    reqwest_client: reqwest::Client,
    dns_resolver: TokioAsyncResolver,
    jwt_decoding_key: Option<jsonwebtoken::DecodingKey<'static>>,
    pub(super) server_signingkeys: Arc<dyn Tree>,
-    pub bad_event_ratelimiter: Arc<RwLock<HashMap<EventId, RateLimitState>>>,
-    pub bad_signature_ratelimiter: Arc<RwLock<HashMap<Vec<String>, RateLimitState>>>,
-    pub servername_ratelimiter: Arc<RwLock<HashMap<Box<ServerName>, Arc<Semaphore>>>>,
-    pub sync_receivers: RwLock<HashMap<(UserId, Box<DeviceId>), SyncHandle>>,
-    pub roomid_mutex_insert: RwLock<HashMap<RoomId, Arc<Mutex<()>>>>,
-    pub roomid_mutex_state: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>,
-    pub roomid_mutex_federation: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>, // this lock will be held longer
-    pub rotate: RotationHandler,
+    pub bad_event_ratelimiter: Arc<RwLock<BTreeMap<EventId, RateLimitState>>>,
+    pub bad_signature_ratelimiter: Arc<RwLock<BTreeMap<Vec<String>, RateLimitState>>>,
+    pub servername_ratelimiter: Arc<RwLock<BTreeMap<Box<ServerName>, Arc<Semaphore>>>>,
+    pub roomid_mutex: RwLock<BTreeMap<RoomId, Arc<Mutex<()>>>>,
+    pub sync_receivers: RwLock<
+        BTreeMap<
+            (UserId, Box<DeviceId>),
+            (
+                Option<String>,
+                tokio::sync::watch::Receiver<Option<ConduitResult<sync_events::Response>>>,
+            ), // since, rx
+        >,
+    >,
 }

-/// Handles "rotation" of long-polling requests. "Rotation" in this context is similar to "rotation" of log files and the like.
-///
-/// This is utilized to have sync workers return early and release read locks on the database.
-pub struct RotationHandler(broadcast::Sender<()>, broadcast::Receiver<()>);
+struct MatrixServerVerifier {
+    inner: WebPKIVerifier,
+    tls_name_override: Arc<RwLock<TlsNameMap>>,
+}

-impl RotationHandler {
-    pub fn new() -> Self {
-        let (s, r) = broadcast::channel::<()>(1);
-
-        Self(s, r)
-    }
-
-    pub fn watch(&self) -> impl Future<Output = ()> {
-        let mut r = self.0.subscribe();
-
-        async move {
-            let _ = r.recv().await;
+impl ServerCertVerifier for MatrixServerVerifier {
+    fn verify_server_cert(
+        &self,
+        roots: &rustls::RootCertStore,
+        presented_certs: &[rustls::Certificate],
+        dns_name: webpki::DNSNameRef<'_>,
+        ocsp_response: &[u8],
+    ) -> std::result::Result<rustls::ServerCertVerified, rustls::TLSError> {
+        if let Some(override_name) = self.tls_name_override.read().unwrap().get(dns_name.into()) {
+            let result = self.inner.verify_server_cert(
+                roots,
+                presented_certs,
+                override_name.as_ref(),
+                ocsp_response,
+            );
+            if result.is_ok() {
+                return result;
+            }
+            info!(
+                "Server {:?} is non-compliant, retrying TLS verification with original name",
+                dns_name
+            );
        }
-    }
-
-    pub fn fire(&self) {
-        let _ = self.0.send(());
-    }
-}
-
-impl Default for RotationHandler {
-    fn default() -> Self {
-        Self::new()
+        self.inner
+            .verify_server_cert(roots, presented_certs, dns_name, ocsp_response)
    }
 }

@@ -127,6 +126,22 @@ impl Globals {
        };

        let tls_name_override = Arc::new(RwLock::new(TlsNameMap::new()));
+        let verifier = Arc::new(MatrixServerVerifier {
+            inner: WebPKIVerifier::new(),
+            tls_name_override: tls_name_override.clone(),
+        });
+        let mut tlsconfig = rustls::ClientConfig::new();
+        tlsconfig.dangerous().set_certificate_verifier(verifier);
+        tlsconfig.root_store =
+            rustls_native_certs::load_native_certs().expect("Error loading system certificates");
+
+        let reqwest_client = reqwest::Client::builder()
+            .connect_timeout(Duration::from_secs(30))
+            .timeout(Duration::from_secs(60 * 3))
+            .pool_max_idle_per_host(1)
+            .use_preconfigured_tls(tlsconfig)
+            .build()
+            .unwrap();

        let jwt_decoding_key = config
            .jwt_secret
@@ -137,6 +152,7 @@ impl Globals {
            globals,
            config,
            keypair: Arc::new(keypair),
+            reqwest_client,
            dns_resolver: TokioAsyncResolver::tokio_from_system_conf().map_err(|_| {
                Error::bad_config("Failed to set up trust dns resolver with system config.")
            })?,
@@ -144,14 +160,11 @@ impl Globals {
            tls_name_override,
            server_signingkeys,
            jwt_decoding_key,
-            bad_event_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
-            bad_signature_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
-            servername_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
-            roomid_mutex_state: RwLock::new(HashMap::new()),
-            roomid_mutex_insert: RwLock::new(HashMap::new()),
-            roomid_mutex_federation: RwLock::new(HashMap::new()),
-            sync_receivers: RwLock::new(HashMap::new()),
-            rotate: RotationHandler::new(),
+            bad_event_ratelimiter: Arc::new(RwLock::new(BTreeMap::new())),
+            bad_signature_ratelimiter: Arc::new(RwLock::new(BTreeMap::new())),
+            servername_ratelimiter: Arc::new(RwLock::new(BTreeMap::new())),
+            roomid_mutex: RwLock::new(BTreeMap::new()),
+            sync_receivers: RwLock::new(BTreeMap::new()),
        };

        fs::create_dir_all(s.get_media_folder())?;
@@ -165,26 +178,15 @@ impl Globals {
    }

    /// Returns a reqwest client which can be used to send requests.
-    pub fn reqwest_client(&self) -> Result<reqwest::ClientBuilder> {
-        let mut reqwest_client_builder = reqwest::Client::builder()
-            .connect_timeout(Duration::from_secs(30))
-            .timeout(Duration::from_secs(60 * 3))
-            .pool_max_idle_per_host(1);
-        //.use_preconfigured_tls(tlsconfig);
-        if let Some(proxy) = self.config.proxy.to_proxy()? {
-            reqwest_client_builder = reqwest_client_builder.proxy(proxy);
-        }
-
-        Ok(reqwest_client_builder)
+    pub fn reqwest_client(&self) -> &reqwest::Client {
+        &self.reqwest_client
    }

-    #[tracing::instrument(skip(self))]
    pub fn next_count(&self) -> Result<u64> {
        utils::u64_from_bytes(&self.globals.increment(COUNTER)?)
            .map_err(|_| Error::bad_database("Count has invalid bytes."))
    }

-    #[tracing::instrument(skip(self))]
    pub fn current_count(&self) -> Result<u64> {
        self.globals.get(COUNTER)?.map_or(Ok(0_u64), |bytes| {
            utils::u64_from_bytes(&bytes)
@@ -54,7 +54,6 @@ impl Media {
    }

    /// Uploads or replaces a file thumbnail.
-    #[allow(clippy::too_many_arguments)]
    pub async fn upload_thumbnail(
        &self,
        mxc: String,
@@ -101,8 +100,8 @@ impl Media {
        prefix.extend_from_slice(&0_u32.to_be_bytes()); // Height = 0 if it's not a thumbnail
        prefix.push(0xff);

-        let first = self.mediaid_file.scan_prefix(prefix).next();
-        if let Some((key, _)) = first {
+        let mut iter = self.mediaid_file.scan_prefix(prefix);
+        if let Some((key, _)) = iter.next() {
            let path = globals.get_media_file(&key);
            let mut file = Vec::new();
            File::open(path).await?.read_to_end(&mut file).await?;
@@ -190,9 +189,7 @@ impl Media {
        original_prefix.extend_from_slice(&0_u32.to_be_bytes()); // Height = 0 if it's not a thumbnail
        original_prefix.push(0xff);

-        let first_thumbnailprefix = self.mediaid_file.scan_prefix(thumbnail_prefix).next();
-        let first_originalprefix = self.mediaid_file.scan_prefix(original_prefix).next();
-        if let Some((key, _)) = first_thumbnailprefix {
+        if let Some((key, _)) = self.mediaid_file.scan_prefix(thumbnail_prefix).next() {
            // Using saved thumbnail
            let path = globals.get_media_file(&key);
            let mut file = Vec::new();
@@ -227,7 +224,7 @@ impl Media {
                content_type,
                file: file.to_vec(),
            }))
-        } else if let Some((key, _)) = first_originalprefix {
+        } else if let Some((key, _)) = self.mediaid_file.scan_prefix(original_prefix).next() {
            // Generate a thumbnail
            let path = globals.get_media_file(&key);
            let mut file = Vec::new();
@@ -1,146 +0,0 @@
-use reqwest::{Proxy, Url};
-use serde::Deserialize;
-
-use crate::Result;
-
-/// ## Examples:
-/// - No proxy (default):
-/// ```toml
-/// proxy ="none"
-/// ```
-/// - Global proxy
-/// ```toml
-/// [proxy]
-/// global = { url = "socks5h://localhost:9050" }
-/// ```
-/// - Proxy some domains
-/// ```toml
-/// [proxy]
-/// [[proxy.by_domain]]
-/// url = "socks5h://localhost:9050"
-/// include = ["*.onion", "matrix.myspecial.onion"]
-/// exclude = ["*.myspecial.onion"]
-/// ```
-/// ## Include vs. Exclude
-/// If include is an empty list, it is assumed to be `["*"]`.
-///
-/// If a domain matches both the exclude and include list, the proxy will only be used if it was
-/// included because of a more specific rule than it was excluded. In the above example, the proxy
-/// would be used for `ordinary.onion`, `matrix.myspecial.onion`, but not `hello.myspecial.onion`.
-#[derive(Clone, Debug, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum ProxyConfig {
-    None,
-    Global {
-        #[serde(deserialize_with = "crate::utils::deserialize_from_str")]
-        url: Url,
-    },
-    ByDomain(Vec<PartialProxyConfig>),
-}
-impl ProxyConfig {
-    pub fn to_proxy(&self) -> Result<Option<Proxy>> {
-        Ok(match self.clone() {
-            ProxyConfig::None => None,
-            ProxyConfig::Global { url } => Some(Proxy::all(url)?),
-            ProxyConfig::ByDomain(proxies) => Some(Proxy::custom(move |url| {
-                proxies.iter().find_map(|proxy| proxy.for_url(url)).cloned() // first matching proxy
-            })),
-        })
-    }
-}
-impl Default for ProxyConfig {
-    fn default() -> Self {
-        ProxyConfig::None
-    }
-}
-
-#[derive(Clone, Debug, Deserialize)]
-pub struct PartialProxyConfig {
-    #[serde(deserialize_with = "crate::utils::deserialize_from_str")]
-    url: Url,
-    #[serde(default)]
-    include: Vec<WildCardedDomain>,
-    #[serde(default)]
-    exclude: Vec<WildCardedDomain>,
-}
-impl PartialProxyConfig {
-    pub fn for_url(&self, url: &Url) -> Option<&Url> {
-        let domain = url.domain()?;
-        let mut included_because = None; // most specific reason it was included
-        let mut excluded_because = None; // most specific reason it was excluded
-        if self.include.is_empty() {
-            // treat empty include list as `*`
-            included_because = Some(&WildCardedDomain::WildCard)
-        }
-        for wc_domain in &self.include {
-            if wc_domain.matches(domain) {
-                match included_because {
-                    Some(prev) if !wc_domain.more_specific_than(prev) => (),
-                    _ => included_because = Some(wc_domain),
-                }
-            }
-        }
-        for wc_domain in &self.exclude {
-            if wc_domain.matches(domain) {
-                match excluded_because {
-                    Some(prev) if !wc_domain.more_specific_than(prev) => (),
-                    _ => excluded_because = Some(wc_domain),
-                }
-            }
-        }
-        match (included_because, excluded_because) {
-            (Some(a), Some(b)) if a.more_specific_than(b) => Some(&self.url), // included for a more specific reason than excluded
-            (Some(_), None) => Some(&self.url),
-            _ => None,
-        }
-    }
-}
-
-/// A domain name, that optionally allows a * as its first subdomain.
-#[derive(Clone, Debug)]
-pub enum WildCardedDomain {
-    WildCard,
-    WildCarded(String),
-    Exact(String),
-}
-impl WildCardedDomain {
-    pub fn matches(&self, domain: &str) -> bool {
-        match self {
-            WildCardedDomain::WildCard => true,
-            WildCardedDomain::WildCarded(d) => domain.ends_with(d),
-            WildCardedDomain::Exact(d) => domain == d,
-        }
-    }
-    pub fn more_specific_than(&self, other: &Self) -> bool {
-        match (self, other) {
-            (WildCardedDomain::WildCard, WildCardedDomain::WildCard) => false,
-            (_, WildCardedDomain::WildCard) => true,
-            (WildCardedDomain::Exact(a), WildCardedDomain::WildCarded(_)) => other.matches(a),
-            (WildCardedDomain::WildCarded(a), WildCardedDomain::WildCarded(b)) => {
-                a != b && a.ends_with(b)
-            }
-            _ => false,
-        }
-    }
-}
-impl std::str::FromStr for WildCardedDomain {
-    type Err = std::convert::Infallible;
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        // maybe do some domain validation?
-        Ok(if s.starts_with("*.") {
-            WildCardedDomain::WildCarded(s[1..].to_owned())
-        } else if s == "*" {
-            WildCardedDomain::WildCarded("".to_owned())
-        } else {
-            WildCardedDomain::Exact(s.to_owned())
-        })
-    }
-}
-impl<'de> serde::de::Deserialize<'de> for WildCardedDomain {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::de::Deserializer<'de>,
-    {
-        crate::utils::deserialize_from_str(deserializer)
-    }
-}
@@ -1,5 +1,6 @@
 use crate::{Database, Error, PduEvent, Result};
 use bytes::BytesMut;
+use log::{error, info, warn};
 use ruma::{
    api::{
        client::r0::push::{get_pushers, set_pusher, PusherKind},
@@ -9,13 +10,10 @@ use ruma::{
        },
        IncomingResponse, OutgoingRequest, SendAccessToken,
    },
-    events::{room::power_levels::PowerLevelsEventContent, AnySyncRoomEvent, EventType},
-    identifiers::RoomName,
+    events::{room::power_levels::PowerLevelsEventContent, EventType},
    push::{Action, PushConditionRoomCtx, PushFormat, Ruleset, Tweak},
-    serde::Raw,
-    uint, RoomId, UInt, UserId,
+    uint, UInt, UserId,
 };
-use tracing::{error, info, warn};

 use std::{convert::TryFrom, fmt::Debug, mem, sync::Arc};

@@ -27,7 +25,6 @@ pub struct PushData {
 }

 impl PushData {
-    #[tracing::instrument(skip(self, sender, pusher))]
    pub fn set_pusher(&self, sender: &UserId, pusher: set_pusher::Pusher) -> Result<()> {
        let mut key = sender.as_bytes().to_vec();
        key.push(0xff);
@@ -50,7 +47,6 @@ impl PushData {
        Ok(())
    }

-    #[tracing::instrument(skip(self, senderkey))]
    pub fn get_pusher(&self, senderkey: &[u8]) -> Result<Option<get_pushers::Pusher>> {
        self.senderkey_pusher
            .get(senderkey)?
@@ -61,7 +57,6 @@ impl PushData {
            .transpose()
    }

-    #[tracing::instrument(skip(self, sender))]
    pub fn get_pushers(&self, sender: &UserId) -> Result<Vec<get_pushers::Pusher>> {
        let mut prefix = sender.as_bytes().to_vec();
        prefix.push(0xff);
@@ -75,11 +70,10 @@ impl PushData {
            .collect()
    }

-    #[tracing::instrument(skip(self, sender))]
    pub fn get_pusher_senderkeys<'a>(
        &'a self,
        sender: &UserId,
-    ) -> impl Iterator<Item = Vec<u8>> + 'a {
+    ) -> impl Iterator<Item = Box<[u8]>> + 'a {
        let mut prefix = sender.as_bytes().to_vec();
        prefix.push(0xff);

@@ -87,7 +81,6 @@ impl PushData {
    }
 }

-#[tracing::instrument(skip(globals, destination, request))]
 pub async fn send_request<T: OutgoingRequest>(
    globals: &crate::database::globals::Globals,
    destination: &str,
@@ -113,11 +106,7 @@ where
    //*reqwest_request.timeout_mut() = Some(Duration::from_secs(5));

    let url = reqwest_request.url().clone();
-    let response = globals
-        .reqwest_client()?
-        .build()?
-        .execute(reqwest_request)
-        .await;
+    let response = globals.reqwest_client().execute(reqwest_request).await;

    match response {
        Ok(mut response) => {
@@ -165,7 +154,6 @@ where
    }
 }

-#[tracing::instrument(skip(user, unread, pusher, ruleset, pdu, db))]
 pub async fn send_push_notice(
    user: &UserId,
    unread: UInt,
@@ -177,24 +165,7 @@ pub async fn send_push_notice(
    let mut notify = None;
    let mut tweaks = Vec::new();

-    let power_levels: PowerLevelsEventContent = db
-        .rooms
-        .room_state_get(&pdu.room_id, &EventType::RoomPowerLevels, "")?
-        .map(|ev| {
-            serde_json::from_value(ev.content.clone())
-                .map_err(|_| Error::bad_database("invalid m.room.power_levels event"))
-        })
-        .transpose()?
-        .unwrap_or_default();
-
-    for action in get_actions(
-        user,
-        &ruleset,
-        &power_levels,
-        &pdu.to_sync_room_event(),
-        &pdu.room_id,
-        db,
-    )? {
+    for action in get_actions(user, &ruleset, pdu, db)? {
        let n = match action {
            Action::DontNotify => false,
            // TODO: Implement proper support for coalesce
@@ -222,31 +193,37 @@ pub async fn send_push_notice(
    Ok(())
 }

-#[tracing::instrument(skip(user, ruleset, pdu, db))]
 pub fn get_actions<'a>(
    user: &UserId,
    ruleset: &'a Ruleset,
-    power_levels: &PowerLevelsEventContent,
-    pdu: &Raw<AnySyncRoomEvent>,
-    room_id: &RoomId,
+    pdu: &PduEvent,
    db: &Database,
 ) -> Result<&'a [Action]> {
+    let power_levels: PowerLevelsEventContent = db
+        .rooms
+        .room_state_get(&pdu.room_id, &EventType::RoomPowerLevels, "")?
+        .map(|ev| {
+            serde_json::from_value(ev.content.clone())
+                .map_err(|_| Error::bad_database("invalid m.room.power_levels event"))
+        })
+        .transpose()?
+        .unwrap_or_default();
+
    let ctx = PushConditionRoomCtx {
-        room_id: room_id.clone(),
+        room_id: pdu.room_id.clone(),
        member_count: 10_u32.into(), // TODO: get member count efficiently
        user_display_name: db
            .users
            .displayname(&user)?
            .unwrap_or_else(|| user.localpart().to_owned()),
-        users_power_levels: power_levels.users.clone(),
+        users_power_levels: power_levels.users,
        default_power_level: power_levels.users_default,
-        notification_power_levels: power_levels.notifications.clone(),
+        notification_power_levels: power_levels.notifications,
    };

-    Ok(ruleset.get_actions(pdu, &ctx))
+    Ok(ruleset.get_actions(&pdu.to_sync_room_event(), &ctx))
 }

-#[tracing::instrument(skip(unread, pusher, tweaks, event, db))]
 async fn send_notice(
    unread: UInt,
    pusher: &get_pushers::Pusher,
@@ -322,9 +299,7 @@ async fn send_notice(
            .rooms
            .room_state_get(&event.room_id, &EventType::RoomName, "")?
            .map(|pdu| match pdu.content.get("name") {
-                Some(serde_json::Value::String(s)) => {
-                    Some(Box::<RoomName>::try_from(&**s).expect("room name is valid"))
-                }
+                Some(serde_json::Value::String(s)) => Some(s.to_string()),
                _ => None,
            })
            .flatten();
@@ -116,7 +116,6 @@ impl RoomEdus {
    }

    /// Sets a private read marker at `count`.
-    #[tracing::instrument(skip(self, globals))]
    pub fn private_read_set(
        &self,
        room_id: &RoomId,
@@ -422,7 +421,7 @@ impl RoomEdus {
    }

    /// Sets all users to offline who have been quiet for too long.
-    fn presence_maintain(
+    pub fn presence_maintain(
        &self,
        rooms: &super::Rooms,
        globals: &super::super::globals::Globals,
@@ -497,7 +496,7 @@ impl RoomEdus {
        rooms: &super::Rooms,
        globals: &super::super::globals::Globals,
    ) -> Result<HashMap<UserId, PresenceEvent>> {
-        //self.presence_maintain(rooms, globals)?;
+        self.presence_maintain(rooms, globals)?;

        let mut prefix = room_id.as_bytes().to_vec();
        prefix.push(0xff);
@@ -1,5 +1,5 @@
 use std::{
-    collections::{BTreeMap, HashMap, HashSet},
+    collections::{BTreeMap, HashMap},
    convert::{TryFrom, TryInto},
    fmt::Debug,
    sync::Arc,
@@ -10,6 +10,7 @@ use crate::{
    appservice_server, database::pusher, server_server, utils, Database, Error, PduEvent, Result,
 };
 use federation::transactions::send_transaction_message;
+use log::{error, warn};
 use ring::digest;
 use rocket::futures::{
    channel::mpsc,
@@ -20,23 +21,16 @@ use ruma::{
        appservice,
        federation::{
            self,
-            transactions::edu::{
-                DeviceListUpdateContent, Edu, ReceiptContent, ReceiptData, ReceiptMap,
-            },
+            transactions::edu::{Edu, ReceiptContent, ReceiptData, ReceiptMap},
        },
        OutgoingRequest,
    },
-    device_id,
    events::{push_rules, AnySyncEphemeralRoomEvent, EventType},
    push,
    receipt::ReceiptType,
-    uint, MilliSecondsSinceUnixEpoch, ServerName, UInt, UserId,
+    MilliSecondsSinceUnixEpoch, ServerName, UInt, UserId,
 };
-use tokio::{
-    select,
-    sync::{RwLock, Semaphore},
-};
-use tracing::{error, warn};
+use tokio::{select, sync::Semaphore};

 use super::abstraction::Tree;

@@ -48,7 +42,6 @@ pub enum OutgoingKind {
 }

 impl OutgoingKind {
-    #[tracing::instrument(skip(self))]
    pub fn get_prefix(&self) -> Vec<u8> {
        let mut prefix = match self {
            OutgoingKind::Appservice(server) => {
@@ -84,10 +77,10 @@ pub enum SendingEventType {
 pub struct Sending {
    /// The state for a given state hash.
    pub(super) servername_educount: Arc<dyn Tree>, // EduCount: Count of last EDU sync
-    pub(super) servernameevent_data: Arc<dyn Tree>, // ServernamEvent = (+ / $)SenderKey / ServerName / UserId + PduId / Id (for edus), Data = EDU content
-    pub(super) servercurrentevent_data: Arc<dyn Tree>, // ServerCurrentEvents = (+ / $)ServerName / UserId + PduId / Id (for edus), Data = EDU content
+    pub(super) servernamepduids: Arc<dyn Tree>, // ServernamePduId = (+ / $)SenderKey / ServerName / UserId + PduId
+    pub(super) servercurrentevents: Arc<dyn Tree>, // ServerCurrentEvents = (+ / $)ServerName / UserId + PduId / (*)EduEvent
    pub(super) maximum_requests: Arc<Semaphore>,
-    pub sender: mpsc::UnboundedSender<(Vec<u8>, Vec<u8>)>,
+    pub sender: mpsc::UnboundedSender<Vec<u8>>,
 }

 enum TransactionStatus {
@@ -97,11 +90,7 @@ enum TransactionStatus {
 }

 impl Sending {
-    pub fn start_handler(
-        &self,
-        db: Arc<RwLock<Database>>,
-        mut receiver: mpsc::UnboundedReceiver<(Vec<u8>, Vec<u8>)>,
-    ) {
+    pub fn start_handler(&self, db: Arc<Database>, mut receiver: mpsc::UnboundedReceiver<Vec<u8>>) {
        tokio::spawn(async move {
            let mut futures = FuturesUnordered::new();

@@ -109,18 +98,15 @@ impl Sending {

            // Retry requests we could not finish yet
            let mut initial_transactions = HashMap::<OutgoingKind, Vec<SendingEventType>>::new();
-
-            let guard = db.read().await;
-
-            for (key, outgoing_kind, event) in guard
-                .sending
-                .servercurrentevent_data
-                .iter()
-                .filter_map(|(key, v)| {
-                    Self::parse_servercurrentevent(&key, v)
-                        .ok()
-                        .map(|(k, e)| (key, k, e))
-                })
+            for (key, outgoing_kind, event) in
+                db.sending
+                    .servercurrentevents
+                    .iter()
+                    .filter_map(|(key, _)| {
+                        Self::parse_servercurrentevent(&key)
+                            .ok()
+                            .map(|(k, e)| (key, k, e))
+                    })
            {
                let entry = initial_transactions
                    .entry(outgoing_kind.clone())
@@ -131,23 +117,17 @@ impl Sending {
                        "Dropping some current events: {:?} {:?} {:?}",
                        key, outgoing_kind, event
                    );
-                    guard.sending.servercurrentevent_data.remove(&key).unwrap();
+                    db.sending.servercurrentevents.remove(&key).unwrap();
                    continue;
                }

                entry.push(event);
            }

-            drop(guard);
-
            for (outgoing_kind, events) in initial_transactions {
                current_transaction_status
                    .insert(outgoing_kind.get_prefix(), TransactionStatus::Running);
-                futures.push(Self::handle_events(
-                    outgoing_kind.clone(),
-                    events,
-                    Arc::clone(&db),
-                ));
+                futures.push(Self::handle_events(outgoing_kind.clone(), events, &db));
            }

            loop {
@@ -155,20 +135,18 @@ impl Sending {
                    Some(response) = futures.next() => {
                        match response {
                            Ok(outgoing_kind) => {
-                                let guard = db.read().await;
-
                                let prefix = outgoing_kind.get_prefix();
-                                for (key, _) in guard.sending.servercurrentevent_data
+                                for (key, _) in db.sending.servercurrentevents
                                    .scan_prefix(prefix.clone())
                                {
-                                    guard.sending.servercurrentevent_data.remove(&key).unwrap();
+                                    db.sending.servercurrentevents.remove(&key).unwrap();
                                }

                                // Find events that have been added since starting the last request
-                                let new_events = guard.sending.servernameevent_data
+                                let new_events = db.sending.servernamepduids
                                    .scan_prefix(prefix.clone())
-                                    .filter_map(|(k, v)| {
-                                        Self::parse_servercurrentevent(&k, v).ok().map(|ev| (ev, k))
+                                    .map(|(k, _)| {
+                                        SendingEventType::Pdu(k[prefix.len()..].to_vec())
                                    })
                                    .take(30)
                                    .collect::<Vec<_>>();
@@ -177,19 +155,23 @@ impl Sending {

                                if !new_events.is_empty() {
                                    // Insert pdus we found
-                                    for (e, key) in &new_events {
-                                        let value = if let SendingEventType::Edu(value) = &e.1 { &**value } else { &[] };
-                                        guard.sending.servercurrentevent_data.insert(&key, value).unwrap();
-                                        guard.sending.servernameevent_data.remove(&key).unwrap();
+                                    for event in &new_events {
+                                        let mut current_key = prefix.clone();
+                                        match event {
+                                            SendingEventType::Pdu(b) |
+                                            SendingEventType::Edu(b) => {
+                                                current_key.extend_from_slice(&b);
+                                                db.sending.servercurrentevents.insert(&current_key, &[]).unwrap();
+                                                db.sending.servernamepduids.remove(&current_key).unwrap();
+                                             }
+                                        }
                                    }

-                                    drop(guard);
-
                                    futures.push(
                                        Self::handle_events(
                                            outgoing_kind.clone(),
-                                            new_events.into_iter().map(|(event, _)| event.1).collect(),
-                                            Arc::clone(&db),
+                                            new_events,
+                                            &db,
                                        )
                                    );
                                } else {
@@ -208,17 +190,15 @@ impl Sending {
                            }
                        };
                    },
-                    Some((key, value)) = receiver.next() => {
-                        if let Ok((outgoing_kind, event)) = Self::parse_servercurrentevent(&key, value) {
-                            let guard = db.read().await;
-
+                    Some(key) = receiver.next() => {
+                        if let Ok((outgoing_kind, event)) = Self::parse_servercurrentevent(&key) {
                            if let Ok(Some(events)) = Self::select_events(
                                &outgoing_kind,
                                vec![(event, key)],
                                &mut current_transaction_status,
-                                &guard
+                                &db
                            ) {
-                                futures.push(Self::handle_events(outgoing_kind, events, Arc::clone(&db)));
+                                futures.push(Self::handle_events(outgoing_kind, events, &db));
                            }
                        }
                    }
@@ -227,7 +207,6 @@ impl Sending {
        });
    }

-    #[tracing::instrument(skip(outgoing_kind, new_events, current_transaction_status, db))]
    fn select_events(
        outgoing_kind: &OutgoingKind,
        new_events: Vec<(SendingEventType, Vec<u8>)>, // Events we want to send: event and full key
@@ -270,33 +249,25 @@ impl Sending {

        if retry {
            // We retry the previous transaction
-            for (key, value) in db.sending.servercurrentevent_data.scan_prefix(prefix) {
-                if let Ok((_, e)) = Self::parse_servercurrentevent(&key, value) {
+            for (key, _) in db.sending.servercurrentevents.scan_prefix(prefix) {
+                if let Ok((_, e)) = Self::parse_servercurrentevent(&key) {
                    events.push(e);
                }
            }
        } else {
            for (e, full_key) in new_events {
-                let value = if let SendingEventType::Edu(value) = &e {
-                    &**value
-                } else {
-                    &[][..]
-                };
-                db.sending
-                    .servercurrentevent_data
-                    .insert(&full_key, value)?;
+                db.sending.servercurrentevents.insert(&full_key, &[])?;

                // If it was a PDU we have to unqueue it
                // TODO: don't try to unqueue EDUs
-                db.sending.servernameevent_data.remove(&full_key)?;
+                db.sending.servernamepduids.remove(&full_key)?;

                events.push(e);
            }

            if let OutgoingKind::Normal(server_name) = outgoing_kind {
                if let Ok((select_edus, last_count)) = Self::select_edus(db, server_name) {
-                    events.extend(select_edus.into_iter().map(SendingEventType::Edu));
-
+                    events.extend_from_slice(&select_edus);
                    db.sending
                        .servername_educount
                        .insert(server_name.as_bytes(), &last_count.to_be_bytes())?;
@@ -307,8 +278,7 @@ impl Sending {
        Ok(Some(events))
    }

-    #[tracing::instrument(skip(db, server))]
-    pub fn select_edus(db: &Database, server: &ServerName) -> Result<(Vec<Vec<u8>>, u64)> {
+    pub fn select_edus(db: &Database, server: &ServerName) -> Result<(Vec<SendingEventType>, u64)> {
        // u64: count of last edu
        let since = db
            .sending
@@ -320,19 +290,8 @@ impl Sending {
            })?;
        let mut events = Vec::new();
        let mut max_edu_count = since;
-        let mut device_list_changes = HashSet::new();
-
        'outer: for room_id in db.rooms.server_rooms(server) {
            let room_id = room_id?;
-            // Look for device list updates in this room
-            device_list_changes.extend(
-                db.users
-                    .keys_changed(&room_id.to_string(), since, None)
-                    .filter_map(|r| r.ok())
-                    .filter(|user_id| user_id.server_name() == db.globals.server_name()),
-            );
-
-            // Look for read receipts in this room
            for r in db.rooms.edus.readreceipts_since(&room_id, since) {
                let (user_id, count, read_receipt) = r?;

@@ -384,7 +343,9 @@ impl Sending {
                    }
                };

-                events.push(serde_json::to_vec(&federation_event).expect("json can be serialized"));
+                events.push(SendingEventType::Edu(
+                    serde_json::to_vec(&federation_event).expect("json can be serialized"),
+                ));

                if events.len() >= 20 {
                    break 'outer;
@@ -392,60 +353,28 @@ impl Sending {
            }
        }

-        for user_id in device_list_changes {
-            // Empty prev id forces synapse to resync: https://github.com/matrix-org/synapse/blob/98aec1cc9da2bd6b8e34ffb282c85abf9b8b42ca/synapse/handlers/device.py#L767
-            // Because synapse resyncs, we can just insert dummy data
-            let edu = Edu::DeviceListUpdate(DeviceListUpdateContent {
-                user_id,
-                device_id: device_id!("dummy"),
-                device_display_name: "Dummy".to_owned(),
-                stream_id: uint!(1),
-                prev_id: Vec::new(),
-                deleted: None,
-                keys: None,
-            });
-
-            events.push(serde_json::to_vec(&edu).expect("json can be serialized"));
-        }
-
        Ok((events, max_edu_count))
    }

-    #[tracing::instrument(skip(self, pdu_id, senderkey))]
-    pub fn send_push_pdu(&self, pdu_id: &[u8], senderkey: Vec<u8>) -> Result<()> {
+    #[tracing::instrument(skip(self))]
+    pub fn send_push_pdu(&self, pdu_id: &[u8], senderkey: Box<[u8]>) -> Result<()> {
        let mut key = b"$".to_vec();
        key.extend_from_slice(&senderkey);
        key.push(0xff);
        key.extend_from_slice(pdu_id);
-        self.servernameevent_data.insert(&key, &[])?;
-        self.sender.unbounded_send((key, vec![])).unwrap();
+        self.servernamepduids.insert(&key, b"")?;
+        self.sender.unbounded_send(key).unwrap();

        Ok(())
    }

-    #[tracing::instrument(skip(self, server, pdu_id))]
+    #[tracing::instrument(skip(self))]
    pub fn send_pdu(&self, server: &ServerName, pdu_id: &[u8]) -> Result<()> {
        let mut key = server.as_bytes().to_vec();
        key.push(0xff);
        key.extend_from_slice(pdu_id);
-        self.servernameevent_data.insert(&key, &[])?;
-        self.sender.unbounded_send((key, vec![])).unwrap();
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, server, serialized))]
-    pub fn send_reliable_edu(
-        &self,
-        server: &ServerName,
-        serialized: Vec<u8>,
-        id: u64,
-    ) -> Result<()> {
-        let mut key = server.as_bytes().to_vec();
-        key.push(0xff);
-        key.extend_from_slice(&id.to_be_bytes());
-        self.servernameevent_data.insert(&key, &serialized)?;
-        self.sender.unbounded_send((key, serialized)).unwrap();
+        self.servernamepduids.insert(&key, b"")?;
+        self.sender.unbounded_send(key).unwrap();

        Ok(())
    }
@@ -456,13 +385,13 @@ impl Sending {
        key.extend_from_slice(appservice_id.as_bytes());
        key.push(0xff);
        key.extend_from_slice(pdu_id);
-        self.servernameevent_data.insert(&key, &[])?;
-        self.sender.unbounded_send((key, vec![])).unwrap();
+        self.servernamepduids.insert(&key, b"")?;
+        self.sender.unbounded_send(key).unwrap();

        Ok(())
    }

-    #[tracing::instrument(skip(keys))]
+    #[tracing::instrument]
    fn calculate_hash(keys: &[&[u8]]) -> Vec<u8> {
        // We only hash the pdu's event ids, not the whole pdu
        let bytes = keys.join(&0xff);
@@ -470,14 +399,12 @@ impl Sending {
        hash.as_ref().to_owned()
    }

-    #[tracing::instrument(skip(db, events, kind))]
+    #[tracing::instrument(skip(db))]
    async fn handle_events(
        kind: OutgoingKind,
        events: Vec<SendingEventType>,
-        db: Arc<RwLock<Database>>,
+        db: &Database,
    ) -> std::result::Result<OutgoingKind, (OutgoingKind, Error)> {
-        let db = db.read().await;
-
        match &kind {
            OutgoingKind::Appservice(server) => {
                let mut pdu_jsons = Vec::new();
@@ -492,7 +419,7 @@ impl Sending {
                                    (
                                        kind.clone(),
                                        Error::bad_database(
-                                            "[Appservice] Event in servernameevent_data not found in db.",
+                                            "[Appservice] Event in servernamepduids not found in db.",
                                        ),
                                    )
                                })?
@@ -549,7 +476,7 @@ impl Sending {
                                        (
                                            kind.clone(),
                                            Error::bad_database(
-                                                "[Push] Event in servernamevent_datas not found in db.",
+                                                "[Push] Event in servernamepduids not found in db.",
                                            ),
                                        )
                                    })?,
@@ -616,7 +543,7 @@ impl Sending {
                        &pusher,
                        rules_for_user,
                        &pdu,
-                        &db,
+                        db,
                    )
                    .await
                    .map(|_response| kind.clone())
@@ -634,25 +561,29 @@ impl Sending {
                    match event {
                        SendingEventType::Pdu(pdu_id) => {
                            // TODO: check room version and remove event_id if needed
-                            let raw = PduEvent::convert_to_outgoing_federation_event(
-                                db.rooms
-                                    .get_pdu_json_from_id(&pdu_id)
-                                    .map_err(|e| (OutgoingKind::Normal(server.clone()), e))?
-                                    .ok_or_else(|| {
-                                        (
-                                            OutgoingKind::Normal(server.clone()),
-                                            Error::bad_database(
-                                                "[Normal] Event in servernamevent_datas not found in db.",
-                                            ),
-                                        )
-                                    })?,
-                            );
-                            pdu_jsons.push(raw);
+                            pdu_jsons.push(serde_json::from_str(
+                                PduEvent::convert_to_outgoing_federation_event(
+                                    db.rooms
+                                        .get_pdu_json_from_id(&pdu_id)
+                                        .map_err(|e| (OutgoingKind::Normal(server.clone()), e))?
+                                        .ok_or_else(|| {
+                                            (
+                                                OutgoingKind::Normal(server.clone()),
+                                                Error::bad_database(
+                                                    "[Normal] Event in servernamepduids not found in db.",
+                                                ),
+                                            )
+                                        })?,
+                                )
+                                .json()
+                                .get(),
+                            )
+                            .expect("Raw<..> is always valid"));
                        }
                        SendingEventType::Edu(edu) => {
-                            if let Ok(raw) = serde_json::from_slice(edu) {
-                                edu_jsons.push(raw);
-                            }
+                            edu_jsons.push(
+                                serde_json::from_slice(edu).expect("Raw<..> is always valid"),
+                            );
                        }
                    }
                }
@@ -698,11 +629,7 @@ impl Sending {
        }
    }

-    #[tracing::instrument(skip(key))]
-    fn parse_servercurrentevent(
-        key: &[u8],
-        value: Vec<u8>,
-    ) -> Result<(OutgoingKind, SendingEventType)> {
+    fn parse_servercurrentevent(key: &[u8]) -> Result<(OutgoingKind, SendingEventType)> {
        // Appservices start with a plus
        Ok::<_, Error>(if key.starts_with(b"+") {
            let mut parts = key[1..].splitn(2, |&b| b == 0xff);
@@ -719,10 +646,10 @@ impl Sending {
                OutgoingKind::Appservice(Box::<ServerName>::try_from(server).map_err(|_| {
                    Error::bad_database("Invalid server string in server_currenttransaction")
                })?),
-                if value.is_empty() {
-                    SendingEventType::Pdu(event.to_vec())
+                if event.starts_with(b"*") {
+                    SendingEventType::Edu(event[1..].to_vec())
                } else {
-                    SendingEventType::Edu(value)
+                    SendingEventType::Pdu(event.to_vec())
                },
            )
        } else if key.starts_with(b"$") {
@@ -737,10 +664,10 @@ impl Sending {
                .ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
            (
                OutgoingKind::Push(user.to_vec(), pushkey.to_vec()),
-                if value.is_empty() {
-                    SendingEventType::Pdu(event.to_vec())
+                if event.starts_with(b"*") {
+                    SendingEventType::Edu(event[1..].to_vec())
                } else {
-                    SendingEventType::Edu(value)
+                    SendingEventType::Pdu(event.to_vec())
                },
            )
        } else {
@@ -758,16 +685,16 @@ impl Sending {
                OutgoingKind::Normal(Box::<ServerName>::try_from(server).map_err(|_| {
                    Error::bad_database("Invalid server string in server_currenttransaction")
                })?),
-                if value.is_empty() {
-                    SendingEventType::Pdu(event.to_vec())
+                if event.starts_with(b"*") {
+                    SendingEventType::Edu(event[1..].to_vec())
                } else {
-                    SendingEventType::Edu(value)
+                    SendingEventType::Pdu(event.to_vec())
                },
            )
        })
    }

-    #[tracing::instrument(skip(self, globals, destination, request))]
+    #[tracing::instrument(skip(self, globals))]
    pub async fn send_federation_request<T: OutgoingRequest>(
        &self,
        globals: &crate::database::globals::Globals,
@@ -784,7 +711,7 @@ impl Sending {
        response
    }

-    #[tracing::instrument(skip(self, globals, registration, request))]
+    #[tracing::instrument(skip(self, globals))]
    pub async fn send_appservice_request<T: OutgoingRequest>(
        &self,
        globals: &crate::database::globals::Globals,
@@ -4,14 +4,11 @@ use crate::{client_server::SESSION_ID_LENGTH, utils, Error, Result};
 use ruma::{
    api::client::{
        error::ErrorKind,
-        r0::uiaa::{
-            IncomingAuthData, IncomingPassword, IncomingUserIdentifier::MatrixId, UiaaInfo,
-        },
+        r0::uiaa::{IncomingAuthData, UiaaInfo},
    },
    signatures::CanonicalJsonValue,
    DeviceId, UserId,
 };
-use tracing::error;

 use super::abstraction::Tree;

@@ -52,91 +49,126 @@ impl Uiaa {
        users: &super::users::Users,
        globals: &super::globals::Globals,
    ) -> Result<(bool, UiaaInfo)> {
-        let mut uiaainfo = auth
-            .session()
-            .map(|session| self.get_uiaa_session(&user_id, &device_id, session))
-            .unwrap_or_else(|| Ok(uiaainfo.clone()))?;
+        if let IncomingAuthData::DirectRequest {
+            kind,
+            session,
+            auth_parameters,
+        } = &auth
+        {
+            let mut uiaainfo = session
+                .as_ref()
+                .map(|session| self.get_uiaa_session(&user_id, &device_id, session))
+                .unwrap_or_else(|| Ok(uiaainfo.clone()))?;

-        if uiaainfo.session.is_none() {
-            uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        }
+            if uiaainfo.session.is_none() {
+                uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+            }

-        match auth {
            // Find out what the user completed
-            IncomingAuthData::Password(IncomingPassword {
-                identifier,
-                password,
-                ..
-            }) => {
-                let username = match identifier {
-                    MatrixId(username) => username,
-                    _ => {
+            match &**kind {
+                "m.login.password" => {
+                    let identifier = auth_parameters.get("identifier").ok_or(Error::BadRequest(
+                        ErrorKind::MissingParam,
+                        "m.login.password needs identifier.",
+                    ))?;
+
+                    let identifier_type = identifier.get("type").ok_or(Error::BadRequest(
+                        ErrorKind::MissingParam,
+                        "Identifier needs a type.",
+                    ))?;
+
+                    if identifier_type != "m.id.user" {
                        return Err(Error::BadRequest(
                            ErrorKind::Unrecognized,
                            "Identifier type not recognized.",
-                        ))
+                        ));
                    }
-                };

-                let user_id =
-                    UserId::parse_with_server_name(username.clone(), globals.server_name())
+                    let username = identifier
+                        .get("user")
+                        .ok_or(Error::BadRequest(
+                            ErrorKind::MissingParam,
+                            "Identifier needs user field.",
+                        ))?
+                        .as_str()
+                        .ok_or(Error::BadRequest(
+                            ErrorKind::BadJson,
+                            "User is not a string.",
+                        ))?;
+
+                    let user_id = UserId::parse_with_server_name(username, globals.server_name())
                        .map_err(|_| {
-                            Error::BadRequest(ErrorKind::InvalidParam, "User ID is invalid.")
-                        })?;
+                        Error::BadRequest(ErrorKind::InvalidParam, "User ID is invalid.")
+                    })?;

-                // Check if password is correct
-                if let Some(hash) = users.password_hash(&user_id)? {
-                    let hash_matches =
-                        argon2::verify_encoded(&hash, password.as_bytes()).unwrap_or(false);
+                    let password = auth_parameters
+                        .get("password")
+                        .ok_or(Error::BadRequest(
+                            ErrorKind::MissingParam,
+                            "Password is missing.",
+                        ))?
+                        .as_str()
+                        .ok_or(Error::BadRequest(
+                            ErrorKind::BadJson,
+                            "Password is not a string.",
+                        ))?;

-                    if !hash_matches {
-                        uiaainfo.auth_error = Some(ruma::api::client::error::ErrorBody {
-                            kind: ErrorKind::Forbidden,
-                            message: "Invalid username or password.".to_owned(),
-                        });
-                        return Ok((false, uiaainfo));
+                    // Check if password is correct
+                    if let Some(hash) = users.password_hash(&user_id)? {
+                        let hash_matches =
+                            argon2::verify_encoded(&hash, password.as_bytes()).unwrap_or(false);
+
+                        if !hash_matches {
+                            uiaainfo.auth_error = Some(ruma::api::client::error::ErrorBody {
+                                kind: ErrorKind::Forbidden,
+                                message: "Invalid username or password.".to_owned(),
+                            });
+                            return Ok((false, uiaainfo));
+                        }
+                    }
+
+                    // Password was correct! Let's add it to `completed`
+                    uiaainfo.completed.push("m.login.password".to_owned());
+                }
+                "m.login.dummy" => {
+                    uiaainfo.completed.push("m.login.dummy".to_owned());
+                }
+                k => panic!("type not supported: {}", k),
+            }
+
+            // Check if a flow now succeeds
+            let mut completed = false;
+            'flows: for flow in &mut uiaainfo.flows {
+                for stage in &flow.stages {
+                    if !uiaainfo.completed.contains(stage) {
+                        continue 'flows;
                    }
                }
-
-                // Password was correct! Let's add it to `completed`
-                uiaainfo.completed.push("m.login.password".to_owned());
+                // We didn't break, so this flow succeeded!
+                completed = true;
            }
-            IncomingAuthData::Dummy(_) => {
-                uiaainfo.completed.push("m.login.dummy".to_owned());
-            }
-            k => error!("type not supported: {:?}", k),
-        }

-        // Check if a flow now succeeds
-        let mut completed = false;
-        'flows: for flow in &mut uiaainfo.flows {
-            for stage in &flow.stages {
-                if !uiaainfo.completed.contains(stage) {
-                    continue 'flows;
-                }
+            if !completed {
+                self.update_uiaa_session(
+                    user_id,
+                    device_id,
+                    uiaainfo.session.as_ref().expect("session is always set"),
+                    Some(&uiaainfo),
+                )?;
+                return Ok((false, uiaainfo));
            }
-            // We didn't break, so this flow succeeded!
-            completed = true;
-        }

-        if !completed {
+            // UIAA was successful! Remove this session and return true
            self.update_uiaa_session(
                user_id,
                device_id,
                uiaainfo.session.as_ref().expect("session is always set"),
-                Some(&uiaainfo),
+                None,
            )?;
-            return Ok((false, uiaainfo));
+            Ok((true, uiaainfo))
+        } else {
+            panic!("FallbackAcknowledgement is not supported yet");
        }
-
-        // UIAA was successful! Remove this session and return true
-        self.update_uiaa_session(
-            user_id,
-            device_id,
-            uiaainfo.session.as_ref().expect("session is always set"),
-            None,
-        )?;
-        Ok((true, uiaainfo))
    }

    fn set_uiaa_request(
@@ -8,7 +8,6 @@ use ruma::{
    DeviceId, DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, UInt, UserId,
 };
 use std::{collections::BTreeMap, convert::TryFrom, mem, sync::Arc};
-use tracing::warn;

 use super::abstraction::Tree;

@@ -16,7 +15,6 @@ pub struct Users {
    pub(super) userid_password: Arc<dyn Tree>,
    pub(super) userid_displayname: Arc<dyn Tree>,
    pub(super) userid_avatarurl: Arc<dyn Tree>,
-    pub(super) userid_blurhash: Arc<dyn Tree>,
    pub(super) userdeviceid_token: Arc<dyn Tree>,
    pub(super) userdeviceid_metadata: Arc<dyn Tree>, // This is also used to check if a device exists
    pub(super) userid_devicelistversion: Arc<dyn Tree>, // DevicelistVersion = u64
@@ -35,13 +33,11 @@ pub struct Users {

 impl Users {
    /// Check if a user has an account on this homeserver.
-    #[tracing::instrument(skip(self, user_id))]
    pub fn exists(&self, user_id: &UserId) -> Result<bool> {
        Ok(self.userid_password.get(user_id.as_bytes())?.is_some())
    }

    /// Check if account is deactivated
-    #[tracing::instrument(skip(self, user_id))]
    pub fn is_deactivated(&self, user_id: &UserId) -> Result<bool> {
        Ok(self
            .userid_password
@@ -54,20 +50,17 @@ impl Users {
    }

    /// Create a new user account on this homeserver.
-    #[tracing::instrument(skip(self, user_id, password))]
    pub fn create(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
        self.set_password(user_id, password)?;
        Ok(())
    }

    /// Returns the number of users registered on this server.
-    #[tracing::instrument(skip(self))]
    pub fn count(&self) -> Result<usize> {
        Ok(self.userid_password.iter().count())
    }

    /// Find out which user an access token belongs to.
-    #[tracing::instrument(skip(self, token))]
    pub fn find_from_token(&self, token: &str) -> Result<Option<(UserId, String)>> {
        self.token_userdeviceid
            .get(token.as_bytes())?
@@ -95,7 +88,6 @@ impl Users {
    }

    /// Returns an iterator over all users on this homeserver.
-    #[tracing::instrument(skip(self))]
    pub fn iter(&self) -> impl Iterator<Item = Result<UserId>> + '_ {
        self.userid_password.iter().map(|(bytes, _)| {
            UserId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
@@ -106,7 +98,6 @@ impl Users {
    }

    /// Returns the password hash for the given user.
-    #[tracing::instrument(skip(self, user_id))]
    pub fn password_hash(&self, user_id: &UserId) -> Result<Option<String>> {
        self.userid_password
            .get(user_id.as_bytes())?
@@ -118,7 +109,6 @@ impl Users {
    }

    /// Hash and set the user's password to the Argon2 hash
-    #[tracing::instrument(skip(self, user_id, password))]
    pub fn set_password(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
        if let Some(password) = password {
            if let Ok(hash) = utils::calculate_hash(&password) {
@@ -138,7 +128,6 @@ impl Users {
    }

    /// Returns the displayname of a user on this homeserver.
-    #[tracing::instrument(skip(self, user_id))]
    pub fn displayname(&self, user_id: &UserId) -> Result<Option<String>> {
        self.userid_displayname
            .get(user_id.as_bytes())?
@@ -150,7 +139,6 @@ impl Users {
    }

    /// Sets a new displayname or removes it if displayname is None. You still need to nofify all rooms of this change.
-    #[tracing::instrument(skip(self, user_id, displayname))]
    pub fn set_displayname(&self, user_id: &UserId, displayname: Option<String>) -> Result<()> {
        if let Some(displayname) = displayname {
            self.userid_displayname
@@ -162,8 +150,7 @@ impl Users {
        Ok(())
    }

-    /// Get the avatar_url of a user.
-    #[tracing::instrument(skip(self, user_id))]
+    /// Get a the avatar_url of a user.
    pub fn avatar_url(&self, user_id: &UserId) -> Result<Option<MxcUri>> {
        self.userid_avatarurl
            .get(user_id.as_bytes())?
@@ -176,7 +163,6 @@ impl Users {
    }

    /// Sets a new avatar_url or removes it if avatar_url is None.
-    #[tracing::instrument(skip(self, user_id, avatar_url))]
    pub fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<MxcUri>) -> Result<()> {
        if let Some(avatar_url) = avatar_url {
            self.userid_avatarurl
@@ -188,35 +174,7 @@ impl Users {
        Ok(())
    }

-    /// Get the blurhash of a user.
-    #[tracing::instrument(skip(self, user_id))]
-    pub fn blurhash(&self, user_id: &UserId) -> Result<Option<String>> {
-        self.userid_blurhash
-            .get(user_id.as_bytes())?
-            .map(|bytes| {
-                let s = utils::string_from_bytes(&bytes)
-                    .map_err(|_| Error::bad_database("Avatar URL in db is invalid."))?;
-
-                Ok(s)
-            })
-            .transpose()
-    }
-
-    /// Sets a new avatar_url or removes it if avatar_url is None.
-    #[tracing::instrument(skip(self, user_id, blurhash))]
-    pub fn set_blurhash(&self, user_id: &UserId, blurhash: Option<String>) -> Result<()> {
-        if let Some(blurhash) = blurhash {
-            self.userid_blurhash
-                .insert(user_id.as_bytes(), blurhash.as_bytes())?;
-        } else {
-            self.userid_blurhash.remove(user_id.as_bytes())?;
-        }
-
-        Ok(())
-    }
-
    /// Adds a new device to a user.
-    #[tracing::instrument(skip(self, user_id, device_id, token, initial_device_display_name))]
    pub fn create_device(
        &self,
        user_id: &UserId,
@@ -251,7 +209,6 @@ impl Users {
    }

    /// Removes a device from a user.
-    #[tracing::instrument(skip(self, user_id, device_id))]
    pub fn remove_device(&self, user_id: &UserId, device_id: &DeviceId) -> Result<()> {
        let mut userdeviceid = user_id.as_bytes().to_vec();
        userdeviceid.push(0xff);
@@ -282,7 +239,6 @@ impl Users {
    }

    /// Returns an iterator over all device ids of this user.
-    #[tracing::instrument(skip(self, user_id))]
    pub fn all_device_ids<'a>(
        &'a self,
        user_id: &UserId,
@@ -305,7 +261,6 @@ impl Users {
    }

    /// Replaces the access token of one device.
-    #[tracing::instrument(skip(self, user_id, device_id, token))]
    pub fn set_token(&self, user_id: &UserId, device_id: &DeviceId, token: &str) -> Result<()> {
        let mut userdeviceid = user_id.as_bytes().to_vec();
        userdeviceid.push(0xff);
@@ -329,14 +284,6 @@ impl Users {
        Ok(())
    }

-    #[tracing::instrument(skip(
-        self,
-        user_id,
-        device_id,
-        one_time_key_key,
-        one_time_key_value,
-        globals
-    ))]
    pub fn add_one_time_key(
        &self,
        user_id: &UserId,
@@ -373,7 +320,7 @@ impl Users {
        Ok(())
    }

-    #[tracing::instrument(skip(self, user_id))]
+    #[tracing::instrument(skip(self))]
    pub fn last_one_time_keys_update(&self, user_id: &UserId) -> Result<u64> {
        self.userid_lastonetimekeyupdate
            .get(&user_id.as_bytes())?
@@ -385,7 +332,6 @@ impl Users {
            .unwrap_or(Ok(0))
    }

-    #[tracing::instrument(skip(self, user_id, device_id, key_algorithm, globals))]
    pub fn take_one_time_key(
        &self,
        user_id: &UserId,
@@ -425,7 +371,7 @@ impl Users {
            .transpose()
    }

-    #[tracing::instrument(skip(self, user_id, device_id))]
+    #[tracing::instrument(skip(self))]
    pub fn count_one_time_keys(
        &self,
        user_id: &UserId,
@@ -458,7 +404,6 @@ impl Users {
        Ok(counts)
    }

-    #[tracing::instrument(skip(self, user_id, device_id, device_keys, rooms, globals))]
    pub fn add_device_keys(
        &self,
        user_id: &UserId,
@@ -481,14 +426,6 @@ impl Users {
        Ok(())
    }

-    #[tracing::instrument(skip(
-        self,
-        master_key,
-        self_signing_key,
-        user_signing_key,
-        rooms,
-        globals
-    ))]
    pub fn add_cross_signing_keys(
        &self,
        user_id: &UserId,
@@ -589,7 +526,6 @@ impl Users {
        Ok(())
    }

-    #[tracing::instrument(skip(self, target_id, key_id, signature, sender_id, rooms, globals))]
    pub fn sign_key(
        &self,
        target_id: &UserId,
@@ -633,7 +569,7 @@ impl Users {
        Ok(())
    }

-    #[tracing::instrument(skip(self, user_or_room_id, from, to))]
+    #[tracing::instrument(skip(self))]
    pub fn keys_changed<'a>(
        &'a self,
        user_or_room_id: &str,
@@ -646,24 +582,9 @@ impl Users {
        let mut start = prefix.clone();
        start.extend_from_slice(&(from + 1).to_be_bytes());

-        let to = to.unwrap_or(u64::MAX);
-
        self.keychangeid_userid
            .iter_from(&start, false)
-            .take_while(move |(k, _)| {
-                k.starts_with(&prefix)
-                    && if let Some(current) = k.splitn(2, |&b| b == 0xff).nth(1) {
-                        if let Ok(c) = utils::u64_from_bytes(current) {
-                            c <= to
-                        } else {
-                            warn!("BadDatabase: Could not parse keychangeid_userid bytes");
-                            false
-                        }
-                    } else {
-                        warn!("BadDatabase: Could not parse keychangeid_userid");
-                        false
-                    }
-            })
+            .take_while(move |(k, _)| k.starts_with(&prefix))
            .map(|(_, bytes)| {
                UserId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
                    Error::bad_database("User ID in devicekeychangeid_userid is invalid unicode.")
@@ -672,8 +593,7 @@ impl Users {
            })
    }

-    #[tracing::instrument(skip(self, user_id, rooms, globals))]
-    pub fn mark_device_key_update(
+    fn mark_device_key_update(
        &self,
        user_id: &UserId,
        rooms: &super::rooms::Rooms,
@@ -704,7 +624,6 @@ impl Users {
        Ok(())
    }

-    #[tracing::instrument(skip(self, user_id, device_id))]
    pub fn get_device_keys(
        &self,
        user_id: &UserId,
@@ -721,7 +640,6 @@ impl Users {
        })
    }

-    #[tracing::instrument(skip(self, user_id, allowed_signatures))]
    pub fn get_master_key<F: Fn(&UserId) -> bool>(
        &self,
        user_id: &UserId,
@@ -749,7 +667,6 @@ impl Users {
            })
    }

-    #[tracing::instrument(skip(self, user_id, allowed_signatures))]
    pub fn get_self_signing_key<F: Fn(&UserId) -> bool>(
        &self,
        user_id: &UserId,
@@ -777,7 +694,6 @@ impl Users {
            })
    }

-    #[tracing::instrument(skip(self, user_id))]
    pub fn get_user_signing_key(&self, user_id: &UserId) -> Result<Option<CrossSigningKey>> {
        self.userid_usersigningkeyid
            .get(user_id.as_bytes())?
@@ -790,15 +706,6 @@ impl Users {
            })
    }

-    #[tracing::instrument(skip(
-        self,
-        sender,
-        target_user_id,
-        target_device_id,
-        event_type,
-        content,
-        globals
-    ))]
    pub fn add_to_device_event(
        &self,
        sender: &UserId,
@@ -826,7 +733,7 @@ impl Users {
        Ok(())
    }

-    #[tracing::instrument(skip(self, user_id, device_id))]
+    #[tracing::instrument(skip(self))]
    pub fn get_to_device_events(
        &self,
        user_id: &UserId,
@@ -849,7 +756,7 @@ impl Users {
        Ok(events)
    }

-    #[tracing::instrument(skip(self, user_id, device_id, until))]
+    #[tracing::instrument(skip(self))]
    pub fn remove_to_device_events(
        &self,
        user_id: &UserId,
@@ -884,7 +791,6 @@ impl Users {
        Ok(())
    }

-    #[tracing::instrument(skip(self, user_id, device_id, device))]
    pub fn update_device_metadata(
        &self,
        user_id: &UserId,
@@ -910,7 +816,6 @@ impl Users {
    }

    /// Get device metadata.
-    #[tracing::instrument(skip(self, user_id, device_id))]
    pub fn get_device_metadata(
        &self,
        user_id: &UserId,
@@ -929,7 +834,6 @@ impl Users {
            })
    }

-    #[tracing::instrument(skip(self, user_id))]
    pub fn get_devicelist_version(&self, user_id: &UserId) -> Result<Option<u64>> {
        self.userid_devicelistversion
            .get(user_id.as_bytes())?
@@ -940,7 +844,6 @@ impl Users {
            })
    }

-    #[tracing::instrument(skip(self, user_id))]
    pub fn all_devices_metadata<'a>(
        &'a self,
        user_id: &UserId,
@@ -957,7 +860,6 @@ impl Users {
    }

    /// Deactivate account
-    #[tracing::instrument(skip(self, user_id))]
    pub fn deactivate_account(&self, user_id: &UserId) -> Result<()> {
        // Remove all associated devices
        for device_id in self.all_device_ids(user_id) {
@@ -1,3 +1,4 @@
+use log::{error, warn};
 use ruma::{
    api::client::{
        error::{Error as RumaError, ErrorKind},
@@ -6,7 +7,6 @@ use ruma::{
    ServerName,
 };
 use thiserror::Error;
-use tracing::warn;

 #[cfg(feature = "conduit_bin")]
 use {
@@ -17,7 +17,6 @@ use {
        Request,
    },
    ruma::api::client::r0::uiaa::UiaaResponse,
-    tracing::error,
 };

 pub type Result<T> = std::result::Result<T, Error>;
@@ -30,15 +29,12 @@ pub enum Error {
        #[from]
        source: sled::Error,
    },
-    #[cfg(feature = "sqlite")]
-    #[error("There was a problem with the connection to the sqlite database: {source}")]
-    SqliteError {
+    #[cfg(feature = "rocksdb")]
+    #[error("There was a problem with the connection to the rocksdb database: {source}")]
+    RocksDbError {
        #[from]
-        source: rusqlite::Error,
+        source: rocksdb::Error,
    },
-    #[cfg(feature = "heed")]
-    #[error("There was a problem with the connection to the heed database: {error}")]
-    HeedError { error: String },
    #[error("Could not generate an image.")]
    ImageError {
        #[from]
@@ -10,10 +10,10 @@ mod ruma_wrapper;
 pub mod server_server;
 mod utils;

-pub use database::{Config, Database};
+pub use database::Database;
 pub use error::{Error, Result};
 pub use pdu::PduEvent;
-pub use rocket::Config as RocketConfig;
+pub use rocket::Config;
 pub use ruma_wrapper::{ConduitResult, Ruma, RumaResponse};
 use std::ops::Deref;

@@ -17,7 +17,6 @@ use std::sync::Arc;
 use database::Config;
 pub use database::Database;
 pub use error::{Error, Result};
-use opentelemetry::trace::{FutureExt, Tracer};
 pub use pdu::PduEvent;
 pub use rocket::State;
 use ruma::api::client::error::ErrorKind;
@@ -31,10 +30,10 @@ use rocket::{
    },
    routes, Request,
 };
-use tokio::sync::RwLock;
-use tracing_subscriber::{prelude::*, EnvFilter};
+use tracing::span;
+use tracing_subscriber::{prelude::*, Registry};

-fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<rocket::Build> {
+fn setup_rocket(config: Figment, data: Arc<Database>) -> rocket::Rocket<rocket::Build> {
    rocket::custom(config)
        .manage(data)
        .mount(
@@ -50,7 +49,6 @@ fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<
                client_server::logout_all_route,
                client_server::change_password_route,
                client_server::deactivate_route,
-                client_server::third_party_route,
                client_server::get_capabilities_route,
                client_server::get_pushrules_all_route,
                client_server::set_pushrule_route,
@@ -61,7 +59,6 @@ fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<
                client_server::set_pushrule_actions_route,
                client_server::delete_pushrule_route,
                client_server::get_room_event_route,
-                client_server::get_room_aliases_route,
                client_server::get_filter_route,
                client_server::create_filter_route,
                client_server::set_global_account_data_route,
@@ -160,8 +157,7 @@ fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<
                server_server::get_room_state_route,
                server_server::get_room_state_ids_route,
                server_server::create_join_event_template_route,
-                server_server::create_join_event_v1_route,
-                server_server::create_join_event_v2_route,
+                server_server::create_join_event_route,
                server_server::create_invite_route,
                server_server::get_devices_route,
                server_server::get_room_information_route,
@@ -188,7 +184,7 @@ async fn main() {
    std::env::set_var("CONDUIT_LOG_LEVEL", "off");

    let raw_config =
-        Figment::from(default_config())
+        Figment::from(rocket::Config::release_default())
            .merge(
                Toml::file(Env::var("CONDUIT_CONFIG").expect(
                    "The CONDUIT_CONFIG env var needs to be set. Example: /etc/conduit.toml",
@@ -197,65 +193,33 @@ async fn main() {
            )
            .merge(Env::prefixed("CONDUIT_").global());

-    std::env::set_var("RUST_LOG", "warn");
-
    let config = raw_config
        .extract::<Config>()
        .expect("It looks like your config is invalid. Please take a look at the error");

-    let start = async {
-        config.warn_deprecated();
-
-        let db = Database::load_or_create(&config)
-            .await
-            .expect("config is valid");
-
-        let rocket = setup_rocket(raw_config, Arc::clone(&db))
-            .ignite()
-            .await
-            .unwrap();
-
-        Database::start_on_shutdown_tasks(db, rocket.shutdown()).await;
-
-        rocket.launch().await.unwrap();
-    };
+    let db = Database::load_or_create(config.clone())
+        .await
+        .expect("config is valid");

    if config.allow_jaeger {
-        opentelemetry::global::set_text_map_propagator(opentelemetry_jaeger::Propagator::new());
-        let tracer = opentelemetry_jaeger::new_pipeline()
-            .install_batch(opentelemetry::runtime::Tokio)
+        let (tracer, _uninstall) = opentelemetry_jaeger::new_pipeline()
+            .with_service_name("conduit")
+            .install()
            .unwrap();
+        let telemetry = tracing_opentelemetry::layer().with_tracer(tracer);
+        Registry::default().with(telemetry).try_init().unwrap();

-        let span = tracer.start("conduit");
-        start.with_current_context().await;
-        drop(span);
+        let root = span!(tracing::Level::INFO, "app_start", work_units = 2);
+        let _enter = root.enter();

-        println!("exporting");
-        opentelemetry::global::shutdown_tracer_provider();
+        let rocket = setup_rocket(raw_config, db);
+        rocket.launch().await.unwrap();
    } else {
-        std::env::set_var("RUST_LOG", &config.log);
+        std::env::set_var("RUST_LOG", config.log);
+        tracing_subscriber::fmt::init();

-        let registry = tracing_subscriber::Registry::default();
-        if config.tracing_flame {
-            let (flame_layer, _guard) =
-                tracing_flame::FlameLayer::with_file("./tracing.folded").unwrap();
-            let flame_layer = flame_layer.with_empty_samples(false);
-
-            let filter_layer = EnvFilter::new("trace,h2=off");
-
-            let subscriber = registry.with(filter_layer).with(flame_layer);
-            tracing::subscriber::set_global_default(subscriber).unwrap();
-            start.await;
-        } else {
-            let fmt_layer = tracing_subscriber::fmt::Layer::new();
-            let filter_layer = EnvFilter::try_from_default_env()
-                .or_else(|_| EnvFilter::try_new("info"))
-                .unwrap();
-
-            let subscriber = registry.with(filter_layer).with(fmt_layer);
-            tracing::subscriber::set_global_default(subscriber).unwrap();
-            start.await;
-        }
+        let rocket = setup_rocket(raw_config, db);
+        rocket.launch().await.unwrap();
    }
 }

@@ -286,30 +250,3 @@ fn missing_token_catcher() -> Result<()> {
 fn bad_json_catcher() -> Result<()> {
    Err(Error::BadRequest(ErrorKind::BadJson, "Bad json."))
 }
-
-fn default_config() -> rocket::Config {
-    let mut config = rocket::Config::release_default();
-
-    {
-        let mut shutdown = &mut config.shutdown;
-
-        #[cfg(unix)]
-        {
-            use rocket::config::Sig;
-
-            shutdown.signals.insert(Sig::Term);
-            shutdown.signals.insert(Sig::Int);
-        }
-
-        // Once shutdown is triggered, this is the amount of seconds before rocket
-        // will forcefully start shutting down connections, this gives enough time to /sync
-        // requests and the like (which havent gotten the memo, somehow) to still complete gracefully.
-        shutdown.grace = 35;
-
-        // After the grace period, rocket starts shutting down connections, and waits at least this
-        // many seconds before forcefully shutting all of them down.
-        shutdown.mercy = 10;
-    }
-
-    config
-}
@@ -1,9 +1,10 @@
 use crate::Error;
+use log::error;
 use ruma::{
    events::{
-        pdu::EventHash, room::member::MemberEventContent, AnyEphemeralRoomEvent,
-        AnyInitialStateEvent, AnyRoomEvent, AnyStateEvent, AnyStrippedStateEvent, AnySyncRoomEvent,
-        AnySyncStateEvent, EventType, StateEvent,
+        pdu::EventHash, room::member::MemberEventContent, AnyEphemeralRoomEvent, AnyRoomEvent,
+        AnyStateEvent, AnyStrippedStateEvent, AnySyncRoomEvent, AnySyncStateEvent, EventType,
+        StateEvent,
    },
    serde::{CanonicalJsonObject, CanonicalJsonValue, Raw},
    state_res, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, ServerName,
@@ -12,7 +13,6 @@ use ruma::{
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use std::{cmp::Ordering, collections::BTreeMap, convert::TryFrom};
-use tracing::warn;

 #[derive(Clone, Deserialize, Serialize, Debug)]
 pub struct PduEvent {
@@ -322,13 +322,12 @@ pub(crate) fn gen_event_id_canonical_json(
    pdu: &Raw<ruma::events::pdu::Pdu>,
 ) -> crate::Result<(EventId, CanonicalJsonObject)> {
    let value = serde_json::from_str(pdu.json().get()).map_err(|e| {
-        warn!("Error parsing incoming event {:?}: {:?}", pdu, e);
+        error!("{:?}: {:?}", pdu, e);
        Error::BadServerResponse("Invalid PDU in server response")
    })?;

    let event_id = EventId::try_from(&*format!(
        "${}",
-        // Anything higher than version3 behaves the same
        ruma::signatures::reference_hash(&value, &RoomVersionId::Version6)
            .expect("ruma can calculate reference hashes")
    ))
@@ -347,17 +346,3 @@ pub struct PduBuilder {
    pub state_key: Option<String>,
    pub redacts: Option<EventId>,
 }
-
-/// Direct conversion prevents loss of the empty `state_key` that ruma requires.
-impl From<AnyInitialStateEvent> for PduBuilder {
-    fn from(event: AnyInitialStateEvent) -> Self {
-        Self {
-            event_type: EventType::from(event.event_type()),
-            content: serde_json::value::to_value(event.content())
-                .expect("AnyStateEventContent came from JSON and can thus turn back into JSON."),
-            unsigned: None,
-            state_key: Some(event.state_key().to_owned()),
-            redacts: None,
-        }
-    }
-}
@@ -1,4 +1,4 @@
-use crate::{database::DatabaseGuard, Error};
+use crate::Error;
 use ruma::{
    api::{client::r0::uiaa::UiaaResponse, OutgoingResponse},
    identifiers::{DeviceId, UserId},
@@ -9,20 +9,21 @@ use std::ops::Deref;

 #[cfg(feature = "conduit_bin")]
 use {
-    crate::server_server,
+    crate::{server_server, Database},
+    log::{debug, warn},
    rocket::{
        data::{self, ByteUnit, Data, FromData},
        http::Status,
        outcome::Outcome::*,
        response::{self, Responder},
        tokio::io::AsyncReadExt,
-        Request,
+        Request, State,
    },
    ruma::api::{AuthScheme, IncomingRequest},
    std::collections::BTreeMap,
    std::convert::TryFrom,
    std::io::Cursor,
-    tracing::{debug, warn},
+    std::sync::Arc,
 };

 /// This struct converts rocket requests into ruma structs by converting them into http requests
@@ -45,14 +46,10 @@ where
 {
    type Error = ();

-    #[tracing::instrument(skip(request, data))]
-    async fn from_data(
-        request: &'a Request<'_>,
-        data: Data<'a>,
-    ) -> data::Outcome<'a, Self, Self::Error> {
+    async fn from_data(request: &'a Request<'_>, data: Data) -> data::Outcome<Self, Self::Error> {
        let metadata = T::Incoming::METADATA;
        let db = request
-            .guard::<DatabaseGuard>()
+            .guard::<State<'_, Arc<Database>>>()
            .await
            .expect("database was loaded");

@@ -75,9 +72,9 @@ where
            registration,
        )) = db
            .appservice
-            .all()
+            .iter_all()
            .unwrap()
-            .iter()
+            .filter_map(|r| r.ok())
            .find(|(_id, registration)| {
                registration
                    .get("as_token")
@@ -106,7 +103,7 @@ where

                    if !db.users.exists(&user_id).unwrap() {
                        // Forbidden
-                        return Failure((Status::new(580), ()));
+                        return Failure((Status::raw(580), ()));
                    }

                    // TODO: Check if appservice is allowed to be that user
@@ -121,7 +118,7 @@ where
                    if let Some(token) = token {
                        match db.users.find_from_token(&token).unwrap() {
                            // Unknown Token
-                            None => return Failure((Status::new(581), ())),
+                            None => return Failure((Status::raw(581), ())),
                            Some((user_id, device_id)) => (
                                Some(user_id),
                                Some(Box::<DeviceId>::from(device_id)),
@@ -131,7 +128,7 @@ where
                        }
                    } else {
                        // Missing Token
-                        return Failure((Status::new(582), ()));
+                        return Failure((Status::raw(582), ()));
                    }
                }
                AuthScheme::ServerSignatures => {
@@ -153,7 +150,7 @@ where
                            warn!("No Authorization header");

                            // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                        }
                    };

@@ -163,7 +160,7 @@ where
                            warn!("Invalid X-Matrix header origin field: {:?}", x_matrix);

                            // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                        }
                    };

@@ -176,7 +173,7 @@ where
                            );

                            // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                        }
                    };

@@ -186,7 +183,7 @@ where
                            warn!("Invalid X-Matrix header key field: {:?}", x_matrix);

                            // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                        }
                    };

@@ -196,7 +193,7 @@ where
                            warn!("Invalid X-Matrix header sig field: {:?}", x_matrix);

                            // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                        }
                    };

@@ -247,7 +244,7 @@ where
                                warn!("Failed to fetch signing keys: {}", e);

                                // Forbidden
-                                return Failure((Status::new(580), ()));
+                                return Failure((Status::raw(580), ()));
                            }
                        };

@@ -257,17 +254,14 @@ where
                    match ruma::signatures::verify_json(&pub_key_map, &request_map) {
                        Ok(()) => (None, None, Some(origin), false),
                        Err(e) => {
-                            warn!(
-                                "Failed to verify json request from {}: {}\n{:?}",
-                                origin, e, request_map
-                            );
+                            warn!("Failed to verify json request from {}: {}", origin, e);

                            if request.uri().to_string().contains('@') {
                                warn!("Request uri contained '@' character. Make sure your reverse proxy gives Conduit the raw uri (apache: use nocanon)");
                            }

                            // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                        }
                    }
                }
@@ -325,7 +319,7 @@ where
            Err(e) => {
                warn!("{:?}", e);
                // Bad Json
-                Failure((Status::new(583), ()))
+                Failure((Status::raw(583), ()))
            }
        }
    }
@@ -351,7 +345,7 @@ pub fn response<T: OutgoingResponse>(response: RumaResponse<T>) -> response::Res
    let mut response = rocket::response::Response::build();

    let status = http_response.status();
-    response.status(Status::new(status.as_u16()));
+    response.raw_status(status.into(), "");

    for header in http_response.headers() {
        response.raw_header(header.0.to_string(), header.1.to_str().unwrap().to_owned());
@@ -5,11 +5,9 @@ use ruma::serde::{try_from_json_map, CanonicalJsonError, CanonicalJsonObject};
 use std::{
    cmp,
    convert::TryInto,
-    str::FromStr,
    time::{SystemTime, UNIX_EPOCH},
 };

-#[tracing::instrument]
 pub fn millis_since_unix_epoch() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
@@ -17,6 +15,15 @@ pub fn millis_since_unix_epoch() -> u64 {
        .as_millis() as u64
 }

+#[cfg(feature = "rocksdb")]
+pub fn increment_rocksdb(
+    _new_key: &[u8],
+    old: Option<&[u8]>,
+    _operands: &mut rocksdb::MergeOperands,
+) -> Option<Vec<u8>> {
+    increment(old)
+}
+
 pub fn increment(old: Option<&[u8]>) -> Option<Vec<u8>> {
    let number = match old.map(|bytes| bytes.try_into()) {
        Some(Ok(bytes)) => {
@@ -40,19 +47,16 @@ pub fn generate_keypair() -> Vec<u8> {
 }

 /// Parses the bytes into an u64.
-#[tracing::instrument(skip(bytes))]
 pub fn u64_from_bytes(bytes: &[u8]) -> Result<u64, std::array::TryFromSliceError> {
    let array: [u8; 8] = bytes.try_into()?;
    Ok(u64::from_be_bytes(array))
 }

 /// Parses the bytes into a string.
-#[tracing::instrument(skip(bytes))]
 pub fn string_from_bytes(bytes: &[u8]) -> Result<String, std::string::FromUtf8Error> {
    String::from_utf8(bytes.to_vec())
 }

-#[tracing::instrument(skip(length))]
 pub fn random_string(length: usize) -> String {
    thread_rng()
        .sample_iter(&rand::distributions::Alphanumeric)
@@ -62,7 +66,6 @@ pub fn random_string(length: usize) -> String {
 }

 /// Calculate a new hash for the given password
-#[tracing::instrument(skip(password))]
 pub fn calculate_hash(password: &str) -> Result<String, argon2::Error> {
    let hashing_config = Config {
        variant: Variant::Argon2id,
@@ -73,7 +76,6 @@ pub fn calculate_hash(password: &str) -> Result<String, argon2::Error> {
    argon2::hash_encoded(password.as_bytes(), salt.as_bytes(), &hashing_config)
 }

-#[tracing::instrument(skip(iterators, check_order))]
 pub fn common_elements(
    mut iterators: impl Iterator<Item = impl Iterator<Item = Vec<u8>>>,
    check_order: impl Fn(&[u8], &[u8]) -> Ordering,
@@ -101,7 +103,6 @@ pub fn common_elements(
 /// Fallible conversion from any value that implements `Serialize` to a `CanonicalJsonObject`.
 ///
 /// `value` must serialize to an `serde_json::Value::Object`.
-#[tracing::instrument(skip(value))]
 pub fn to_canonical_object<T: serde::Serialize>(
    value: T,
 ) -> Result<CanonicalJsonObject, CanonicalJsonError> {
@@ -114,30 +115,3 @@ pub fn to_canonical_object<T: serde::Serialize>(
        ))),
    }
 }
-
-#[tracing::instrument(skip(deserializer))]
-pub fn deserialize_from_str<
-    'de,
-    D: serde::de::Deserializer<'de>,
-    T: FromStr<Err = E>,
-    E: std::fmt::Display,
->(
-    deserializer: D,
-) -> std::result::Result<T, D::Error> {
-    struct Visitor<T: FromStr<Err = E>, E>(std::marker::PhantomData<T>);
-    impl<'de, T: FromStr<Err = Err>, Err: std::fmt::Display> serde::de::Visitor<'de>
-        for Visitor<T, Err>
-    {
-        type Value = T;
-        fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            write!(formatter, "a parsable string")
-        }
-        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-        where
-            E: serde::de::Error,
-        {
-            v.parse().map_err(serde::de::Error::custom)
-        }
-    }
-    deserializer.deserialize_str(Visitor(std::marker::PhantomData))
-}
@@ -1,101 +0,0 @@
-const puppeteer = require('puppeteer');
-
-run().then(() => console.log('Done')).catch(error => {
-    console.error("Registration test failed.");
-    console.error("There might be a screenshot of the failure in the artifacts.\n");
-    console.error(error);
-    process.exit(111);
-});
-
-async function run() {
-
-    const elementUrl = process.argv[process.argv.length - 2];
-    console.debug("Testing registration with ElementWeb hosted at "+ elementUrl);
-
-    const homeserverUrl = process.argv[process.argv.length - 1];
-    console.debug("Homeserver url: "+ homeserverUrl);
-
-    const username = "testuser" + String(Math.floor(Math.random() * 100000));
-    const password = "testpassword" + String(Math.floor(Math.random() * 100000));
-    console.debug("Testuser for this run:\n  User: " + username + "\n  Password: " + password);
-
-    const browser = await puppeteer.launch({
-        headless: true, args: [
-            "--no-sandbox"
-        ]
-    });
-
-    const page = await browser.newPage();
-    await page.goto(elementUrl);
-
-    await page.screenshot({ path: '01-element-web-opened.png' });
-
-    console.debug("Click [Create Account] button");
-    await page.waitForSelector('a.mx_ButtonCreateAccount');
-    await page.click('a.mx_ButtonCreateAccount');
-
-    await page.screenshot({ path: '02-clicked-create-account-button.png' });
-
-    // The webapp should have loaded right now, if anything takes more than 5 seconds, something probably broke
-    page.setDefaultTimeout(5000);
-
-    console.debug("Click [Edit] to switch homeserver");
-    await page.waitForSelector('div.mx_ServerPicker_change');
-    await page.click('div.mx_ServerPicker_change');
-
-    await page.screenshot({ path: '03-clicked-edit-homeserver-button.png' });
-
-    console.debug("Type in local homeserver url");
-    await page.waitForSelector('input#mx_homeserverInput');
-    await page.click('input#mx_homeserverInput');
-    await page.click('input#mx_homeserverInput');
-    await page.keyboard.type(homeserverUrl);
-
-    await page.screenshot({ path: '04-typed-in-homeserver.png' });
-
-    console.debug("[Continue] with changed homeserver");
-    await page.waitForSelector("div.mx_ServerPickerDialog_continue");
-    await page.click('div.mx_ServerPickerDialog_continue');
-
-    await page.screenshot({ path: '05-back-to-enter-user-credentials.png' });
-
-    console.debug("Type in username");
-    await page.waitForSelector("input#mx_RegistrationForm_username");
-    await page.click('input#mx_RegistrationForm_username');
-    await page.keyboard.type(username);
-
-    await page.screenshot({ path: '06-typed-in-username.png' });
-
-    console.debug("Type in password");
-    await page.waitForSelector("input#mx_RegistrationForm_password");
-    await page.click('input#mx_RegistrationForm_password');
-    await page.keyboard.type(password);
-
-    await page.screenshot({ path: '07-typed-in-password-once.png' });
-
-    console.debug("Type in password again");
-    await page.waitForSelector("input#mx_RegistrationForm_passwordConfirm");
-    await page.click('input#mx_RegistrationForm_passwordConfirm');
-    await page.keyboard.type(password);
-
-    await page.screenshot({ path: '08-typed-in-password-twice.png' });
-
-    console.debug("Click on [Register] to finish the account creation");
-    await page.waitForSelector("input.mx_Login_submit");
-    await page.click('input.mx_Login_submit');
-
-    await page.screenshot({ path: '09-clicked-on-register-button.png' });
-
-    // Waiting for the app to login can take some time, so be patient.
-    page.setDefaultTimeout(10000);
-
-    console.debug("Wait for chat window to show up");
-    await page.waitForSelector("div.mx_HomePage_default_buttons");
-    console.debug("Apparently the registration worked.");
-
-    await page.screenshot({ path: '10-logged-in-homescreen.png' });
-
-
-    // Close the browser and exit the script
-    await browser.close();
-}
@@ -1,15 +0,0 @@
-[global]
-
-# Server runs in same container as tests do, so localhost is fine
-server_name = "localhost"
-
-# With a bit of luck /tmp is a RAM disk, so that the file system does not become the bottleneck while testing
-database_path = "/tmp"
-
-# All the other settings are left at their defaults:
-port = 6167
-max_request_size = 20_000_000
-allow_registration = true
-trusted_servers = ["matrix.org"]
-address = "127.0.0.1"
-proxy = "none"
@@ -1 +1 @@
 .52
 .51.0