improvement: locks

improvement: efficient /sync, mutex for federation transactions
fix: stuck messages
2021-07-13 15:48:10 +02:00 · 2021-07-13 10:29:02 +02:00 · 2021-07-13 10:26:39 +02:00 · 2021-07-13 10:26:36 +02:00 · 2021-07-13 10:24:51 +02:00 · 2021-07-12 21:23:20 +02:00
68 changed files with 2278 additions and 3534 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
@@ -1,19 +1,19 @@
 stages:
-  - build
-  - build docker image
  - test
-  - upload artifacts
+  - build
+  - publish artifacts
+  - release nightly

 variables:
  GIT_SUBMODULE_STRATEGY: recursive
  FF_USE_FASTZIP: 1
  CACHE_COMPRESSION_LEVEL: fastest

+
 test:cargo:
  stage: "test"
  needs: []
  image: "rust:latest"
-  tags: ["docker"]
  variables:
    CARGO_HOME: "cargohome"
  cache:
@@ -29,66 +29,10 @@ test:cargo:
    - 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: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-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:cargo:x86_64-unknown-linux-gnu"
-  image: "buildkite/puppeteer:latest"
-  tags: ["docker"]
-  interruptible: true
-  script:
-    - "CONDUIT_CONFIG=tests/test-config.toml ./conduit-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
-
-
 # --------------------------------------------------------------------- #
 #  Cargo: Compiling for different architectures                         #
 # --------------------------------------------------------------------- #
@@ -100,7 +44,6 @@ test:register:element-web-stable:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
  interruptible: true
  image: "rust:latest"
-  tags: ["docker"]
  cache:
    paths:
      - cargohome
@@ -115,24 +58,18 @@ test:register:element-web-stable:
    - "apt-get install -yqq --no-install-recommends $NEEDED_PACKAGES"
    - "rustup target add $TARGET"
  script:
-    # Set some cargo tuning here, because targets overwrite the 'variables'
-    - "export CARGO_INCREMENTAL=true"
-    - "export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=16"
-    - "export CARGO_PROFILE_RELEASE_LTO=thin"
    - time cargo build --target $TARGET --release
    - 'mv "target/$TARGET/release/conduit" "conduit-$TARGET"'
+  artifacts:
+    name: "conduit-$TARGET"
+    expose_as: "Binary"
+    paths:
+      - "conduit-$TARGET"

 build:cargo:x86_64-unknown-linux-gnu:
  extends: .build-cargo-shared-settings
  variables:
    TARGET: "x86_64-unknown-linux-gnu"
-  rules:
-    - if: "$CI_COMMIT_BRANCH"
-  artifacts:
-    name: "conduit-x86_64-unknown-linux-gnu"
-    paths:
-      - "conduit-x86_64-unknown-linux-gnu"
-    expose_as: "Release binary x86_64-unknown-linux-gnu"

 build:cargo:armv7-unknown-linux-gnueabihf:
  extends: .build-cargo-shared-settings
@@ -142,11 +79,6 @@ build:cargo:armv7-unknown-linux-gnueabihf:
    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: "Release binary armv7-unknown-linux-gnueabihf"

 build:cargo:aarch64-unknown-linux-gnu:
  extends: .build-cargo-shared-settings
@@ -158,30 +90,6 @@ build:cargo:aarch64-unknown-linux-gnu:
    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: "Release binary aarch64-unknown-linux-gnu"
-
-build:cargo:x86_64-unknown-linux-musl:
-  extends: .build-cargo-shared-settings
-  image: "rust:alpine"
-  rules:
-    - if: '$CI_COMMIT_BRANCH' # Always run
-  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: "Release binary x86_64-unknown-linux-musl"


 # --------------------------------------------------------------------- #
@@ -196,7 +104,6 @@ build:cargo:x86_64-unknown-linux-musl:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
  interruptible: true
  image: "rust:latest"
-  tags: ["docker"]
  cache:
    paths:
      - cargohome
@@ -214,80 +121,35 @@ build:cargo:x86_64-unknown-linux-musl:
  script:
    - time cargo deb --target $TARGET
    - 'mv target/$TARGET/debian/*.deb "conduit-$TARGET.deb"'
+  artifacts:
+    name: "conduit-$TARGET.deb"
+    expose_as: "Debian Package"
+    paths:
+      - "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: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'
-
-
-# --------------------------------------------------------------------- #
-#  Store binaries as package so they have download urls                 #
+#  Storing and releasing compiled binaries                              #
 # --------------------------------------------------------------------- #

 publish:package:
-  stage: "upload artifacts"
+  stage: "publish artifacts"
  needs:
    - "build:cargo:x86_64-unknown-linux-gnu"
    - "build:cargo:armv7-unknown-linux-gnueabihf"
    - "build:cargo:aarch64-unknown-linux-gnu"
-    - "build: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:
@@ -295,7 +157,32 @@ publish:package:
    - '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"'


+
+publish:nightly:
+  stage: "release nightly"
+  image: registry.gitlab.com/gitlab-org/release-cli:latest
+  needs:
+    - job: "publish:package"
+      artifacts: false
+  variables:
+    GIT_STRATEGY: "none" # Don't need a clean copy of the code, we just operate on artifacts
+  script: "echo 'Releasing current state as release'"
+  rules:
+    - if: "$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH"           # Run this job on the main branch
+  release:
+    name: 'Nightly'
+    description: '⚠️ The latest development version of the day, fresh from the repository. Use at your own risk!'
+    tag_name: 'nightly'
+    assets: 
+      links:
+        - name: 'conduit-x86_64-unknown-linux-gnu'
+          url: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}/conduit-x86_64-unknown-linux-gnu"
+        - name: 'conduit-armv7-unknown-linux-gnueabihf'
+          url: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}/conduit-armv7-unknown-linux-gnueabihf"
+        - name: 'conduit-aarch64-unknown-linux-gnu'
+          url: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}/conduit-aarch64-unknown-linux-gnu"
+        - name: 'conduit-x86_64-unknown-linux-gnu.deb'
+          url: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}/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,44 +14,45 @@ 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 = { git = "https://github.com/ruma/ruma", rev = "eb19b0e08a901b87d11b3be0890ec788cc760492", 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 = "a2d93500e1dbc87e7032a3c74f3b2479a7f84e93", 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 = "174555857ef90d49e4b9a672be9e2fe0acdc2687", 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", "socks"] }
 # 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
@@ -59,33 +60,30 @@ 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"] }
-opentelemetry = "0.15.0"
-tracing-subscriber = "0.2.19"
-tracing-opentelemetry = "0.14.0"
-tracing-flame = "0.1.0"
-opentelemetry-jaeger = "0.14.0"
+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 }
+num_cpus = { version = "1.13.0", optional = true }

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

 [[bin]]
@@ -8,17 +8,10 @@ If you run into any problems while setting up Conduit, write an email to `timo@k

 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: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:cargo:x86_64-unknown-linux-musl
-[armv7-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-armv7-unknown-linux-gnueabihf?job=build:cargo:armv7-unknown-linux-gnueabihf
-[armv8-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-aarch64-unknown-linux-gnu?job=build:cargo:aarch64-unknown-linux-gnu
+- 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>
@@ -33,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.
@@ -114,13 +106,11 @@ allow_federation = true

 trusted_servers = ["matrix.org"]

+#db_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,6 +35,7 @@ max_request_size = 20_000_000 # in bytes

 trusted_servers = ["matrix.org"]

+#db_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
@@ -42,6 +43,3 @@ trusted_servers = ["matrix.org"]
 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

+#db_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"
@@ -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,
@@ -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 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")]
@@ -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,15 +236,15 @@ pub async fn register_route(

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

-        let mutex_state = Arc::clone(
+        let mutex = Arc::clone(
            db.globals
-                .roomid_mutex_state
+                .roomid_mutex
                .write()
                .unwrap()
                .entry(room_id.clone())
                .or_default(),
        );
-        let state_lock = mutex_state.lock().await;
+        let mutex_lock = mutex.lock().await;

        let mut content = ruma::events::room::create::CreateEventContent::new(conduit_user.clone());
        content.federate = true;
@@ -276,7 +263,7 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;

        // 2. Make conduit bot join
@@ -289,7 +276,6 @@ pub async fn register_route(
                    avatar_url: None,
                    is_direct: None,
                    third_party_invite: None,
-                    blurhash: None,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -299,7 +285,7 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;

        // 3. Power levels
@@ -324,7 +310,7 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;

        // 4.1 Join Rules
@@ -342,7 +328,7 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;

        // 4.2 History Visibility
@@ -362,7 +348,7 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;

        // 4.3 Guest Access
@@ -380,17 +366,18 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_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)))
+                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()),
@@ -399,7 +386,7 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;

        db.rooms.build_and_append_pdu(
@@ -416,7 +403,7 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;

        // Room alias
@@ -439,7 +426,7 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;

        db.rooms.set_alias(&alias, Some(&room_id), &db.globals)?;
@@ -454,7 +441,6 @@ pub async fn register_route(
                    avatar_url: None,
                    is_direct: None,
                    third_party_invite: None,
-                    blurhash: None,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -464,18 +450,17 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_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,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -485,7 +470,7 @@ pub async fn register_route(
            &user_id,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;

        // Send welcome message
@@ -504,13 +489,13 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;
    }

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

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

    Ok(register::Response {
        access_token: Some(token),
@@ -562,13 +547,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
@@ -586,9 +573,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`
@@ -652,27 +639,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(
+    for room_id in 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 {
+    ) {
        let room_id = room_id?;
        let event = member::MemberEventContent {
            membership: member::MembershipState::Leave,
@@ -680,18 +663,17 @@ pub async fn deactivate_route(
            avatar_url: None,
            is_direct: None,
            third_party_invite: None,
-            blurhash: None,
        };

-        let mutex_state = Arc::clone(
+        let mutex = Arc::clone(
            db.globals
-                .roomid_mutex_state
+                .roomid_mutex
                .write()
                .unwrap()
                .entry(room_id.clone())
                .or_default(),
        );
-        let state_lock = mutex_state.lock().await;
+        let mutex_lock = mutex.lock().await;

        db.rooms.build_and_append_pdu(
            PduBuilder {
@@ -704,7 +686,7 @@ pub async fn deactivate_route(
            &sender_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;
    }

@@ -713,7 +695,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,
@@ -721,17 +703,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> {
+    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())
 }
+*/
@@ -31,7 +31,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())
 }
@@ -47,7 +47,7 @@ pub async fn delete_alias_route(
 ) -> 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())
 }
@@ -85,7 +85,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"))
@@ -26,7 +26,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())
 }
@@ -44,9 +44,9 @@ pub async fn update_backup_route(
    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(
@@ -117,9 +117,9 @@ pub async fn delete_backup_route(

    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.
@@ -147,7 +147,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(),
@@ -179,7 +179,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(),
@@ -209,7 +209,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(),
@@ -288,7 +288,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(),
@@ -311,7 +311,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(),
@@ -334,7 +334,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();
@@ -43,9 +43,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(
@@ -78,9 +78,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(
@@ -98,7 +98,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."))?
@@ -129,7 +129,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."))?
@@ -71,9 +71,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(
@@ -112,20 +112,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(
@@ -164,20 +166,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,5 @@
-use std::convert::TryInto;
-
 use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Result, Ruma};
+use log::info;
 use ruma::{
    api::{
        client::{
@@ -23,7 +22,6 @@ use ruma::{
    serde::Raw,
    ServerName, UInt,
 };
-use tracing::{info, warn};

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post, put};
@@ -89,22 +87,22 @@ pub async fn set_room_visibility_route(
    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(
@@ -233,18 +231,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 +316,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,8 +1,7 @@
 use super::SESSION_ID_LENGTH;
 use crate::{database::DatabaseGuard, utils, ConduitResult, Database, Error, Result, Ruma};
 use ruma::{
-    api::{
-        client::{
+    api::client::{
        error::ErrorKind,
        r0::{
            keys::{
@@ -12,12 +11,9 @@ use ruma::{
            uiaa::{AuthFlow, UiaaInfo},
        },
    },
-        federation,
-    },
    encryption::UnsignedDeviceInfo,
    DeviceId, DeviceKeyAlgorithm, UserId,
 };
-use serde_json::json;
 use std::collections::{BTreeMap, HashSet};

 #[cfg(feature = "conduit_bin")]
@@ -64,7 +60,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)?,
@@ -88,8 +84,7 @@ pub async fn get_keys_route(
        &body.device_keys,
        |u| u == sender_user,
        &db,
-    )
-    .await?;
+    )?;

    Ok(response.into())
 }
@@ -103,9 +98,9 @@ pub async fn claim_keys_route(
    db: DatabaseGuard,
    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())
 }
@@ -146,13 +141,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 {
@@ -166,9 +163,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(
@@ -227,9 +224,9 @@ pub async fn upload_signatures_route(
        }
    }

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

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

 #[cfg_attr(
@@ -283,7 +280,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,
@@ -294,17 +291,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 = BTreeMap::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) {
@@ -362,60 +349,21 @@ pub async fn get_keys_helper<F: Fn(&UserId) -> bool>(
        }
    }

-    let mut failures = BTreeMap::new();
-
-    for (server, vec) in get_over_federation {
-        let mut device_keys_input_fed = BTreeMap::new();
-        for (user_id, keys) in vec {
-            device_keys_input_fed.insert(user_id.clone(), keys.clone());
-        }
-        match db
-            .sending
-            .send_federation_request(
-                &db.globals,
-                server,
-                federation::keys::get_keys::v1::Request {
-                    device_keys: device_keys_input_fed,
-                },
-            )
-            .await
-        {
-            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) =
@@ -430,26 +378,6 @@ pub async fn claim_keys_helper(
        one_time_keys.insert(user_id.clone(), container);
    }

-    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
-        let 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);
-    }
-
    Ok(claim_keys::Response {
        failures: BTreeMap::new(),
        one_time_keys,
@@ -52,7 +52,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"),
@@ -4,6 +4,7 @@ use crate::{
    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};
@@ -74,7 +74,7 @@ pub async fn join_room_by_id_route(
    )
    .await;

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

    ret
 }
@@ -125,7 +125,7 @@ pub async fn join_room_by_id_or_alias_route(
    )
    .await?;

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

    Ok(join_room_by_id_or_alias::Response {
        room_id: join_room_response.0.room_id,
@@ -146,7 +146,7 @@ pub async fn leave_room_route(

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

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

    Ok(leave_room::Response::new().into())
 }
@@ -164,8 +164,8 @@ pub async fn invite_user_route(

    if let invite_user::IncomingInvitationRecipient::UserId { user_id } = &body.recipient {
        invite_helper(sender_user, user_id, &body.room_id, &db, false).await?;
-        db.flush()?;
-        Ok(invite_user::Response {}.into())
+        db.flush().await?;
+        Ok(invite_user::Response.into())
    } else {
        Err(Error::BadRequest(ErrorKind::NotFound, "User not found."))
    }
@@ -203,15 +203,15 @@ pub async fn kick_user_route(
    event.membership = ruma::events::room::member::MembershipState::Leave;
    // TODO: reason

-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
        db.globals
-            .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(body.room_id.clone())
            .or_default(),
    );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;

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

-    drop(state_lock);
+    drop(mutex_lock);

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

    Ok(kick_user::Response::new().into())
 }
@@ -261,7 +261,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)?,
            }),
            |event| {
                let mut event = serde_json::from_value::<Raw<member::MemberEventContent>>(
@@ -275,15 +274,15 @@ pub async fn ban_user_route(
            },
        )?;

-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
        db.globals
-            .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(body.room_id.clone())
            .or_default(),
    );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;

    db.rooms.build_and_append_pdu(
        PduBuilder {
@@ -296,12 +295,12 @@ pub async fn ban_user_route(
        &sender_user,
        &body.room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

-    drop(state_lock);
+    drop(mutex_lock);

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

    Ok(ban_user::Response::new().into())
 }
@@ -337,15 +336,15 @@ pub async fn unban_user_route(

    event.membership = ruma::events::room::member::MembershipState::Leave;

-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
        db.globals
-            .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(body.room_id.clone())
            .or_default(),
    );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;

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

-    drop(state_lock);
+    drop(mutex_lock);

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

    Ok(unban_user::Response::new().into())
 }
@@ -381,7 +380,7 @@ pub async fn forget_room_route(

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

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

    Ok(forget_room::Response::new().into())
 }
@@ -486,15 +485,15 @@ async fn join_room_by_id_helper(
 ) -> ConduitResult<join_room_by_id::Response> {
    let sender_user = sender_user.expect("user is authenticated");

-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
        db.globals
-            .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(room_id.clone())
            .or_default(),
    );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.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() {
@@ -511,7 +510,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;
@@ -526,12 +525,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")),
        };

@@ -562,7 +556,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)?,
            })
            .expect("event is valid, we just created it"),
        );
@@ -612,7 +605,7 @@ async fn join_room_by_id_helper(
        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(
@@ -692,7 +685,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)?,
        };

        db.rooms.build_and_append_pdu(
@@ -706,13 +698,13 @@ async fn join_room_by_id_helper(
            &sender_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;
    }

-    drop(state_lock);
+    drop(mutex_lock);

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

    Ok(join_room_by_id::Response::new(room_id.clone()).into())
 }
@@ -788,18 +780,17 @@ pub async fn invite_helper<'a>(
    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(
+    let mutex = Arc::clone(
        db.globals
-                    .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(room_id.clone())
            .or_default(),
    );
-            let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;

+    if user_id.server_name() != db.globals.server_name() {
        let prev_events = db
            .rooms
            .get_pdu_leaves(room_id)?
@@ -834,8 +825,7 @@ pub async fn invite_helper<'a>(
            .map_or(RoomVersionId::Version6, |create_event| {
                create_event.room_version
            });
-            let room_version =
-                RoomVersion::new(&room_version_id).expect("room version is supported");
+        let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");

        let content = serde_json::to_value(MemberEventContent {
            avatar_url: None,
@@ -843,20 +833,15 @@ pub async fn invite_helper<'a>(
            is_direct: Some(is_direct),
            membership: MembershipState::Invite,
            third_party_invite: None,
-                blurhash: 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,
-            )?;
+        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
@@ -940,13 +925,9 @@ pub async fn invite_helper<'a>(
        )
        .expect("event is valid, we just created it");

+        drop(mutex_lock);
+
        let invite_room_state = db.rooms.calculate_invite_state(&pdu)?;
-
-            drop(state_lock);
-
-            (room_version_id, pdu_json, invite_room_state)
-        };
-
        let response = db
            .sending
            .send_federation_request(
@@ -955,7 +936,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,
                },
@@ -1018,16 +999,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,
@@ -1037,7 +1008,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)?,
            })
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -1047,10 +1017,8 @@ pub async fn invite_helper<'a>(
        &sender_user,
        room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

-    drop(state_lock);
-
    Ok(())
 }
@@ -28,15 +28,15 @@ pub async fn send_message_event_route(
    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(
+    let mutex = Arc::clone(
        db.globals
-            .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(body.room_id.clone())
            .or_default(),
    );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;

    // Check if this is a new transaction id
    if let Some(response) =
@@ -75,7 +75,7 @@ pub async fn send_message_event_route(
        &sender_user,
        &body.room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

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

-    drop(state_lock);
+    drop(mutex_lock);

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

    Ok(send_message_event::Response::new(event_id).into())
 }
@@ -75,5 +75,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())
 }
@@ -41,9 +41,9 @@ pub async fn set_presence_route(
        )?;
    }

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

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

 #[cfg_attr(
@@ -1,14 +1,11 @@
 use crate::{database::DatabaseGuard, pdu::PduBuilder, utils, ConduitResult, Error, Ruma};
 use ruma::{
-    api::{
-        client::{
+    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,
 };
@@ -32,10 +29,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 +69,19 @@ pub async fn set_displayname_route(
        })
        .filter_map(|r| r.ok())
    {
-        let mutex_state = Arc::clone(
+        let mutex = Arc::clone(
            db.globals
-                .roomid_mutex_state
+                .roomid_mutex
                .write()
                .unwrap()
                .entry(room_id.clone())
                .or_default(),
        );
-        let state_lock = mutex_state.lock().await;
+        let mutex_lock = mutex.lock().await;

        let _ =
            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, &mutex_lock);

        // Presence update
        db.rooms.edus.update_presence(
@@ -110,9 +106,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(
@@ -124,25 +120,6 @@ pub async fn get_displayname_route(
    db: DatabaseGuard,
    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)?,
    }
@@ -163,13 +140,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 +181,19 @@ pub async fn set_avatar_url_route(
        })
        .filter_map(|r| r.ok())
    {
-        let mutex_state = Arc::clone(
+        let mutex = Arc::clone(
            db.globals
-                .roomid_mutex_state
+                .roomid_mutex
                .write()
                .unwrap()
                .entry(room_id.clone())
                .or_default(),
        );
-        let state_lock = mutex_state.lock().await;
+        let mutex_lock = mutex.lock().await;

        let _ =
            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, &mutex_lock);

        // Presence update
        db.rooms.edus.update_presence(
@@ -244,9 +218,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(
@@ -258,29 +232,8 @@ pub async fn get_avatar_url_route(
    db: DatabaseGuard,
    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())
 }
@@ -294,27 +247,6 @@ pub async fn get_profile_route(
    db: DatabaseGuard,
    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 +257,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())
@@ -81,7 +81,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 {
@@ -181,7 +181,7 @@ pub async fn set_pushrule_route(
                .into(),
            );
        }
-        _ => {}
+        RuleKind::_Custom(_) => {}
    }

    db.account_data.update(
@@ -192,9 +192,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(
@@ -245,10 +245,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(),
@@ -314,7 +314,7 @@ pub async fn set_pushrule_actions_route(
                global.content.replace(rule);
            }
        }
-        _ => {}
+        RuleKind::_Custom(_) => {}
    };

    db.account_data.update(
@@ -325,9 +325,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(
@@ -383,10 +383,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())
 }
@@ -454,7 +454,7 @@ pub async fn set_pushrule_enabled_route(
                global.content.insert(rule);
            }
        }
-        _ => {}
+        RuleKind::_Custom(_) => {}
    }

    db.account_data.update(
@@ -465,9 +465,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(
@@ -523,7 +523,7 @@ pub async fn delete_pushrule_route(
                global.content.remove(&rule);
            }
        }
-        _ => {}
+        RuleKind::_Custom(_) => {}
    }

    db.account_data.update(
@@ -534,9 +534,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(
@@ -570,7 +570,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())
 }
@@ -75,9 +75,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(
@@ -128,7 +128,7 @@ pub async fn create_receipt_route(
        &db.globals,
    )?;

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

-    Ok(create_receipt::Response {}.into())
+    Ok(create_receipt::Response.into())
 }
@@ -20,15 +20,15 @@ pub async fn redact_event_route(
 ) -> ConduitResult<redact_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
        db.globals
-            .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(body.room_id.clone())
            .or_default(),
    );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;

    let event_id = db.rooms.build_and_append_pdu(
        PduBuilder {
@@ -44,12 +44,12 @@ pub async fn redact_event_route(
        &sender_user,
        &body.room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

-    drop(state_lock);
+    drop(mutex_lock);

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

    Ok(redact_event::Response { event_id }.into())
 }
@@ -2,10 +2,11 @@ use crate::{
    client_server::invite_helper, database::DatabaseGuard, pdu::PduBuilder, ConduitResult, 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 +16,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};
@@ -33,15 +33,15 @@ pub async fn create_room_route(

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

-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
        db.globals
-            .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(room_id.clone())
            .or_default(),
    );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;

    let alias = body
        .room_alias_name
@@ -65,19 +65,7 @@ pub async fn create_room_route(
    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(
@@ -91,7 +79,7 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

    // 2. Let the room creator join
@@ -104,7 +92,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)?,
            })
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -114,7 +101,7 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

    // 3. Power levels
@@ -126,7 +113,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();
@@ -169,7 +156,7 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

    // 4. Events set by preset
@@ -196,7 +183,7 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

    // 4.2 History Visibility
@@ -214,7 +201,7 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

    // 4.3 Guest Access
@@ -240,15 +227,15 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

    // 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() {
@@ -256,7 +243,7 @@ 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, &mutex_lock)?;
    }

    // 6. Events implied by name and topic
@@ -264,7 +251,11 @@ pub async fn create_room_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomName,
-                content: serde_json::to_value(name::NameEventContent::new(Some(name.clone())))
+                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()),
@@ -273,7 +264,7 @@ pub async fn create_room_route(
            &sender_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;
    }

@@ -292,12 +283,12 @@ pub async fn create_room_route(
            &sender_user,
            &room_id,
            &db,
-            &state_lock,
+            &mutex_lock,
        )?;
    }

    // 7. Events implied by invite (and TODO: invite_3pid)
-    drop(state_lock);
+    drop(mutex_lock);
    for user_id in &body.invite {
        let _ = invite_helper(sender_user, user_id, &room_id, &db, body.is_direct).await;
    }
@@ -313,7 +304,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())
 }
@@ -348,47 +339,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,
    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.",
@@ -398,15 +359,15 @@ pub async fn upgrade_room_route(
    // Create a replacement room
    let replacement_room = RoomId::new(db.globals.server_name());

-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
        db.globals
-            .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(body.room_id.clone())
            .or_default(),
    );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.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
@@ -425,21 +386,9 @@ pub async fn upgrade_room_route(
        sender_user,
        &body.room_id,
        &db,
-        &state_lock,
+        &mutex_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
@@ -478,7 +427,7 @@ pub async fn upgrade_room_route(
        sender_user,
        &replacement_room,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

    // Join the new room
@@ -491,7 +440,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)?,
            })
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -501,7 +449,7 @@ pub async fn upgrade_room_route(
        sender_user,
        &replacement_room,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

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

@@ -579,12 +527,12 @@ pub async fn upgrade_room_route(
        sender_user,
        &body.room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

-    drop(state_lock);
+    drop(mutex_lock);

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

    // Return the replacement room id
    Ok(upgrade_room::Response { replacement_room }.into())
@@ -1,5 +1,6 @@
 use super::{DEVICE_ID_LENGTH, TOKEN_LENGTH};
 use crate::{database::DatabaseGuard, utils, ConduitResult, Error, Ruma};
+use log::info;
 use ruma::{
    api::client::{
        error::ErrorKind,
@@ -8,7 +9,6 @@ use ruma::{
    UserId,
 };
 use serde::Deserialize;
-use tracing::info;

 #[derive(Debug, Deserialize)]
 struct Claims {
@@ -143,7 +143,7 @@ pub async fn login_route(

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

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

    Ok(login::Response {
        user_id,
@@ -175,7 +175,7 @@ pub async fn logout_route(

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

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

    Ok(logout::Response::new().into())
 }
@@ -204,7 +204,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())
 }
@@ -43,7 +43,7 @@ pub async fn send_state_event_for_key_route(
    )
    .await?;

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

    Ok(send_state_event::Response { event_id }.into())
 }
@@ -69,7 +69,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())
 }
@@ -259,15 +259,15 @@ pub async fn send_state_event_for_key_helper(
        }
    }

-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
        db.globals
-            .roomid_mutex_state
+            .roomid_mutex
            .write()
            .unwrap()
            .entry(room_id.clone())
            .or_default(),
    );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;

    let event_id = db.rooms.build_and_append_pdu(
        PduBuilder {
@@ -280,7 +280,7 @@ pub async fn send_state_event_for_key_helper(
        &sender_user,
        &room_id,
        &db,
-        &state_lock,
+        &mutex_lock,
    )?;

    Ok(event_id)
@@ -1,4 +1,5 @@
 use crate::{database::DatabaseGuard, 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 +7,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, warn};

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, tokio};
@@ -186,22 +186,20 @@ 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(
+        let mutex = Arc::clone(
            db.globals
-                .roomid_mutex_insert
+                .roomid_mutex
                .write()
                .unwrap()
                .entry(room_id.clone())
                .or_default(),
        );
-        let insert_lock = mutex_insert.lock().unwrap();
-        drop(insert_lock);
+        let mutex_lock = mutex.lock().await;
+        drop(mutex_lock);

        let mut non_timeline_pdus = db
            .rooms
@@ -264,12 +262,8 @@ async fn sync_helper(
                db.rooms
                    .pdu_shortstatehash(&pdu.1.event_id)
                    .transpose()
-                    .ok_or_else(|| {
-                        warn!("PDU without state: {}", pdu.1.event_id);
-                        Error::bad_database("Found PDU without state")
+                    .expect("all pdus have state")
            })
-            })
-            .transpose()?
            .transpose()?;

        // Calculates joined_member_count, invited_member_count and heroes
@@ -423,10 +417,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
@@ -631,10 +622,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
@@ -660,21 +651,20 @@ 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(
+        let mutex = Arc::clone(
            db.globals
-                .roomid_mutex_insert
+                .roomid_mutex
                .write()
                .unwrap()
                .entry(room_id.clone())
                .or_default(),
        );
-        let insert_lock = mutex_insert.lock().unwrap();
-        drop(insert_lock);
+        let mutex_lock = mutex.lock().await;
+        drop(mutex_lock);

        let left_count = db.rooms.get_left_count(&room_id, &sender_user)?;

@@ -700,21 +690,20 @@ 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(
+        let mutex = Arc::clone(
            db.globals
-                .roomid_mutex_insert
+                .roomid_mutex
                .write()
                .unwrap()
                .entry(room_id.clone())
                .or_default(),
        );
-        let insert_lock = mutex_insert.lock().unwrap();
-        drop(insert_lock);
+        let mutex_lock = mutex.lock().await;
+        drop(mutex_lock);

        let invite_count = db.rooms.get_invite_count(&room_id, &sender_user)?;

@@ -764,7 +753,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
@@ -40,9 +40,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(
@@ -74,9 +74,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(
@@ -1,12 +1,6 @@
-use std::collections::BTreeMap;
-
 use crate::{database::DatabaseGuard, ConduitResult, 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,
 };

@@ -39,28 +33,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"),
-                )?;
-
-                continue;
-            }
-
            match target_device_id_maybe {
                DeviceIdOrAllDevices::DeviceId(target_device_id) => db.users.add_to_device_event(
                    sender_user,
@@ -95,7 +67,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())
 }
@@ -29,5 +29,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())
 }
@@ -25,22 +25,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
+            .contains(&body.search_term.to_lowercase())
+            && 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 {
+                .is_none()
+        {
            return None;
        }

@@ -17,26 +17,24 @@ 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},
+    outcome::IntoOutcome,
    request::{FromRequest, Request},
-    Shutdown, State,
+    try_outcome, State,
 };
-use ruma::{DeviceId, RoomId, ServerName, UserId};
+use ruma::{DeviceId, ServerName, UserId};
 use serde::{de::IgnoredAny, Deserialize};
 use std::{
    collections::{BTreeMap, HashMap},
-    convert::TryFrom,
    fs::{self, remove_dir_all},
    io::Write,
    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;

@@ -44,10 +42,16 @@ use self::proxy::ProxyConfig;
 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_db_cache_capacity")]
+    db_cache_capacity: u32,
+    #[serde(default = "default_sqlite_read_pool_size")]
+    sqlite_read_pool_size: usize,
+    #[serde(default = "false_fn")]
+    sqlite_wal_clean_timer: bool,
    #[serde(default = "default_sqlite_wal_clean_second_interval")]
    sqlite_wal_clean_second_interval: u32,
+    #[serde(default = "default_sqlite_wal_clean_second_timeout")]
+    sqlite_wal_clean_second_timeout: u32,
    #[serde(default = "default_max_request_size")]
    max_request_size: u32,
    #[serde(default = "default_max_concurrent_requests")]
@@ -60,8 +64,6 @@ 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>,
@@ -84,12 +86,12 @@ impl Config {
            .keys()
            .filter(|key| DEPRECATED_KEYS.iter().any(|s| s == key))
        {
-            warn!("Config parameter {} is deprecated", key);
+            log::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");
+            log::warn!("Read conduit documentation and check your configuration if any new configuration parameters should be adjusted");
        }
    }
 }
@@ -102,12 +104,20 @@ fn true_fn() -> bool {
    true
 }

-fn default_db_cache_capacity_mb() -> f64 {
-    200.0
+fn default_db_cache_capacity() -> u32 {
+    1024 * 1024 * 1024
+}
+
+fn default_sqlite_read_pool_size() -> usize {
+    num_cpus::get().max(1)
 }

 fn default_sqlite_wal_clean_second_interval() -> u32 {
-    15 * 60 // every 15 minutes
+    60
+}
+
+fn default_sqlite_wal_clean_second_timeout() -> u32 {
+    2
 }

 fn default_max_request_size() -> u32 {
@@ -125,12 +135,12 @@ fn default_log() -> String {
 #[cfg(feature = "sled")]
 pub type Engine = abstraction::sled::Engine;

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

-#[cfg(feature = "heed")]
-pub type Engine = abstraction::heed::Engine;
-
 pub struct Database {
    _db: Arc<Engine>,
    pub globals: globals::Globals,
@@ -160,37 +170,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<TokioRwLock<Self>>> {
        let builder = Engine::open(&config)?;

        if config.max_request_size < 1024 {
@@ -206,7 +187,6 @@ impl Database {
                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")?,
@@ -250,7 +230,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")?,
@@ -269,14 +248,11 @@ impl Database {
                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(100_000)),
-                shorteventid_cache: Mutex::new(LruCache::new(1_000_000)),
+                prevevent_parent: builder.open_tree("prevevent_parent")?,
+                pdu_cache: RwLock::new(LruCache::new(10_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")?,
@@ -291,8 +267,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,
            },
@@ -362,7 +338,7 @@ impl Database {
            if db.globals.database_version()? < 3 {
                // Move media to filesystem
                for (key, content) in db.media.mediaid_file.iter() {
-                    if content.is_empty() {
+                    if content.len() == 0 {
                        continue;
                    }

@@ -399,45 +375,6 @@ impl Database {

                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 {
-                // TODO update to 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");
-            }
        }

        let guard = db.read().await;
@@ -453,26 +390,11 @@ impl Database {
        drop(guard);

        #[cfg(feature = "sqlite")]
-        {
-            Self::start_wal_clean_task(Arc::clone(&db), &config).await;
-        }
+        Self::start_wal_clean_task(&db, &config).await;

        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();
@@ -499,16 +421,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()) {
@@ -543,7 +455,7 @@ impl Database {

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

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

@@ -573,62 +485,78 @@ impl Database {
        futures.next().await;
    }

-    #[tracing::instrument(skip(self))]
-    pub fn flush(&self) -> Result<()> {
+    pub async fn flush(&self) -> Result<()> {
        let start = std::time::Instant::now();

        let res = self._db.flush();

-        debug!("flush: took {:?}", start.elapsed());
+        log::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;
+    pub async fn start_wal_clean_task(lock: &Arc<TokioRwLock<Self>>, config: &Config) {
+        use tokio::{
+            select,
+            signal::unix::{signal, SignalKind},
+            time::{interval, timeout},
+        };

-        #[cfg(unix)]
-        use tokio::signal::unix::{signal, SignalKind};
-        use tracing::info;
+        use std::{
+            sync::Weak,
+            time::{Duration, Instant},
+        };

-        use std::time::{Duration, Instant};
+        let weak: Weak<TokioRwLock<Database>> = Arc::downgrade(&lock);

+        let lock_timeout = Duration::from_secs(config.sqlite_wal_clean_second_timeout as u64);
        let timer_interval = Duration::from_secs(config.sqlite_wal_clean_second_interval as u64);
+        let do_timer = config.sqlite_wal_clean_timer;

        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");
+                select! {
+                    _ = i.tick(), if do_timer => {
+                        log::info!(target: "wal-trunc", "Timer ticked")
                    }
                    _ = s.recv() => {
-                        info!("wal-trunc: Received SIGHUP");
+                        log::info!(target: "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);
+                if let Some(arc) = Weak::upgrade(&weak) {
+                    log::info!(target: "wal-trunc", "Rotating sync helpers...");
+                    // This actually creates a very small race condition between firing this and trying to acquire the subsequent write lock.
+                    // Though it is not a huge deal if the write lock doesn't "catch", as it'll harmlessly time out.
+                    arc.read().await.globals.rotate.fire();
+
+                    log::info!(target: "wal-trunc", "Locking...");
+                    let guard = {
+                        if let Ok(guard) = timeout(lock_timeout, arc.write()).await {
+                            guard
                        } else {
-                    info!("wal-trunc: Flushed in {:?}", start.elapsed());
+                            log::info!(target: "wal-trunc", "Lock failed in timeout, canceled.");
+                            continue;
+                        }
+                    };
+                    log::info!(target: "wal-trunc", "Locked, flushing...");
+                    let start = Instant::now();
+                    if let Err(e) = guard.flush_wal() {
+                        log::error!(target: "wal-trunc", "Errored: {}", e);
+                    } else {
+                        log::info!(target: "wal-trunc", "Flushed in {:?}", start.elapsed());
+                    }
+                } else {
+                    break;
                }
            }
        });
@@ -650,14 +578,14 @@ 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);
+        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)
+impl Into<DatabaseGuard> for OwnedRwLockReadGuard<Database> {
+    fn into(self) -> DatabaseGuard {
+        DatabaseGuard(self)
    }
 }
@@ -3,15 +3,15 @@ use crate::Result;

 use std::{future::Future, pin::Pin, sync::Arc};

+#[cfg(feature = "rocksdb")]
+pub mod rocksdb;
+
 #[cfg(feature = "sled")]
 pub mod sled;

 #[cfg(feature = "sqlite")]
 pub mod sqlite;

-#[cfg(feature = "heed")]
-pub mod heed;
-
 pub trait DatabaseEngine: Sized {
    fn open(config: &Config) -> Result<Arc<Self>>;
    fn open_tree(self: &Arc<Self>, name: &'static str) -> Result<Arc<dyn Tree>>;
@@ -22,24 +22,23 @@ 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 = (Vec<u8>, Vec<u8>)> + Send + 'a>;

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

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

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

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

@@ -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();
-        })
-    }
-}
@@ -0,0 +1,176 @@
+use super::super::Config;
+use crate::{utils, Result};
+
+use std::{future::Future, pin::Pin, sync::Arc};
+
+use super::{DatabaseEngine, Tree};
+
+use std::{collections::BTreeMap, sync::RwLock};
+
+pub struct Engine(rocksdb::DBWithThreadMode<rocksdb::MultiThreaded>);
+
+pub struct RocksDbEngineTree<'a> {
+    db: Arc<Engine>,
+    name: &'a str,
+    watchers: RwLock<BTreeMap<Vec<u8>, Vec<tokio::sync::oneshot::Sender<()>>>>,
+}
+
+impl DatabaseEngine for Engine {
+    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(Engine(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()),
+        }))
+    }
+}
+
+impl RocksDbEngineTree<'_> {
+    fn cf(&self) -> rocksdb::BoundColumnFamily<'_> {
+        self.db.0.cf_handle(self.name).unwrap()
+    }
+}
+
+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 = (Vec<u8>, Vec<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 = (Vec<u8>, Vec<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 = (Vec<u8>, Vec<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,7 +1,7 @@
 use super::super::Config;
 use crate::{utils, Result};
+use log::warn;
 use std::{future::Future, pin::Pin, sync::Arc};
-use tracing::warn;

 use super::{DatabaseEngine, Tree};

@@ -14,7 +14,7 @@ impl DatabaseEngine for Engine {
        Ok(Arc::new(Engine(
            sled::Config::default()
                .path(&config.database_path)
-                .cache_capacity((config.db_cache_capacity_mb * 1024.0 * 1024.0) as u64)
+                .cache_capacity(config.db_cache_capacity as u64)
                .use_compression(true)
                .open()?,
        )))
@@ -39,21 +39,12 @@ impl Tree for SledEngineTree {
        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> {
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> {
        Box::new(
            self.0
                .iter()
@@ -71,7 +62,7 @@ impl Tree for SledEngineTree {
        &self,
        from: &[u8],
        backwards: bool,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)>> {
+    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send> {
        let iter = if backwards {
            self.0.range(..=from)
        } else {
@@ -104,7 +95,7 @@ impl Tree for SledEngineTree {
    fn scan_prefix<'a>(
        &'a self,
        prefix: Vec<u8>,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> {
+    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> {
        let iter = self
            .0
            .scan_prefix(prefix)
@@ -1,59 +1,94 @@
-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,
+    collections::BTreeMap,
    future::Future,
+    ops::Deref,
    path::{Path, PathBuf},
    pin::Pin,
    sync::Arc,
+    thread,
    time::{Duration, Instant},
 };
+
+use crate::{database::Config, Result};
+
+use super::{DatabaseEngine, Tree};
+
+use log::debug;
+
+use crossbeam::channel::{bounded, Sender as ChannelSender};
+use parking_lot::{Mutex, MutexGuard, RwLock};
+use rusqlite::{params, Connection, DatabaseName::Main, OptionalExtension};
+
 use tokio::sync::oneshot::Sender;
-use tracing::debug;

-thread_local! {
-    static READ_CONNECTION: RefCell<Option<&'static Connection>> = RefCell::new(None);
-}
+// const SQL_CREATE_TABLE: &str =
+//     "CREATE TABLE IF NOT EXISTS {} {{ \"key\" BLOB PRIMARY KEY, \"value\" BLOB NOT NULL }}";
+// const SQL_SELECT: &str = "SELECT value FROM {} WHERE key = ?";
+// const SQL_INSERT: &str = "INSERT OR REPLACE INTO {} (key, value) VALUES (?, ?)";
+// const SQL_DELETE: &str = "DELETE FROM {} WHERE key = ?";
+// const SQL_SELECT_ITER: &str = "SELECT key, value FROM {}";
+// const SQL_SELECT_PREFIX: &str = "SELECT key, value FROM {} WHERE key LIKE ?||'%' ORDER BY key ASC";
+// const SQL_SELECT_ITER_FROM_FORWARDS: &str = "SELECT key, value FROM {} WHERE key >= ? ORDER BY ASC";
+// const SQL_SELECT_ITER_FROM_BACKWARDS: &str =
+//     "SELECT key, value FROM {} WHERE key <= ? ORDER BY DESC";

-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 {
+struct Pool {
    writer: Mutex<Connection>,
-
+    readers: Vec<Mutex<Connection>>,
+    spill_tracker: Arc<()>,
    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)?;
+pub const MILLI: Duration = Duration::from_millis(1);

-        conn.pragma_update(Some(Main), "page_size", &32768)?;
-        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", &0)?;
+enum HoldingConn<'a> {
+    FromGuard(MutexGuard<'a, Connection>),
+    FromOwned(Connection, Arc<()>),
+}
+
+impl<'a> Deref for HoldingConn<'a> {
+    type Target = Connection;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            HoldingConn::FromGuard(guard) => guard.deref(),
+            HoldingConn::FromOwned(conn, _) => conn,
+        }
+    }
+}
+
+impl Pool {
+    fn new<P: AsRef<Path>>(path: P, num_readers: usize, cache_size: u32) -> Result<Self> {
+        let writer = Mutex::new(Self::prepare_conn(&path, Some(cache_size))?);
+
+        let mut readers = Vec::new();
+
+        for _ in 0..num_readers {
+            readers.push(Mutex::new(Self::prepare_conn(&path, Some(cache_size))?))
+        }
+
+        Ok(Self {
+            writer,
+            readers,
+            spill_tracker: Arc::new(()),
+            path: path.as_ref().to_path_buf(),
+        })
+    }
+
+    fn prepare_conn<P: AsRef<Path>>(path: P, cache_size: Option<u32>) -> Result<Connection> {
+        let conn = Connection::open(path)?;
+
+        conn.pragma_update(Some(Main), "journal_mode", &"WAL".to_owned())?;
+
+        // conn.pragma_update(Some(Main), "wal_autocheckpoint", &250)?;
+
+        // conn.pragma_update(Some(Main), "wal_checkpoint", &"FULL".to_owned())?;
+
+        conn.pragma_update(Some(Main), "synchronous", &"OFF".to_owned())?;
+
+        if let Some(cache_kib) = cache_size {
+            conn.pragma_update(Some(Main), "cache_size", &(-Into::<i64>::into(cache_kib)))?;
+        }

        Ok(conn)
    }
@@ -62,76 +97,102 @@ impl Engine {
        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);
+    fn read_lock(&self) -> HoldingConn<'_> {
+        for r in &self.readers {
+            if let Some(reader) = r.try_lock() {
+                return HoldingConn::FromGuard(reader);
+            }
        }

-            connection.unwrap()
-        })
+        let spill_arc = self.spill_tracker.clone();
+        let now_count = Arc::strong_count(&spill_arc) - 1 /* because one is held by the pool */;
+
+        log::warn!("read_lock: all readers locked, creating spillover reader...");
+
+        if now_count > 1 {
+            log::warn!("read_lock: now {} spillover readers exist", now_count);
        }

-    pub fn flush_wal(self: &Arc<Self>) -> Result<()> {
-        self.write_lock()
-            .pragma_update(Some(Main), "wal_checkpoint", &"TRUNCATE")?;
-        Ok(())
+        let spilled = Self::prepare_conn(&self.path, None).unwrap();
+
+        return HoldingConn::FromOwned(spilled, spill_arc);
    }
 }

+pub struct Engine {
+    pool: Pool,
+}
+
 impl DatabaseEngine for Engine {
    fn open(config: &Config) -> Result<Arc<Self>> {
-        let path = Path::new(&config.database_path).join("conduit.db");
+        let pool = Pool::new(
+            Path::new(&config.database_path).join("conduit.db"),
+            config.sqlite_read_pool_size,
+            config.db_cache_capacity / 1024, // bytes -> kb
+        )?;

-        // 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;
+        pool.write_lock()
+            .execute("CREATE TABLE IF NOT EXISTS _noop (\"key\" INT)", params![])?;

-        let writer = Mutex::new(Self::prepare_conn(&path, cache_size_per_thread)?);
-
-        let arc = Arc::new(Engine {
-            writer,
-            path,
-            cache_size_per_thread,
-        });
+        let arc = Arc::new(Engine { pool });

        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), [])?;
+        self.pool.write_lock().execute(format!("CREATE TABLE IF NOT EXISTS {} ( \"key\" BLOB PRIMARY KEY, \"value\" BLOB NOT NULL )", name).as_str(), [])?;

        Ok(Arc::new(SqliteTable {
            engine: Arc::clone(self),
            name: name.to_owned(),
-            watchers: RwLock::new(HashMap::new()),
+            watchers: RwLock::new(BTreeMap::new()),
        }))
    }

    fn flush(self: &Arc<Self>) -> Result<()> {
-        // we enabled PRAGMA synchronous=normal, so this should not be necessary
-        Ok(())
+        self.pool
+            .write_lock()
+            .execute_batch(
+                "
+            PRAGMA synchronous=FULL;
+            BEGIN;
+                DELETE FROM _noop;
+                INSERT INTO _noop VALUES (1);
+            COMMIT;
+            PRAGMA synchronous=OFF;
+            ",
+            )
+            .map_err(Into::into)
+    }
+}
+
+impl Engine {
+    pub fn flush_wal(self: &Arc<Self>) -> Result<()> {
+        self.pool
+            .write_lock()
+            .execute_batch(
+                "
+            PRAGMA synchronous=FULL; PRAGMA wal_checkpoint=TRUNCATE;
+            BEGIN;
+                DELETE FROM _noop;
+                INSERT INTO _noop VALUES (1);
+            COMMIT;
+            PRAGMA wal_checkpoint=PASSIVE; PRAGMA synchronous=OFF;
+            ",
+            )
+            .map_err(Into::into)
    }
 }

 pub struct SqliteTable {
    engine: Arc<Engine>,
    name: String,
-    watchers: RwLock<HashMap<Vec<u8>, Vec<Sender<()>>>>,
+    watchers: RwLock<BTreeMap<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())?
@@ -139,11 +200,10 @@ impl SqliteTable {
            .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 (?, ?)",
+                "INSERT INTO {} (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
                self.name
            )
            .as_str(),
@@ -151,18 +211,63 @@ impl SqliteTable {
        )?;
        Ok(())
    }
+
+    fn _iter_from_thread<F>(&self, f: F) -> Box<dyn Iterator<Item = TupleOfBytes> + Send>
+    where
+        F: (for<'a> FnOnce(&'a Connection, ChannelSender<TupleOfBytes>)) + Send + 'static,
+    {
+        let (s, r) = bounded::<TupleOfBytes>(5);
+
+        let engine = self.engine.clone();
+
+        thread::spawn(move || {
+            let _ = f(&engine.pool.read_lock(), s);
+        });
+
+        Box::new(r.into_iter())
+    }
+}
+
+macro_rules! iter_from_thread {
+    ($self:expr, $sql:expr, $param:expr) => {
+        $self._iter_from_thread(move |guard, s| {
+            let _ = guard
+                .prepare($sql)
+                .unwrap()
+                .query_map($param, |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
+                .unwrap()
+                .map(|r| r.unwrap())
+                .try_for_each(|bob| s.send(bob));
+        })
+    };
 }

 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)
+        let guard = self.engine.pool.read_lock();
+
+        // let start = Instant::now();
+
+        let val = self.get_with_guard(&guard, key);
+
+        // debug!("get:       took {:?}", start.elapsed());
+        // debug!("get key: {:?}", &key)
+
+        val
    }

-    #[tracing::instrument(skip(self, key, value))]
    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()> {
-        let guard = self.engine.write_lock();
+        let guard = self.engine.pool.write_lock();
+
+        let start = Instant::now();
+
        self.insert_with_guard(&guard, key, value)?;
+
+        let elapsed = start.elapsed();
+        if elapsed > MILLI {
+            debug!("insert:    took {:012?} : {}", elapsed, &self.name);
+        }
+
        drop(guard);

        let watchers = self.watchers.read();
@@ -190,121 +295,69 @@ impl Tree for SqliteTable {
        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, key))]
    fn remove(&self, key: &[u8]) -> Result<()> {
-        let guard = self.engine.write_lock();
+        let guard = self.engine.pool.write_lock();
+
+        let start = Instant::now();

        guard.execute(
            format!("DELETE FROM {} WHERE key = ?", self.name).as_str(),
            [key],
        )?;

+        let elapsed = start.elapsed();
+
+        if elapsed > MILLI {
+            debug!("remove:    took {:012?} : {}", elapsed, &self.name);
+        }
+        // debug!("remove key: {:?}", &key);
+
        Ok(())
    }

-    #[tracing::instrument(skip(self))]
-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
-        let guard = self.engine.read_lock();
-
-        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,
-        })
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = TupleOfBytes> + Send + 'a> {
+        let name = self.name.clone();
+        iter_from_thread!(
+            self,
+            format!("SELECT key, value FROM {}", name).as_str(),
+            params![]
+        )
    }

-    #[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();
+    ) -> Box<dyn Iterator<Item = TupleOfBytes> + Send + 'a> {
+        let name = self.name.clone();
        let from = from.to_vec(); // TODO change interface?
-
        if backwards {
-            let statement = Box::leak(Box::new(
-                guard
-                    .prepare(&format!(
+            iter_from_thread!(
+                self,
+                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,
-            })
+                    name
+                )
+                .as_str(),
+                [from]
+            )
        } else {
-            let statement = Box::leak(Box::new(
-                guard
-                    .prepare(&format!(
+            iter_from_thread!(
+                self,
+                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,
-            })
+                    name
+                )
+                .as_str(),
+                [from]
+            )
        }
    }

-    #[tracing::instrument(skip(self, key))]
    fn increment(&self, key: &[u8]) -> Result<Vec<u8>> {
-        let guard = self.engine.write_lock();
+        let guard = self.engine.pool.write_lock();
+
+        let start = Instant::now();

        let old = self.get_with_guard(&guard, key)?;

@@ -313,18 +366,36 @@ impl Tree for SqliteTable {

        self.insert_with_guard(&guard, key, &new)?;

+        let elapsed = start.elapsed();
+
+        if elapsed > MILLI {
+            debug!("increment: took {:012?} : {}", elapsed, &self.name);
+        }
+        // debug!("increment key: {:?}", &key);
+
        Ok(new)
    }

-    #[tracing::instrument(skip(self, prefix))]
-    fn scan_prefix<'a>(&'a self, prefix: Vec<u8>) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
+    fn scan_prefix<'a>(
+        &'a self,
+        prefix: Vec<u8>,
+    ) -> Box<dyn Iterator<Item = TupleOfBytes> + Send + 'a> {
+        // let name = self.name.clone();
+        // iter_from_thread!(
+        //     self,
+        //     format!(
+        //         "SELECT key, value FROM {} WHERE key BETWEEN ?1 AND ?1 || X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' ORDER BY key ASC",
+        //         name
+        //     )
+        //     .as_str(),
+        //     [prefix]
+        // )
        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();

@@ -340,13 +411,28 @@ impl Tree for SqliteTable {
        })
    }

-    #[tracing::instrument(skip(self))]
    fn clear(&self) -> Result<()> {
        debug!("clear: running");
        self.engine
+            .pool
            .write_lock()
            .execute(format!("DELETE FROM {}", self.name).as_str(), [])?;
        debug!("clear: ran");
        Ok(())
    }
 }
+
+// TODO
+// struct Pool<const NUM_READERS: usize> {
+//     writer: Mutex<Connection>,
+//     readers: [Mutex<Connection>; NUM_READERS],
+// }
+
+// // then, to pick a reader:
+// for r in &pool.readers {
+//     if let Ok(reader) = r.try_lock() {
+//         // use reader
+//     }
+// }
+// // none unlocked, pick the next reader
+// pool.readers[pool.counter.fetch_add(1, Relaxed) % NUM_READERS].lock()
@@ -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<(Vec<u8>, Vec<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,13 @@ 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),
@@ -84,15 +84,15 @@ impl Admin {
                tokio::select! {
                    Some(event) = receiver.next() => {
                        let guard = db.read().await;
-                        let mutex_state = Arc::clone(
+                        let mutex = Arc::clone(
                            guard.globals
-                                .roomid_mutex_state
+                                .roomid_mutex
                                .write()
                                .unwrap()
                                .entry(conduit_room.clone())
                                .or_default(),
                        );
-                        let state_lock = mutex_state.lock().await;
+                        let mutex_lock = mutex.lock().await;

                        match event {
                            AdminCommand::RegisterAppservice(yaml) => {
@@ -106,17 +106,17 @@ impl Admin {
                                        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), guard, &mutex_lock);
                                } else {
-                                    send_message(message::MessageEventContent::text_plain("Failed to get appservices."), guard, &state_lock);
+                                    send_message(message::MessageEventContent::text_plain("Failed to get appservices."), guard, &mutex_lock);
                                }
                            }
                            AdminCommand::SendMessage(message) => {
-                                send_message(message, guard, &state_lock);
+                                send_message(message, guard, &mutex_lock);
                            }
                        }

-                        drop(state_lock);
+                        drop(mutex_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 + '_> {
        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| {
+    pub fn iter_all(
+        &self,
+    ) -> Result<impl Iterator<Item = Result<(String, serde_yaml::Value)>> + '_ + Send> {
+        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"),
            ))
-            })
-            .collect()
+        }))
    }
 }
@@ -1,4 +1,5 @@
 use crate::{database::Config, utils, ConduitResult, Error, Result};
+use log::{error, info};
 use ruma::{
    api::{
        client::r0::sync::sync_events,
@@ -12,11 +13,10 @@ use std::{
    fs,
    future::Future,
    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, info};
+use tokio::sync::{broadcast, Mutex, Semaphore};
 use trust_dns_resolver::TokioAsyncResolver;

 use super::abstraction::Tree;
@@ -26,11 +26,6 @@ pub const COUNTER: &[u8] = b"c";
 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>>,
@@ -41,13 +36,20 @@ pub struct Globals {
    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 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 roomid_mutex_federation: RwLock<BTreeMap<RoomId, Arc<Mutex<()>>>>, // this lock will be held longer
+    pub sync_receivers: RwLock<
+        BTreeMap<
+            (UserId, Box<DeviceId>),
+            (
+                Option<String>,
+                tokio::sync::watch::Receiver<Option<ConduitResult<sync_events::Response>>>,
+            ), // since, rx
+        >,
+    >,
    pub rotate: RotationHandler,
 }

@@ -57,7 +59,6 @@ struct MatrixServerVerifier {
 }

 impl ServerCertVerifier for MatrixServerVerifier {
-    #[tracing::instrument(skip(self, roots, presented_certs, dns_name, ocsp_response))]
    fn verify_server_cert(
        &self,
        roots: &rustls::RootCertStore,
@@ -85,9 +86,6 @@ impl ServerCertVerifier for MatrixServerVerifier {
    }
 }

-/// 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<()>);

 impl RotationHandler {
@@ -110,12 +108,6 @@ impl RotationHandler {
    }
 }

-impl Default for RotationHandler {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Globals {
    pub fn load(
        globals: Arc<dyn Tree>,
@@ -198,13 +190,12 @@ 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()),
+            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()),
+            roomid_mutex_federation: RwLock::new(BTreeMap::new()),
+            sync_receivers: RwLock::new(BTreeMap::new()),
            rotate: RotationHandler::new(),
        };

@@ -223,13 +214,11 @@ impl Globals {
        &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,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,7 +70,6 @@ impl PushData {
            .collect()
    }

-    #[tracing::instrument(skip(self, sender))]
    pub fn get_pusher_senderkeys<'a>(
        &'a self,
        sender: &UserId,
@@ -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,
@@ -161,7 +154,6 @@ where
    }
 }

-#[tracing::instrument(skip(user, unread, pusher, ruleset, pdu, db))]
 pub async fn send_push_notice(
    user: &UserId,
    unread: UInt,
@@ -173,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
@@ -218,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,
@@ -318,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);
@@ -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,
@@ -33,7 +34,6 @@ use tokio::{
    select,
    sync::{RwLock, Semaphore},
 };
-use tracing::{error, warn};

 use super::abstraction::Tree;

@@ -45,7 +45,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) => {
@@ -81,10 +80,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 / * (for edus), Data = EDU content
-    pub(super) servercurrentevent_data: Arc<dyn Tree>, // ServerCurrentEvents = (+ / $)ServerName / UserId + PduId / * (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,7 +96,7 @@ impl Sending {
    pub fn start_handler(
        &self,
        db: Arc<RwLock<Database>>,
-        mut receiver: mpsc::UnboundedReceiver<(Vec<u8>, Vec<u8>)>,
+        mut receiver: mpsc::UnboundedReceiver<Vec<u8>>,
    ) {
        tokio::spawn(async move {
            let mut futures = FuturesUnordered::new();
@@ -109,12 +108,13 @@ impl Sending {

            let guard = db.read().await;

-            for (key, outgoing_kind, event) in guard
+            for (key, outgoing_kind, event) in
+                guard
                    .sending
-                .servercurrentevent_data
+                    .servercurrentevents
                    .iter()
-                .filter_map(|(key, v)| {
-                    Self::parse_servercurrentevent(&key, v)
+                    .filter_map(|(key, _)| {
+                        Self::parse_servercurrentevent(&key)
                            .ok()
                            .map(|(k, e)| (key, k, e))
                    })
@@ -128,7 +128,7 @@ impl Sending {
                        "Dropping some current events: {:?} {:?} {:?}",
                        key, outgoing_kind, event
                    );
-                    guard.sending.servercurrentevent_data.remove(&key).unwrap();
+                    guard.sending.servercurrentevents.remove(&key).unwrap();
                    continue;
                }

@@ -155,17 +155,17 @@ impl Sending {
                                let guard = db.read().await;

                                let prefix = outgoing_kind.get_prefix();
-                                for (key, _) in guard.sending.servercurrentevent_data
+                                for (key, _) in guard.sending.servercurrentevents
                                    .scan_prefix(prefix.clone())
                                {
-                                    guard.sending.servercurrentevent_data.remove(&key).unwrap();
+                                    guard.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 = guard.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<_>>();
@@ -174,10 +174,16 @@ 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);
+                                                guard.sending.servercurrentevents.insert(&current_key, &[]).unwrap();
+                                                guard.sending.servernamepduids.remove(&current_key).unwrap();
+                                             }
+                                        }
                                    }

                                    drop(guard);
@@ -185,7 +191,7 @@ impl Sending {
                                    futures.push(
                                        Self::handle_events(
                                            outgoing_kind.clone(),
-                                            new_events.into_iter().map(|(event, _)| event.1).collect(),
+                                            new_events,
                                            Arc::clone(&db),
                                        )
                                    );
@@ -205,8 +211,8 @@ impl Sending {
                            }
                        };
                    },
-                    Some((key, value)) = receiver.next() => {
-                        if let Ok((outgoing_kind, event)) = Self::parse_servercurrentevent(&key, value) {
+                    Some(key) = receiver.next() => {
+                        if let Ok((outgoing_kind, event)) = Self::parse_servercurrentevent(&key) {
                            let guard = db.read().await;

                            if let Ok(Some(events)) = Self::select_events(
@@ -224,7 +230,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
@@ -267,33 +272,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())?;
@@ -304,8 +301,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
@@ -370,7 +366,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;
@@ -381,36 +379,25 @@ impl Sending {
        Ok((events, max_edu_count))
    }

-    #[tracing::instrument(skip(self, pdu_id, senderkey))]
+    #[tracing::instrument(skip(self))]
    pub fn send_push_pdu(&self, pdu_id: &[u8], senderkey: Vec<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>) -> Result<()> {
-        let mut key = server.as_bytes().to_vec();
-        key.push(0xff);
-        key.push(b'*');
-        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(())
    }
@@ -421,13 +408,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);
@@ -435,7 +422,7 @@ 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>,
@@ -457,7 +444,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.",
                                        ),
                                    )
                                })?
@@ -514,7 +501,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.",
                                            ),
                                        )
                                    })?,
@@ -599,7 +586,8 @@ 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(
+                            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))?
@@ -607,17 +595,20 @@ impl Sending {
                                            (
                                                OutgoingKind::Normal(server.clone()),
                                                Error::bad_database(
-                                                "[Normal] Event in servernamevent_datas not found in db.",
+                                                    "[Normal] Event in servernamepduids not found in db.",
                                                ),
                                            )
                                        })?,
-                            );
-                            pdu_jsons.push(raw);
+                                )
+                                .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"),
+                            );
                        }
                    }
                }
@@ -663,11 +654,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);
@@ -685,7 +672,7 @@ impl Sending {
                    Error::bad_database("Invalid server string in server_currenttransaction")
                })?),
                if event.starts_with(b"*") {
-                    SendingEventType::Edu(value)
+                    SendingEventType::Edu(event[1..].to_vec())
                } else {
                    SendingEventType::Pdu(event.to_vec())
                },
@@ -703,7 +690,7 @@ impl Sending {
            (
                OutgoingKind::Push(user.to_vec(), pushkey.to_vec()),
                if event.starts_with(b"*") {
-                    SendingEventType::Edu(value)
+                    SendingEventType::Edu(event[1..].to_vec())
                } else {
                    SendingEventType::Pdu(event.to_vec())
                },
@@ -732,7 +719,7 @@ impl Sending {
        })
    }

-    #[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,
@@ -749,7 +736,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,
@@ -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,7 +593,6 @@ impl Users {
            })
    }

-    #[tracing::instrument(skip(self, user_id, rooms, globals))]
    fn mark_device_key_update(
        &self,
        user_id: &UserId,
@@ -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,18 @@ pub enum Error {
        #[from]
        source: sled::Error,
    },
+    #[cfg(feature = "rocksdb")]
+    #[error("There was a problem with the connection to the rocksdb database: {source}")]
+    RocksDbError {
+        #[from]
+        source: rocksdb::Error,
+    },
    #[cfg(feature = "sqlite")]
    #[error("There was a problem with the connection to the sqlite database: {source}")]
    SqliteError {
        #[from]
        source: rusqlite::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::Tracer;
 pub use pdu::PduEvent;
 pub use rocket::State;
 use ruma::api::client::error::ErrorKind;
@@ -32,7 +31,8 @@ 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> {
    rocket::custom(config)
@@ -50,7 +50,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 +60,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,
@@ -187,7 +185,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",
@@ -202,57 +200,32 @@ async fn main() {
        .extract::<Config>()
        .expect("It looks like your config is invalid. Please take a look at the error");

-    let start = async {
+    let mut _span: Option<span::Span> = None;
+    let mut _enter: Option<span::Entered<'_>> = None;
+
+    if config.allow_jaeger {
+        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();
+
+        _span = Some(span!(tracing::Level::INFO, "app_start", work_units = 2));
+        _enter = Some(_span.as_ref().unwrap().enter());
+    } else {
+        std::env::set_var("RUST_LOG", &config.log);
+        tracing_subscriber::fmt::init();
+    }
+
    config.warn_deprecated();

-        let db = Database::load_or_create(&config)
+    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;
-
+    let rocket = setup_rocket(raw_config, db);
    rocket.launch().await.unwrap();
-    };
-
-    if config.allow_jaeger {
-        let tracer = opentelemetry_jaeger::new_pipeline()
-            .with_service_name("conduit")
-            .install_simple()
-            .unwrap();
-
-        let span = tracer.start("conduit");
-        start.await;
-        drop(span);
-    } else {
-        std::env::set_var("RUST_LOG", &config.log);
-
-        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;
-        }
-    }
 }

 #[catch(404)]
@@ -282,30 +255,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::error;

 #[derive(Clone, Deserialize, Serialize, Debug)]
 pub struct PduEvent {
@@ -328,7 +328,6 @@ pub(crate) fn gen_event_id_canonical_json(

    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,
-        }
-    }
-}
@@ -10,6 +10,7 @@ use std::ops::Deref;
 #[cfg(feature = "conduit_bin")]
 use {
    crate::server_server,
+    log::{debug, warn},
    rocket::{
        data::{self, ByteUnit, Data, FromData},
        http::Status,
@@ -22,7 +23,6 @@ use {
    std::collections::BTreeMap,
    std::convert::TryFrom,
    std::io::Cursor,
-    tracing::{debug, warn},
 };

 /// This struct converts rocket requests into ruma structs by converting them into http requests
@@ -45,11 +45,7 @@ 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>()
@@ -75,9 +71,9 @@ where
            registration,
        )) = db
            .appservice
-            .all()
+            .iter_all()
            .unwrap()
-            .iter()
+            .filter_map(|r| r.ok())
            .find(|(_id, registration)| {
                registration
                    .get("as_token")
@@ -106,7 +102,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 +117,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 +127,7 @@ where
                        }
                    } else {
                        // Missing Token
-                        return Failure((Status::new(582), ()));
+                        return Failure((Status::raw(582), ()));
                    }
                }
                AuthScheme::ServerSignatures => {
@@ -153,7 +149,7 @@ where
                            warn!("No Authorization header");

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

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

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

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

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

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

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

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

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

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

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

@@ -257,17 +253,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 +318,7 @@ where
            Err(e) => {
                warn!("{:?}", e);
                // Bad Json
-                Failure((Status::new(583), ()))
+                Failure((Status::raw(583), ()))
            }
        }
    }
@@ -351,7 +344,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,6 +5,7 @@ use crate::{
 };
 use get_profile_information::v1::ProfileField;
 use http::header::{HeaderValue, AUTHORIZATION, HOST};
+use log::{debug, error, info, trace, warn};
 use regex::Regex;
 use rocket::response::content::Json;
 use ruma::{
@@ -51,7 +52,7 @@ use ruma::{
    ServerSigningKeyId, UserId,
 };
 use std::{
-    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
+    collections::{btree_map::Entry, BTreeMap, BTreeSet, HashSet},
    convert::{TryFrom, TryInto},
    fmt::Debug,
    future::Future,
@@ -62,8 +63,7 @@ use std::{
    sync::{Arc, RwLock},
    time::{Duration, Instant, SystemTime},
 };
-use tokio::sync::{MutexGuard, Semaphore};
-use tracing::{debug, error, info, trace, warn};
+use tokio::sync::Semaphore;

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post, put};
@@ -228,9 +228,11 @@ where
        .headers_mut()
        .insert(HOST, HeaderValue::from_str(&host).unwrap());

-    let reqwest_request = reqwest::Request::try_from(http_request)
+    let mut reqwest_request = reqwest::Request::try_from(http_request)
        .expect("all http requests are valid reqwest requests");

+    *reqwest_request.timeout_mut() = Some(Duration::from_secs(30));
+
    let url = reqwest_request.url().clone();
    let response = globals.reqwest_client().execute(reqwest_request).await;

@@ -271,15 +273,11 @@ where

            if status == 200 {
                let response = T::IncomingResponse::try_from_http_response(http_response);
-                response.map_err(|e| {
-                    warn!("Invalid 200 response from {}: {}", &destination, e);
-                    Error::BadServerResponse("Server returned bad 200 response.")
-                })
+                response.map_err(|_| Error::BadServerResponse("Server returned bad 200 response."))
            } else {
                Err(Error::FederationError(
                    destination.to_owned(),
-                    RumaError::try_from_http_response(http_response).map_err(|e| {
-                        warn!("Server returned bad error response: {}", e);
+                    RumaError::try_from_http_response(http_response).map_err(|_| {
                        Error::BadServerResponse("Server returned bad error response.")
                    })?,
                ))
@@ -667,13 +665,15 @@ pub async fn send_transaction_message_route(
        drop(mutex_lock);

        let elapsed = start_time.elapsed();
+        if elapsed > Duration::from_secs(1) {
            warn!(
-            "Handling transaction of event {} took {}m{}s",
+                "Handling event {} took {}m{}s",
                event_id,
                elapsed.as_secs() / 60,
                elapsed.as_secs() % 60
            );
        }
+    }

    for pdu in &resolved_map {
        if let Err(e) = pdu.1 {
@@ -686,7 +686,8 @@ pub async fn send_transaction_message_route(
    for edu in body
        .edus
        .iter()
-        .filter_map(|edu| serde_json::from_str::<Edu>(edu.json().get()).ok())
+        .map(|edu| serde_json::from_str::<Edu>(edu.json().get()))
+        .filter_map(|r| r.ok())
    {
        match edu {
            Edu::Presence(_) => {}
@@ -721,8 +722,7 @@ pub async fn send_transaction_message_route(
                                &db.globals,
                            )?;
                        } else {
-                            // TODO fetch missing events
-                            debug!("No known event ids in read receipt: {:?}", user_updates);
+                            warn!("No known event ids in read receipt: {:?}", user_updates);
                        }
                    }
                }
@@ -807,13 +807,13 @@ pub async fn send_transaction_message_route(
        }
    }

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

    Ok(send_transaction_message::v1::Response { pdus: resolved_map }.into())
 }

 /// An async function that can recursively call itself.
-type AsyncRecursiveType<'a, T> = Pin<Box<dyn Future<Output = T> + 'a + Send>>;
+type AsyncRecursiveResult<'a, T, E> = Pin<Box<dyn Future<Output = StdResult<T, E>> + 'a + Send>>;

 /// When receiving an event one needs to:
 /// 0. Check the server is in the room
@@ -838,8 +838,7 @@ type AsyncRecursiveType<'a, T> = Pin<Box<dyn Future<Output = T> + 'a + Send>>;
 /// 13. Check if the event passes auth based on the "current state" of the room, if not "soft fail"
 ///     it
 /// 14. Use state resolution to find new room state
-// We use some AsyncRecursiveType hacks here so we can call this async funtion recursively
-#[tracing::instrument(skip(value, is_timeline_event, db, pub_key_map))]
+// We use some AsyncRecursiveResult hacks here so we can call this async funtion recursively
 pub fn handle_incoming_pdu<'a>(
    origin: &'a ServerName,
    event_id: &'a EventId,
@@ -848,10 +847,8 @@ pub fn handle_incoming_pdu<'a>(
    is_timeline_event: bool,
    db: &'a Database,
    pub_key_map: &'a RwLock<BTreeMap<String, BTreeMap<String, String>>>,
-) -> AsyncRecursiveType<'a, StdResult<Option<Vec<u8>>, String>> {
+) -> AsyncRecursiveResult<'a, Option<Vec<u8>>, String> {
    Box::pin(async move {
-        let start_time = Instant::now();
-
        // TODO: For RoomVersion6 we must check that Raw<..> is canonical do we anywhere?: https://matrix.org/docs/spec/rooms/v6#canonical-json
        match db.rooms.exists(&room_id) {
            Ok(true) => {}
@@ -924,15 +921,9 @@ pub fn handle_incoming_pdu<'a>(
        // 5. Reject "due to auth events" if can't get all the auth events or some of the auth events are also rejected "due to auth events"
        // EDIT: Step 5 is not applied anymore because it failed too often
        debug!("Fetching auth events for {}", incoming_pdu.event_id);
-        fetch_and_handle_events(
-            db,
-            origin,
-            &incoming_pdu.auth_events,
-            &room_id,
-            pub_key_map,
-            false,
-        )
-        .await;
+        fetch_and_handle_events(db, origin, &incoming_pdu.auth_events, &room_id, pub_key_map)
+            .await
+            .map_err(|e| e.to_string())?;

        // 6. Reject "due to auth events" if the event doesn't pass auth based on the auth events
        debug!(
@@ -941,7 +932,7 @@ pub fn handle_incoming_pdu<'a>(
        );

        // Build map of auth events
-        let mut auth_events = HashMap::new();
+        let mut auth_events = BTreeMap::new();
        for id in &incoming_pdu.auth_events {
            let auth_event = db
                .rooms
@@ -1014,33 +1005,11 @@ pub fn handle_incoming_pdu<'a>(
        debug!("Added pdu as outlier.");

        // 8. if not timeline event: stop
-        if !is_timeline_event
-            || incoming_pdu.origin_server_ts
-                < (utils::millis_since_unix_epoch() - 1000 * 60 * 20)
-                    .try_into()
-                    .expect("time is valid")
-        // Not older than 20 mins
-        {
-            let elapsed = start_time.elapsed();
-            warn!(
-                "Handling outlier event {} took {}m{}s",
-                event_id,
-                elapsed.as_secs() / 60,
-                elapsed.as_secs() % 60
-            );
+        if !is_timeline_event {
            return Ok(None);
        }

-        // 9. Fetch any missing prev events doing all checks listed here starting at 1. These are timeline events
-        fetch_and_handle_events(
-            db,
-            origin,
-            &incoming_pdu.prev_events,
-            &room_id,
-            pub_key_map,
-            true,
-        )
-        .await;
+        // TODO: 9. fetch any missing prev events doing all checks listed here starting at 1. These are timeline events

        // 10. Fetch missing state and auth chain events by calling /state_ids at backwards extremities
        //     doing all the checks in this list starting at 1. These are not timeline events.
@@ -1053,25 +1022,34 @@ pub fn handle_incoming_pdu<'a>(

        if incoming_pdu.prev_events.len() == 1 {
            let prev_event = &incoming_pdu.prev_events[0];
-            let prev_event_sstatehash = db
+            let state = db
                .rooms
                .pdu_shortstatehash(prev_event)
-                .map_err(|_| "Failed talking to db".to_owned())?;
-
-            let state =
-                prev_event_sstatehash.map(|shortstatehash| db.rooms.state_full_ids(shortstatehash));
-
-            if let Some(Ok(state)) = state {
-                warn!("Using cached state");
-                let mut state = fetch_and_handle_events(
+                .map_err(|_| "Failed talking to db".to_owned())?
+                .map(|shortstatehash| db.rooms.state_full_ids(shortstatehash).ok())
+                .flatten();
+            if let Some(mut state) = state {
+                if db
+                    .rooms
+                    .get_pdu(prev_event)
+                    .ok()
+                    .flatten()
+                    .ok_or_else(|| "Could not find prev event, but we know the state.".to_owned())?
+                    .state_key
+                    .is_some()
+                {
+                    state.insert(prev_event.clone());
+                }
+                state_at_incoming_event = Some(
+                    fetch_and_handle_events(
                        db,
                        origin,
                        &state.into_iter().collect::<Vec<_>>(),
                        &room_id,
                        pub_key_map,
-                    false,
                    )
                    .await
+                    .map_err(|_| "Failed to fetch state events locally".to_owned())?
                    .into_iter()
                    .map(|pdu| {
                        (
@@ -1084,23 +1062,13 @@ pub fn handle_incoming_pdu<'a>(
                            pdu,
                        )
                    })
-                .collect::<HashMap<_, _>>();
-
-                let prev_pdu = db.rooms.get_pdu(prev_event).ok().flatten().ok_or_else(|| {
-                    "Could not find prev event, but we know the state.".to_owned()
-                })?;
-
-                if let Some(state_key) = &prev_pdu.state_key {
-                    state.insert((prev_pdu.kind.clone(), state_key.clone()), prev_pdu);
-                }
-
-                state_at_incoming_event = Some(state);
+                    .collect(),
+                );
            }
            // TODO: set incoming_auth_events?
        }

        if state_at_incoming_event.is_none() {
-            warn!("Calling /state_ids");
            // Call /state_ids to find out what the state at this pdu is. We trust the server's
            // response to some extend, but we still do a lot of checks on the events
            match db
@@ -1117,17 +1085,20 @@ pub fn handle_incoming_pdu<'a>(
            {
                Ok(res) => {
                    debug!("Fetching state events at event.");
-                    let state_vec = fetch_and_handle_events(
+                    let state_vec = match fetch_and_handle_events(
                        &db,
                        origin,
                        &res.pdu_ids,
                        &room_id,
                        pub_key_map,
-                        false,
                    )
-                    .await;
+                    .await
+                    {
+                        Ok(state) => state,
+                        Err(_) => return Err("Failed to fetch state events.".to_owned()),
+                    };

-                    let mut state = HashMap::new();
+                    let mut state = BTreeMap::new();
                    for pdu in state_vec {
                        match state.entry((pdu.kind.clone(), pdu.state_key.clone().ok_or_else(|| "Found non-state pdu in state events.".to_owned())?)) {
                            Entry::Vacant(v) => {
@@ -1151,15 +1122,18 @@ pub fn handle_incoming_pdu<'a>(
                    }

                    debug!("Fetching auth chain events at event.");
-                    fetch_and_handle_events(
+                    match fetch_and_handle_events(
                        &db,
                        origin,
                        &res.auth_chain_ids,
                        &room_id,
                        pub_key_map,
-                        false,
                    )
-                    .await;
+                    .await
+                    {
+                        Ok(state) => state,
+                        Err(_) => return Err("Failed to fetch auth chain.".to_owned()),
+                    };

                    state_at_incoming_event = Some(state);
                }
@@ -1186,18 +1160,6 @@ pub fn handle_incoming_pdu<'a>(
        }
        debug!("Auth check succeeded.");

-        // We start looking at current room state now, so lets lock the room
-
-        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;
-
        // Now we calculate the set of extremities this room has after the incoming event has been
        // applied. We start with the previous extremities (aka leaves)
        let mut extremities = db
@@ -1212,11 +1174,7 @@ pub fn handle_incoming_pdu<'a>(
            }
        }

-        // Only keep those extremities were not referenced yet
-        extremities.retain(|id| !matches!(db.rooms.is_event_referenced(&room_id, id), Ok(true)));
-
-        let mut extremity_statehashes = Vec::new();
-
+        let mut fork_states = BTreeSet::new();
        for id in &extremities {
            match db
                .rooms
@@ -1224,8 +1182,8 @@ pub fn handle_incoming_pdu<'a>(
                .map_err(|_| "Failed to ask db for pdu.".to_owned())?
            {
                Some(leaf_pdu) => {
-                    extremity_statehashes.push((
-                        db.rooms
+                    let pdu_shortstatehash = db
+                        .rooms
                        .pdu_shortstatehash(&leaf_pdu.event_id)
                        .map_err(|_| "Failed to ask db for pdu state hash.".to_owned())?
                        .ok_or_else(|| {
@@ -1234,9 +1192,20 @@ pub fn handle_incoming_pdu<'a>(
                                leaf_pdu
                            );
                            "Found pdu with no statehash in db.".to_owned()
-                            })?,
-                        Some(leaf_pdu),
-                    ));
+                        })?;
+
+                    let mut leaf_state = db
+                        .rooms
+                        .state_full(pdu_shortstatehash)
+                        .map_err(|_| "Failed to ask db for room state.".to_owned())?;
+
+                    if let Some(state_key) = &leaf_pdu.state_key {
+                        // Now it's the state after
+                        let key = (leaf_pdu.kind.clone(), state_key.clone());
+                        leaf_state.insert(key, leaf_pdu);
+                    }
+
+                    fork_states.insert(leaf_state);
                }
                _ => {
                    error!("Missing state snapshot for {:?}", id);
@@ -1250,36 +1219,12 @@ pub fn handle_incoming_pdu<'a>(
        //     don't just trust a set of state we got from a remote).

        // We do this by adding the current state to the list of fork states
-        let current_statehash = db
-            .rooms
-            .current_shortstatehash(&room_id)
-            .map_err(|_| "Failed to load current state hash.".to_owned())?
-            .expect("every room has state");
-
        let current_state = db
            .rooms
-            .state_full(current_statehash)
-            .map_err(|_| "Failed to load room state.")?;
+            .room_state_full(&room_id)
+            .map_err(|_| "Failed to load room state.".to_owned())?;

-        extremity_statehashes.push((current_statehash.clone(), None));
-
-        let mut fork_states = Vec::new();
-        for (statehash, leaf_pdu) in extremity_statehashes {
-            let mut leaf_state = db
-                .rooms
-                .state_full(statehash)
-                .map_err(|_| "Failed to ask db for room state.".to_owned())?;
-
-            if let Some(leaf_pdu) = leaf_pdu {
-                if let Some(state_key) = &leaf_pdu.state_key {
-                    // Now it's the state after
-                    let key = (leaf_pdu.kind.clone(), state_key.clone());
-                    leaf_state.insert(key, leaf_pdu);
-                }
-            }
-
-            fork_states.push(leaf_state);
-        }
+        fork_states.insert(current_state.clone());

        // We also add state after incoming event to the fork states
        extremities.insert(incoming_pdu.event_id.clone());
@@ -1290,15 +1235,18 @@ pub fn handle_incoming_pdu<'a>(
                incoming_pdu.clone(),
            );
        }
-        fork_states.push(state_after.clone());
+        fork_states.insert(state_after.clone());
+
+        let fork_states = fork_states.into_iter().collect::<Vec<_>>();

        let mut update_state = false;
        // 14. Use state resolution to find new room state
        let new_room_state = if fork_states.is_empty() {
            return Err("State is empty.".to_owned());
-        } else if fork_states.iter().skip(1).all(|f| &fork_states[0] == f) {
+        } else if fork_states.len() == 1 {
            // There was only one state, so it has to be the room's current state (because that is
            // always included)
+            debug!("Skipping stateres because there is no new state.");
            fork_states[0]
                .iter()
                .map(|(k, pdu)| (k.clone(), pdu.event_id.clone()))
@@ -1307,30 +1255,28 @@ pub fn handle_incoming_pdu<'a>(
            // We do need to force an update to this room's state
            update_state = true;

-            let fork_states = &fork_states
+            let mut auth_events = vec![];
+            for map in &fork_states {
+                let state_auth = map
+                    .values()
+                    .flat_map(|pdu| pdu.auth_events.clone())
+                    .collect();
+                auth_events.push(state_auth);
+            }
+
+            match state_res::StateResolution::resolve(
+                &room_id,
+                room_version_id,
+                &fork_states
                    .into_iter()
                    .map(|map| {
                        map.into_iter()
                            .map(|(k, v)| (k, v.event_id.clone()))
                            .collect::<StateMap<_>>()
                    })
-                .collect::<Vec<_>>();
-
-            let mut auth_chain_sets = Vec::new();
-            for state in fork_states {
-                auth_chain_sets.push(
-                    get_auth_chain(state.iter().map(|(_, id)| id.clone()).collect(), db)
-                        .map_err(|_| "Failed to load auth chain.".to_owned())?
-                        .collect(),
-                );
-            }
-
-            let state = match state_res::StateResolution::resolve(
-                &room_id,
-                room_version_id,
-                fork_states,
-                auth_chain_sets,
-                |id| {
+                    .collect::<Vec<_>>(),
+                auth_events,
+                &|id| {
                    let res = db.rooms.get_pdu(id);
                    if let Err(e) = &res {
                        error!("LOOK AT ME Failed to fetch event: {}", e);
@@ -1342,12 +1288,9 @@ pub fn handle_incoming_pdu<'a>(
                Err(_) => {
                    return Err("State resolution failed, either an event could not be found or deserialization".into());
                }
+            }
        };

-            state
-        };
-
-        debug!("starting soft fail auth check");
        // 13. Check if the event passes auth based on the "current state" of the room, if not "soft fail" it
        let soft_fail = !state_res::event_auth::auth_check(
            &room_version,
@@ -1366,12 +1309,13 @@ pub fn handle_incoming_pdu<'a>(
            pdu_id = Some(
                append_incoming_pdu(
                    &db,
+                    &room_id,
                    &incoming_pdu,
                    val,
                    extremities,
                    &state_at_incoming_event,
-                    &state_lock,
                )
+                .await
                .map_err(|_| "Failed to add pdu to db.".to_owned())?,
            );
            debug!("Appended incoming pdu.");
@@ -1393,15 +1337,6 @@ pub fn handle_incoming_pdu<'a>(
        }

        // Event has passed all auth/stateres checks
-        drop(state_lock);
-
-        let elapsed = start_time.elapsed();
-        warn!(
-            "Handling timeline event {} took {}m{}s",
-            event_id,
-            elapsed.as_secs() / 60,
-            elapsed.as_secs() % 60
-        );
        Ok(pdu_id)
    })
 }
@@ -1420,8 +1355,7 @@ pub(crate) fn fetch_and_handle_events<'a>(
    events: &'a [EventId],
    room_id: &'a RoomId,
    pub_key_map: &'a RwLock<BTreeMap<String, BTreeMap<String, String>>>,
-    are_timeline_events: bool,
-) -> AsyncRecursiveType<'a, Vec<Arc<PduEvent>>> {
+) -> AsyncRecursiveResult<'a, Vec<Arc<PduEvent>>, Error> {
    Box::pin(async move {
        let back_off = |id| match db.globals.bad_event_ratelimiter.write().unwrap().entry(id) {
            Entry::Vacant(e) => {
@@ -1448,17 +1382,12 @@ pub(crate) fn fetch_and_handle_events<'a>(
            // a. Look in the main timeline (pduid_pdu tree)
            // b. Look at outlier pdu tree
            // (get_pdu checks both)
-            let local_pdu = if are_timeline_events {
-                db.rooms.get_non_outlier_pdu(&id).map(|o| o.map(Arc::new))
-            } else {
-                db.rooms.get_pdu(&id)
-            };
-            let pdu = match local_pdu {
-                Ok(Some(pdu)) => {
+            let pdu = match db.rooms.get_pdu(&id)? {
+                Some(pdu) => {
                    trace!("Found {} in db", id);
                    pdu
                }
-                Ok(None) => {
+                None => {
                    // c. Ask origin server over federation
                    debug!("Fetching {} over federation.", id);
                    match db
@@ -1473,18 +1402,14 @@ pub(crate) fn fetch_and_handle_events<'a>(
                        Ok(res) => {
                            debug!("Got {} over federation", id);
                            let (event_id, mut value) =
-                                match crate::pdu::gen_event_id_canonical_json(&res.pdu) {
-                                    Ok(t) => t,
-                                    Err(_) => continue,
-                                };
-
+                                crate::pdu::gen_event_id_canonical_json(&res.pdu)?;
                            // This will also fetch the auth chain
                            match handle_incoming_pdu(
                                origin,
                                &event_id,
                                &room_id,
                                value.clone(),
-                                are_timeline_events,
+                                false,
                                db,
                                pub_key_map,
                            )
@@ -1520,14 +1445,10 @@ pub(crate) fn fetch_and_handle_events<'a>(
                        }
                    }
                }
-                Err(e) => {
-                    debug!("Error loading {}: {}", id, e);
-                    continue;
-                }
            };
            pdus.push(pdu);
        }
-        pdus
+        Ok(pdus)
    })
 }

@@ -1692,15 +1613,25 @@ pub(crate) async fn fetch_signing_keys(

 /// Append the incoming event setting the state snapshot to the state from the
 /// server that sent the event.
-#[tracing::instrument(skip(db, pdu, pdu_json, new_room_leaves, state, _mutex_lock))]
-fn append_incoming_pdu(
+#[tracing::instrument(skip(db))]
+async fn append_incoming_pdu(
    db: &Database,
+    room_id: &RoomId,
    pdu: &PduEvent,
    pdu_json: CanonicalJsonObject,
    new_room_leaves: HashSet<EventId>,
    state: &StateMap<Arc<PduEvent>>,
-    _mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room mutex
 ) -> Result<Vec<u8>> {
+    let mutex = Arc::clone(
+        db.globals
+            .roomid_mutex
+            .write()
+            .unwrap()
+            .entry(room_id.clone())
+            .or_default(),
+    );
+    let mutex_lock = mutex.lock().await;
+
    // We append to state before appending the pdu, so we don't have a moment in time with the
    // pdu without it's state. This is okay because append_pdu can't fail.
    db.rooms
@@ -1713,7 +1644,9 @@ fn append_incoming_pdu(
        &db,
    )?;

-    for appservice in db.appservice.all()? {
+    drop(mutex_lock);
+
+    for appservice in db.appservice.iter_all()?.filter_map(|r| r.ok()) {
        if let Some(namespaces) = appservice.1.get("namespaces") {
            let users = namespaces
                .get("users")
@@ -1774,72 +1707,6 @@ fn append_incoming_pdu(
    Ok(pdu_id)
 }

-fn get_auth_chain(
-    starting_events: Vec<EventId>,
-    db: &Database,
-) -> Result<impl Iterator<Item = EventId> + '_> {
-    let mut full_auth_chain = HashSet::new();
-
-    let starting_events = starting_events
-        .iter()
-        .map(|id| {
-            db.rooms
-                .get_or_create_shorteventid(id, &db.globals)
-                .map(|s| (s, id))
-        })
-        .collect::<Result<Vec<_>>>()?;
-
-    let mut cache = db.rooms.auth_chain_cache();
-
-    for (sevent_id, event_id) in starting_events {
-        if let Some(cached) = cache.get_mut(&sevent_id) {
-            full_auth_chain.extend(cached.iter().cloned());
-        } else {
-            drop(cache);
-            let mut auth_chain = HashSet::new();
-            get_auth_chain_recursive(&event_id, &mut auth_chain, db)?;
-            cache = db.rooms.auth_chain_cache();
-            cache.insert(sevent_id, auth_chain.clone());
-            full_auth_chain.extend(auth_chain);
-        };
-    }
-
-    drop(cache);
-
-    Ok(full_auth_chain
-        .into_iter()
-        .filter_map(move |sid| db.rooms.get_eventid_from_short(sid).ok()))
-}
-
-fn get_auth_chain_recursive(
-    event_id: &EventId,
-    found: &mut HashSet<u64>,
-    db: &Database,
-) -> Result<()> {
-    let r = db.rooms.get_pdu(&event_id);
-    match r {
-        Ok(Some(pdu)) => {
-            for auth_event in &pdu.auth_events {
-                let sauthevent = db
-                    .rooms
-                    .get_or_create_shorteventid(auth_event, &db.globals)?;
-                if !found.contains(&sauthevent) {
-                    found.insert(sauthevent);
-                    get_auth_chain_recursive(&auth_event, found, db)?;
-                }
-            }
-        }
-        Ok(None) => {
-            warn!("Could not find pdu mentioned in auth events.");
-        }
-        Err(e) => {
-            warn!("Could not load event in auth chain: {}", e);
-        }
-    }
-
-    Ok(())
-}
-
 #[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/federation/v1/event/<_>", data = "<body>")
@@ -1927,15 +1794,35 @@ pub fn get_event_authorization_route(
        return Err(Error::bad_config("Federation is disabled."));
    }

-    let auth_chain_ids = get_auth_chain(vec![body.event_id.clone()], &db)?;
+    let mut auth_chain = Vec::new();
+    let mut auth_chain_ids = BTreeSet::<EventId>::new();
+    let mut todo = BTreeSet::new();
+    todo.insert(body.event_id.clone());

-    Ok(get_event_authorization::v1::Response {
-        auth_chain: auth_chain_ids
-            .filter_map(|id| Some(db.rooms.get_pdu_json(&id).ok()??))
-            .map(|event| PduEvent::convert_to_outgoing_federation_event(event))
-            .collect(),
+    while let Some(event_id) = todo.iter().next().cloned() {
+        if let Some(pdu) = db.rooms.get_pdu(&event_id)? {
+            todo.extend(
+                pdu.auth_events
+                    .clone()
+                    .into_iter()
+                    .collect::<BTreeSet<_>>()
+                    .difference(&auth_chain_ids)
+                    .cloned(),
+            );
+            auth_chain_ids.extend(pdu.auth_events.clone().into_iter());
+
+            let pdu_json = PduEvent::convert_to_outgoing_federation_event(
+                db.rooms.get_pdu_json(&event_id)?.unwrap(),
+            );
+            auth_chain.push(pdu_json);
+        } else {
+            warn!("Could not find pdu mentioned in auth events.");
        }
-    .into())
+
+        todo.remove(&event_id);
+    }
+
+    Ok(get_event_authorization::v1::Response { auth_chain }.into())
 }

 #[cfg_attr(
@@ -1970,20 +1857,35 @@ pub fn get_room_state_route(
        })
        .collect();

-    let auth_chain_ids = get_auth_chain(vec![body.event_id.clone()], &db)?;
+    let mut auth_chain = Vec::new();
+    let mut auth_chain_ids = BTreeSet::<EventId>::new();
+    let mut todo = BTreeSet::new();
+    todo.insert(body.event_id.clone());

-    Ok(get_room_state::v1::Response {
-        auth_chain: auth_chain_ids
-            .map(|id| {
-                Ok::<_, Error>(PduEvent::convert_to_outgoing_federation_event(
-                    db.rooms.get_pdu_json(&id)?.unwrap(),
-                ))
-            })
-            .filter_map(|r| r.ok())
-            .collect(),
-        pdus,
+    while let Some(event_id) = todo.iter().next().cloned() {
+        if let Some(pdu) = db.rooms.get_pdu(&event_id)? {
+            todo.extend(
+                pdu.auth_events
+                    .clone()
+                    .into_iter()
+                    .collect::<BTreeSet<_>>()
+                    .difference(&auth_chain_ids)
+                    .cloned(),
+            );
+            auth_chain_ids.extend(pdu.auth_events.clone().into_iter());
+
+            let pdu_json = PduEvent::convert_to_outgoing_federation_event(
+                db.rooms.get_pdu_json(&event_id)?.unwrap(),
+            );
+            auth_chain.push(pdu_json);
+        } else {
+            warn!("Could not find pdu mentioned in auth events.");
        }
-    .into())
+
+        todo.remove(&event_id);
+    }
+
+    Ok(get_room_state::v1::Response { auth_chain, pdus }.into())
 }

 #[cfg_attr(
@@ -2013,10 +1915,30 @@ pub fn get_room_state_ids_route(
        .into_iter()
        .collect();

-    let auth_chain_ids = get_auth_chain(vec![body.event_id.clone()], &db)?;
+    let mut auth_chain_ids = BTreeSet::<EventId>::new();
+    let mut todo = BTreeSet::new();
+    todo.insert(body.event_id.clone());
+
+    while let Some(event_id) = todo.iter().next().cloned() {
+        if let Some(pdu) = db.rooms.get_pdu(&event_id)? {
+            todo.extend(
+                pdu.auth_events
+                    .clone()
+                    .into_iter()
+                    .collect::<BTreeSet<_>>()
+                    .difference(&auth_chain_ids)
+                    .cloned(),
+            );
+            auth_chain_ids.extend(pdu.auth_events.clone().into_iter());
+        } else {
+            warn!("Could not find pdu mentioned in auth events.");
+        }
+
+        todo.remove(&event_id);
+    }

    Ok(get_room_state_ids::v1::Response {
-        auth_chain_ids: auth_chain_ids.collect(),
+        auth_chain_ids: auth_chain_ids.into_iter().collect(),
        pdu_ids,
    }
    .into())
@@ -2042,6 +1964,15 @@ pub fn create_join_event_template_route(
        ));
    }

+    if !body.ver.contains(&RoomVersionId::Version6) {
+        return Err(Error::BadRequest(
+            ErrorKind::IncompatibleRoomVersion {
+                room_version: RoomVersionId::Version6,
+            },
+            "Room version not supported.",
+        ));
+    }
+
    let prev_events = db
        .rooms
        .get_pdu_leaves(&body.room_id)?
@@ -2072,23 +2003,15 @@ pub fn create_join_event_template_route(
    };

    // 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| {
+    let room_version = RoomVersion::new(
+        &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");
-
-    if !body.ver.contains(&room_version_id) {
-        return Err(Error::BadRequest(
-            ErrorKind::IncompatibleRoomVersion {
-                room_version: room_version_id,
-            },
-            "Room version not supported.",
-        ));
-    }
+        }),
+    )
+    .expect("room version is supported");

    let content = serde_json::to_value(MemberEventContent {
        avatar_url: None,
-        blurhash: None,
        displayname: None,
        is_direct: None,
        membership: MembershipState::Join,
@@ -2181,7 +2104,7 @@ pub fn create_join_event_template_route(
    );

    Ok(create_join_event_template::v1::Response {
-        room_version: Some(room_version_id),
+        room_version: Some(RoomVersionId::Version6),
        event: serde_json::from_value::<Raw<_>>(
            serde_json::to_value(pdu_json).expect("CanonicalJson is valid serde_json::Value"),
        )
@@ -2255,8 +2178,7 @@ pub async fn create_join_event_route(
        &pub_key_map,
    )
    .await
-    .map_err(|e| {
-        warn!("Error while handling incoming send join PDU: {}", e);
+    .map_err(|_| {
        Error::BadRequest(
            ErrorKind::InvalidParam,
            "Error while handling incoming PDU.",
@@ -2269,7 +2191,27 @@ pub async fn create_join_event_route(
    drop(mutex_lock);

    let state_ids = db.rooms.state_full_ids(shortstatehash)?;
-    let auth_chain_ids = get_auth_chain(state_ids.iter().cloned().collect(), &db)?;
+
+    let mut auth_chain_ids = BTreeSet::<EventId>::new();
+    let mut todo = state_ids.iter().cloned().collect::<BTreeSet<_>>();
+
+    while let Some(event_id) = todo.iter().next().cloned() {
+        if let Some(pdu) = db.rooms.get_pdu(&event_id)? {
+            todo.extend(
+                pdu.auth_events
+                    .clone()
+                    .into_iter()
+                    .collect::<BTreeSet<_>>()
+                    .difference(&auth_chain_ids)
+                    .cloned(),
+            );
+            auth_chain_ids.extend(pdu.auth_events.clone().into_iter());
+        } else {
+            warn!("Could not find pdu mentioned in auth events.");
+        }
+
+        todo.remove(&event_id);
+    }

    for server in db
        .rooms
@@ -2280,11 +2222,12 @@ pub async fn create_join_event_route(
        db.sending.send_pdu(&server, &pdu_id)?;
    }

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

    Ok(create_join_event::v2::Response {
        room_state: RoomState {
            auth_chain: auth_chain_ids
+                .iter()
                .filter_map(|id| db.rooms.get_pdu_json(&id).ok().flatten())
                .map(PduEvent::convert_to_outgoing_federation_event)
                .collect(),
@@ -2311,8 +2254,7 @@ pub async fn create_invite_route(
        return Err(Error::bad_config("Federation is disabled."));
    }

-    if body.room_version != RoomVersionId::Version5 && body.room_version != RoomVersionId::Version6
-    {
+    if body.room_version < RoomVersionId::Version6 {
        return Err(Error::BadRequest(
            ErrorKind::IncompatibleRoomVersion {
                room_version: body.room_version.clone(),
@@ -2398,7 +2340,7 @@ pub async fn create_invite_route(
        )?;
    }

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

    Ok(create_invite::v2::Response {
        event: PduEvent::convert_to_outgoing_federation_event(signed_event),
@@ -2489,25 +2431,19 @@ pub fn get_profile_information_route(

    let mut displayname = None;
    let mut avatar_url = None;
-    let mut blurhash = None;

    match &body.field {
-        Some(ProfileField::DisplayName) => displayname = db.users.displayname(&body.user_id)?,
-        Some(ProfileField::AvatarUrl) => {
-            avatar_url = db.users.avatar_url(&body.user_id)?;
-            blurhash = db.users.blurhash(&body.user_id)?
-        }
        // TODO: what to do with custom
-        Some(_) => {}
+        Some(ProfileField::_Custom(_s)) => {}
+        Some(ProfileField::DisplayName) => displayname = db.users.displayname(&body.user_id)?,
+        Some(ProfileField::AvatarUrl) => avatar_url = db.users.avatar_url(&body.user_id)?,
        None => {
            displayname = db.users.displayname(&body.user_id)?;
            avatar_url = db.users.avatar_url(&body.user_id)?;
-            blurhash = db.users.blurhash(&body.user_id)?;
        }
    }

    Ok(get_profile_information::v1::Response {
-        blurhash,
        displayname,
        avatar_url,
    }
@@ -2532,10 +2468,9 @@ pub async fn get_keys_route(
        &body.device_keys,
        |u| Some(u.server_name()) == body.sender_servername.as_deref(),
        &db,
-    )
-    .await?;
+    )?;

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

    Ok(get_keys::v1::Response {
        device_keys: result.device_keys,
@@ -2558,9 +2493,9 @@ pub async fn claim_keys_route(
        return Err(Error::bad_config("Federation is disabled."));
    }

-    let result = claim_keys_helper(&body.one_time_keys, &db).await?;
+    let result = claim_keys_helper(&body.one_time_keys, &db)?;

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

    Ok(claim_keys::v1::Response {
        one_time_keys: result.one_time_keys,
@@ -9,7 +9,6 @@ use std::{
    time::{SystemTime, UNIX_EPOCH},
 };

-#[tracing::instrument]
 pub fn millis_since_unix_epoch() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
@@ -17,6 +16,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 +48,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 +67,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 +77,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 +104,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> {
@@ -115,7 +117,6 @@ pub fn to_canonical_object<T: serde::Serialize>(
    }
 }

-#[tracing::instrument(skip(deserializer))]
 pub fn deserialize_from_str<
    'de,
    D: serde::de::Deserializer<'de>,
@@ -136,7 +137,7 @@ pub fn deserialize_from_str<
        where
            E: serde::de::Error,
        {
-            v.parse().map_err(serde::de::Error::custom)
+            v.parse().map_err(|e| serde::de::Error::custom(e))
        }
    }
    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"
Author	SHA1	Message	Date
Timo Kösters	2423de2d51	improvement: locks	2021-07-13 15:48:10 +02:00
Timo Kösters	553fea9a41	improvement: efficient /sync, mutex for federation transactions	2021-07-13 10:29:02 +02:00
Timo Kösters	25c7333112	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-13 10:26:39 +02:00
Timo Kösters	1bba271916	fix: e2ee verification	2021-07-13 10:26:36 +02:00
Timo Kösters	ea2fc3adc0	improvement: more efficient state res	2021-07-13 10:24:51 +02:00
Jonathan de Jong	b89cffed34	warn on deprecated keys	2021-07-12 21:23:20 +02:00
Jonathan de Jong	3260ae01b8	change references of cache_capacity to db_cache_capacity	2021-07-12 19:53:06 +02:00
Jonathan de Jong	7e0aab7852	shuffle main.rs to allow deprecation warnings	2021-07-12 19:09:14 +02:00
Jonathan de Jong	6e8beb604d	support some deprecations	2021-07-12 18:05:43 +02:00
Jonathan de Jong	735d7a0815	database iter_from fix	2021-07-12 00:07:10 +02:00
Jonathan de Jong	caa0cbfe1d	change fairmutex to mutex	2021-07-11 21:48:55 +02:00
Jonathan de Jong	7e9014d5c9	implement sync rotation	2021-07-11 20:10:24 +02:00
Jonathan de Jong	bcfea98457	replace ReadGuard with DatabaseGuard	2021-07-11 15:42:06 +02:00
Jonathan de Jong	3a76fda92b	incorperate feedback	2021-07-11 15:41:10 +02:00
Jonathan de Jong	318d9c1a35	revert docker-compose.yml file	2021-07-09 14:43:04 +02:00
Jonathan de Jong	f4aabbdaa7	add some flushes	2021-07-08 17:17:42 +02:00
Jonathan de Jong	7c82213ee7	change to use path joining properly	2021-07-08 14:27:28 +02:00
Jonathan de Jong	0719377c6a	merge one more {use}	2021-07-08 12:13:39 +02:00
Jonathan de Jong	494585267a	remove rjbench	2021-07-07 20:43:30 +02:00
Jonathan de Jong	0c23874194	add config and optimise	2021-07-07 20:36:41 +02:00
Jonathan de Jong	dc5f1f41fd	some more fixes to allow sled to work	2021-07-07 14:04:11 +02:00
Jonathan de Jong	f81018ab2d	reverse iterator funk	2021-07-04 13:30:47 +02:00
Jonathan de Jong	e5a26de606	misc cleanup	2021-07-04 13:14:01 +02:00
Jonathan de Jong	5ec0be2b41	fmt	2021-07-04 02:15:04 +02:00
Jonathan de Jong	a55dec9035	add better performance around syncs	2021-07-04 02:03:46 +02:00
Jonathan de Jong	14e6afc45e	remove eldrich being and install good being	2021-07-04 01:18:06 +02:00
Jonathan de Jong	9df86c2c1e	lock update	2021-07-03 21:30:40 +02:00
Jonathan de Jong	0753076e94	chutulu is my copilot	2021-07-03 21:27:11 +02:00
Jonathan de Jong	22e3416745	YEET	2021-07-03 21:26:50 +02:00
@@ -1 +1 @@
 .52
 .51.0