fix: long prev event fetch times for huge rooms

less warnings
improvement: cache for short event ids
2021-08-12 17:55:16 +02:00 · 2021-08-11 21:17:01 +02:00 · 2021-08-11 21:14:22 +02:00 · 2021-08-11 19:15:38 +02:00 · 2021-08-11 10:24:16 +02:00 · 2021-08-10 05:44:16 +00:00
70 changed files with 4915 additions and 2510 deletions
@@ -0,0 +1,11 @@
+---
+name: "Issue with / Feature Request for Conduit"
+about: "Please file issues on GitLab: https://gitlab.com/famedly/conduit/-/issues/new"
+title: "CLOSE ME"
+---
+
+
+
+**⚠️ Conduit development does not happen on GitHub. Issues opened here will not be addressed** 
+
+Please open issues on GitLab: https://gitlab.com/famedly/conduit/-/issues/new
@@ -59,6 +59,7 @@ $RECYCLE.BIN/
 # Conduit
 Rocket.toml
 conduit.toml
+conduit.db

 # Etc.
 **/*.rs.bk
@@ -1,19 +1,19 @@
 stages:
-  - test
  - build
-  - publish artifacts
-  - release nightly
+  - build docker image
+  - test
+  - upload artifacts

 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,10 +29,66 @@ test:cargo:
    - rustup component add clippy rustfmt
  script:
    - rustc --version && cargo --version  # Print version info for debugging
-    - cargo test --workspace --verbose --locked
    - cargo fmt --all -- --check
+    - cargo test --workspace --verbose --locked
    - 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                         #
 # --------------------------------------------------------------------- #
@@ -44,6 +100,7 @@ test:cargo:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
  interruptible: true
  image: "rust:latest"
+  tags: ["docker"]
  cache:
    paths:
      - cargohome
@@ -58,18 +115,24 @@ test:cargo:
    - "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
@@ -79,6 +142,11 @@ 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
@@ -90,6 +158,30 @@ 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"


 # --------------------------------------------------------------------- #
@@ -104,6 +196,7 @@ build:cargo:aarch64-unknown-linux-gnu:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
  interruptible: true
  image: "rust:latest"
+  tags: ["docker"]
  cache:
    paths:
      - cargohome
@@ -121,35 +214,80 @@ build:cargo:aarch64-unknown-linux-gnu:
  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"



 # --------------------------------------------------------------------- #
-#  Storing and releasing compiled binaries                              #
+#  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                 #
 # --------------------------------------------------------------------- #

 publish:package:
-  stage: "publish artifacts"
+  stage: "upload 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:
@@ -157,32 +295,7 @@ 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"
@@ -0,0 +1,19 @@
+<!--
+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
@@ -0,0 +1,17 @@
+<!--
+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
@@ -1,15 +0,0 @@
-# Headline
-
-### Description
-
-
-
-
-
-
-
-
-
-
-
-/label ~conduit
@@ -0,0 +1,8 @@
+
+<!-- Please describe your changes here -->
+
+-----------------------------------------------------------------------------
+
+- [ ] I ran `cargo fmt` and `cargo test`
+- [ ] I agree to release my code and all other changes of this MR under the Apache-2.0 license
+
@@ -14,45 +14,44 @@ 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 = { 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

 # Used for matrix spec type definitions and helpers
-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 = { 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 = { 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.2.0"
+tokio = "1.8.2"
 # 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.3"
+http = "0.2.4"
 # Used to find data directory for default db path
-directories = "3.0.1"
+directories = "3.0.2"
 # 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.123"
+serde = "1.0.126"
 # Used for secure identifiers
-rand = "0.8.3"
+rand = "0.8.4"
 # Used to hash passwords
 rust-argon2 = "0.8.3"
 # Used to send requests
-reqwest = { version = "0.11.3", default-features = false, features = ["rustls-tls-native-roots", "socks"] }
+reqwest = { version = "0.11.4", default-features = false, features = ["rustls-tls-native-roots", "socks"] }
 # Custom TLS verifier
-rustls = { version = "0.19", features = ["dangerous_configuration"] }
+rustls = { version = "0.19.1", features = ["dangerous_configuration"] }
 rustls-native-certs = "0.5.0"
 webpki = "0.21.0"
 # Used for conduit::Error type
-thiserror = "1.0.24"
+thiserror = "1.0.26"
 # Used to generate thumbnails for images
 image = { version = "0.23.14", default-features = false, features = ["jpeg", "png", "gif"] }
 # Used to encode server public key
@@ -60,24 +59,33 @@ 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.0"
+trust-dns-resolver = "0.20.3"
 # Used to find matching events for appservices
-regex = "1.4.3"
+regex = "1.5.4"
 # jwt jsonwebtokens
 jsonwebtoken = "7.2.0"
 # Performance measurements
-tracing = "0.1.25"
-opentelemetry = "0.12.0"
-tracing-subscriber = "0.2.16"
-tracing-opentelemetry = "0.11.0"
-opentelemetry-jaeger = "0.11.0"
+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"
 pretty_env_logger = "0.4.0"
 lru-cache = "0.1.2"
+rusqlite = { version = "0.25.3", optional = true, features = ["bundled"] }
+parking_lot = { version = "0.11.1", optional = true }
+crossbeam = { version = "0.8.1", optional = true }
+num_cpus = "1.13.0"
+threadpool = "1.8.1"
+heed = { git = "https://github.com/timokoesters/heed.git", rev = "f6f825da7fb2c758867e05ad973ef800a6fe1d5d", optional = true }

 [features]
-default = ["conduit_bin", "backend_sled"]
+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"]
 conduit_bin = [] # TODO: add rocket to this when it is optional

 [[bin]]
@@ -8,10 +8,17 @@ 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:
- 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`
+
+| 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

 ```bash
 $ sudo wget -O /usr/local/bin/matrix-conduit <url>
@@ -26,6 +33,7 @@ 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.
@@ -106,11 +114,13 @@ allow_federation = true

 trusted_servers = ["matrix.org"]

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

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

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

 ##########################  BUILD IMAGE  ##########################
 # Alpine build image to build Conduit's statically compiled binary
-FROM alpine:3.12 as builder
+FROM alpine:3.14 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,11 +13,6 @@ 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 \
@@ -36,7 +31,7 @@ RUN if [[ $LOCAL == "true" ]]; then \
 ########################## RUNTIME IMAGE ##########################
 # Create new stage with a minimal image for the actual
 # runtime image/container
-FROM alpine:3.12
+FROM alpine:3.14

 ARG CREATED
 ARG VERSION
@@ -61,8 +56,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 Rocket launches
-EXPOSE 8000
+# Standard port on which Conduit launches. You still need to map the port when using the docker command or docker-compose.
+EXPOSE 6167

 # Copy config files from context and the binary from
 # the "builder" stage to the current stage into folder
@@ -86,11 +81,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=2s CMD curl --fail -s http://localhost:8000/_matrix/client/versions || curl -k --fail -s https://localhost:8000/_matrix/client/versions || exit 1
+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
@@ -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)
- End-to-end encrypted chats over federation
- Typing, presence, read receipts etc. over federation
+- Edge cases for end-to-end encryption over federation
+- Typing and presence 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/conduit.db"
+database_path = "/var/lib/conduit/"

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

 trusted_servers = ["matrix.org"]

-#cache_capacity = 1073741824 # in bytes, 1024 * 1024 * 1024
 #max_concurrent_requests = 100 # How many requests Conduit sends to other servers at the same time
 #log = "info,state_res=warn,rocket=off,_=off,sled=off"
 #workers = 4 # default: cpu core count * 2
@@ -43,3 +42,6 @@ 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,10 +73,12 @@ max_request_size = 20_000_000 # in bytes
 # Enable jaeger to support monitoring and troubleshooting through jaeger.
 #allow_jaeger = false

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

 services:
    homeserver:
-        ### If you already built the Conduit image with 'docker build' or want to use the Docker Hub image,
+        ### If you already built the Conduit image with 'docker build' or want to use a registry 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:8000
+            - 8448:6167
        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:8000  # replace with your own name
+            CONDUIT_SERVER_NAME: localhost:6167  # replace with your own name
            CONDUIT_TRUSTED_SERVERS: '["matrix.org"]'
            ### Uncomment and change values as desired
-            # CONDUIT_ADDRESS: 127.0.0.1
-            # CONDUIT_PORT: 8000
+            # 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 ''
            # Available levels are: error, warn, info, debug, trace - more info at: https://docs.rs/env_logger/*/env_logger/#enabling-logging
            # CONDUIT_LOG: info  # default is: "info,rocket=off,_=off,sled=off"
@@ -56,4 +56,4 @@ services:
    #         - homeserver

 volumes:
-    db:
+  db:
@@ -0,0 +1,70 @@
+# ---------------------------------------------------------------------------------------------------------
+# 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:
-        #         VERSION:
+        #         CREATED: '2021-03-16T08:18:27Z'
+        #         VERSION: '0.1.0'
        #         LOCAL: 'false'
        #         GIT_REF: origin/master
        restart: unless-stopped
@@ -25,12 +25,12 @@ services:
        networks:
            - proxy
        environment:
-            CONDUIT_SERVER_NAME: localhost:8000  # replace with your own name
+            CONDUIT_SERVER_NAME: localhost:6167  # replace with your own name
            CONDUIT_TRUSTED_SERVERS: '["matrix.org"]'
            ### Uncomment and change values as desired
-            # 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 ''
+            # 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 ''
            # 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 you network has a different
+    # This is the network Traefik listens to, if your 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.51.0
+1.52
@@ -1,6 +1,5 @@
 use crate::{utils, Error, Result};
 use bytes::BytesMut;
-use log::warn;
 use ruma::api::{IncomingResponse, OutgoingRequest, SendAccessToken};
 use std::{
    convert::{TryFrom, TryInto},
@@ -8,6 +7,7 @@ use std::{
    mem,
    time::Duration,
 };
+use tracing::warn;

 pub async fn send_request<T: OutgoingRequest>(
    globals: &crate::database::globals::Globals,
@@ -1,8 +1,11 @@
-use std::{collections::BTreeMap, convert::TryInto, sync::Arc};
+use std::{
+    collections::BTreeMap,
+    convert::{TryFrom, TryInto},
+    sync::Arc,
+};

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

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

@@ -185,6 +193,11 @@ 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,
@@ -236,6 +249,16 @@ pub async fn register_route(

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

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

        // 2. Make conduit bot join
@@ -265,6 +289,7 @@ 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,
@@ -274,6 +299,7 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
+            &state_lock,
        )?;

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

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

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

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

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

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

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

        db.rooms.set_alias(&alias, Some(&room_id), &db.globals)?;
@@ -422,6 +454,7 @@ 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,
@@ -431,16 +464,18 @@ pub async fn register_route(
            &conduit_user,
            &room_id,
            &db,
+            &state_lock,
        )?;
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomMember,
                content: serde_json::to_value(member::MemberEventContent {
                    membership: member::MembershipState::Join,
-                    displayname: None,
+                    displayname: Some(displayname),
                    avatar_url: None,
                    is_direct: None,
                    third_party_invite: None,
+                    blurhash: None,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -450,6 +485,7 @@ pub async fn register_route(
            &user_id,
            &room_id,
            &db,
+            &state_lock,
        )?;

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(deactivate::Response {
        id_server_unbind_result: ThirdPartyIdRemovalStatus::NoSupport,
@@ -670,16 +721,17 @@ 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<account::add_3pid::Request<'_>>,
-) -> ConduitResult<account::add_3pid::Response> {
+    body: Ruma<get_contacts::Request>,
+) -> ConduitResult<get_contacts::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(delete_backup_key_session::Response {
        count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -1,4 +1,5 @@
 use crate::ConduitResult;
+use crate::Ruma;
 use ruma::{
    api::client::r0::capabilities::{
        get_capabilities, Capabilities, RoomVersionStability, RoomVersionsCapability,
@@ -13,10 +14,16 @@ 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"))]
-#[tracing::instrument]
-pub async fn get_capabilities_route() -> ConduitResult<get_capabilities::Response> {
+#[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> {
    let mut available = BTreeMap::new();
+    available.insert(RoomVersionId::Version5, RoomVersionStability::Stable);
    available.insert(RoomVersionId::Version6, RoomVersionStability::Stable);

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

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

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

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

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

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

 #[cfg_attr(
@@ -92,7 +89,7 @@ pub async fn set_room_account_data_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_global_account_data_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<get_global_account_data::Request<'_>>,
 ) -> ConduitResult<get_global_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -101,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().await?;
+    db.flush()?;

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

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

 #[cfg(feature = "conduit_bin")]
 use rocket::get;
@@ -12,7 +11,7 @@ use rocket::get;
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_context_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<get_context::Request<'_>>,
 ) -> ConduitResult<get_context::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -1,7 +1,4 @@
-use std::sync::Arc;
-
-use super::State;
-use crate::{utils, ConduitResult, Database, Error, Ruma};
+use crate::{database::DatabaseGuard, utils, ConduitResult, Error, Ruma};
 use ruma::api::client::{
    error::ErrorKind,
    r0::{
@@ -20,7 +17,7 @@ use rocket::{delete, get, post, put};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_devices_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<get_devices::Request>,
 ) -> ConduitResult<get_devices::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -40,7 +37,7 @@ pub async fn get_devices_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_device_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<get_device::Request<'_>>,
 ) -> ConduitResult<get_device::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -59,7 +56,7 @@ pub async fn get_device_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn update_device_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<update_device::Request<'_>>,
 ) -> ConduitResult<update_device::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -74,9 +71,9 @@ pub async fn update_device_route(
    db.users
        .update_device_metadata(&sender_user, &body.device_id, &device)?;

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

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

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

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

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

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

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

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

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

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

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

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

    match &body.visibility {
-        room::Visibility::_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)?,
+        _ => {
+            return Err(Error::BadRequest(
+                ErrorKind::InvalidParam,
+                "Room visibility type is not supported.",
+            ));
+        }
    }

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

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

 #[cfg_attr(
@@ -114,7 +113,7 @@ pub async fn set_room_visibility_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_room_visibility_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<get_room_visibility::Request<'_>>,
 ) -> ConduitResult<get_room_visibility::Response> {
    Ok(get_room_visibility::Response {
@@ -234,10 +233,18 @@ 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()))
+                            .name
+                            .map(|n| n.to_owned().into()))
                        })?,
-                    num_joined_members: (db.rooms.room_members(&room_id).count() as u32).into(),
+                    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"),
                    topic: db
                        .rooms
                        .room_state_get(&room_id, &EventType::RoomTopic, "")?
@@ -319,7 +326,7 @@ pub async fn get_public_rooms_filtered_helper(
                    .map(|q| q.to_lowercase())
                {
                    if let Some(name) = &chunk.name {
-                        if name.to_lowercase().contains(&query) {
+                        if name.as_str().to_lowercase().contains(&query) {
                            return true;
                        }
                    }
@@ -1,23 +1,24 @@
-use super::{State, SESSION_ID_LENGTH};
-use crate::{utils, ConduitResult, Database, Error, Result, Ruma};
+use super::SESSION_ID_LENGTH;
+use crate::{database::DatabaseGuard, utils, ConduitResult, Database, Error, Result, Ruma};
 use ruma::{
-    api::client::{
-        error::ErrorKind,
-        r0::{
-            keys::{
-                claim_keys, get_key_changes, get_keys, upload_keys, upload_signatures,
-                upload_signing_keys,
+    api::{
+        client::{
+            error::ErrorKind,
+            r0::{
+                keys::{
+                    claim_keys, get_key_changes, get_keys, upload_keys, upload_signatures,
+                    upload_signing_keys,
+                },
+                uiaa::{AuthFlow, UiaaInfo},
            },
-            uiaa::{AuthFlow, UiaaInfo},
        },
+        federation,
    },
    encryption::UnsignedDeviceInfo,
    DeviceId, DeviceKeyAlgorithm, UserId,
 };
-use std::{
-    collections::{BTreeMap, HashSet},
-    sync::Arc,
-};
+use serde_json::json;
+use std::collections::{BTreeMap, HashSet};

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

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

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

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

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

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

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

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

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

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

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

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

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

-pub fn get_keys_helper<F: Fn(&UserId) -> bool>(
+pub async fn get_keys_helper<F: Fn(&UserId) -> bool>(
    sender_user: Option<&UserId>,
    device_keys_input: &BTreeMap<UserId, Vec<Box<DeviceId>>>,
    allowed_signatures: F,
@@ -294,7 +294,17 @@ pub 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) {
@@ -352,21 +362,60 @@ pub 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: BTreeMap::new(),
+        failures,
    })
 }

-pub fn claim_keys_helper(
+pub async 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) =
@@ -381,6 +430,26 @@ pub 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,
@@ -1,20 +1,21 @@
-use super::State;
-use crate::{database::media::FileMeta, utils, ConduitResult, Database, Error, Ruma};
+use crate::{
+    database::media::FileMeta, database::DatabaseGuard, utils, ConduitResult, Error, Ruma,
+};
 use ruma::api::client::{
    error::ErrorKind,
    r0::media::{create_content, get_content, get_content_thumbnail, get_media_config},
 };
+use std::convert::TryInto;

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

 const MXC_LENGTH: usize = 32;

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

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

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

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

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

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

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

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

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

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

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

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

    if let invite_user::IncomingInvitationRecipient::UserId { user_id } = &body.recipient {
        invite_helper(sender_user, user_id, &body.room_id, &db, false).await?;
-        db.flush().await?;
-        Ok(invite_user::Response.into())
+        db.flush()?;
+        Ok(invite_user::Response {}.into())
    } else {
        Err(Error::BadRequest(ErrorKind::NotFound, "User not found."))
    }
@@ -173,7 +177,7 @@ pub async fn invite_user_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn kick_user_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<kick_user::Request<'_>>,
 ) -> ConduitResult<kick_user::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -199,6 +203,16 @@ pub async fn kick_user_route(
    event.membership = ruma::events::room::member::MembershipState::Leave;
    // TODO: reason

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

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

    Ok(kick_user::Response::new().into())
 }
@@ -223,7 +240,7 @@ pub async fn kick_user_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn ban_user_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<ban_user::Request<'_>>,
 ) -> ConduitResult<ban_user::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -244,6 +261,7 @@ 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>>(
@@ -257,6 +275,16 @@ pub async fn ban_user_route(
            },
        )?;

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

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

    Ok(ban_user::Response::new().into())
 }
@@ -281,7 +312,7 @@ pub async fn ban_user_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn unban_user_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<unban_user::Request<'_>>,
 ) -> ConduitResult<unban_user::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -306,6 +337,16 @@ pub async fn unban_user_route(

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

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

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

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

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

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

    Ok(forget_room::Response::new().into())
 }
@@ -348,7 +392,7 @@ pub async fn forget_room_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn joined_rooms_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<joined_rooms::Request>,
 ) -> ConduitResult<joined_rooms::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -369,7 +413,7 @@ pub async fn joined_rooms_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_member_events_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<get_member_events::Request<'_>>,
 ) -> ConduitResult<get_member_events::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -399,7 +443,7 @@ pub async fn get_member_events_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn joined_members_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<joined_members::Request<'_>>,
 ) -> ConduitResult<joined_members::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -442,6 +486,16 @@ 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(
+        db.globals
+            .roomid_mutex_state
+            .write()
+            .unwrap()
+            .entry(room_id.clone())
+            .or_default(),
+    );
+    let state_lock = mutex_state.lock().await;
+
    // Ask a remote server if we don't have this room
    if !db.rooms.exists(&room_id)? && room_id.server_name() != db.globals.server_name() {
        let mut make_join_response_and_server = Err(Error::BadServerResponse(
@@ -457,7 +511,7 @@ async fn join_room_by_id_helper(
                    federation::membership::create_join_event_template::v1::Request {
                        room_id,
                        user_id: sender_user,
-                        ver: &[RoomVersionId::Version6],
+                        ver: &[RoomVersionId::Version5, RoomVersionId::Version6],
                    },
                )
                .await;
@@ -472,7 +526,12 @@ 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::Version6 => room_version,
+            Some(room_version)
+                if room_version == RoomVersionId::Version5
+                    || room_version == RoomVersionId::Version6 =>
+            {
+                room_version
+            }
            _ => return Err(Error::BadServerResponse("Room version is not supported")),
        };

@@ -503,6 +562,7 @@ 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"),
        );
@@ -552,7 +612,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 = BTreeMap::new();
+        let mut state = HashMap::new();
        let pub_key_map = RwLock::new(BTreeMap::new());

        for result in futures::future::join_all(
@@ -615,16 +675,9 @@ async fn join_room_by_id_helper(
        // pdu without it's state. This is okay because append_pdu can't fail.
        let statehashid = db.rooms.append_to_state(&pdu, &db.globals)?;

-        let count = db.globals.next_count()?;
-        let mut pdu_id = room_id.as_bytes().to_vec();
-        pdu_id.push(0xff);
-        pdu_id.extend_from_slice(&count.to_be_bytes());
-
        db.rooms.append_pdu(
            &pdu,
            utils::to_canonical_object(&pdu).expect("Pdu is valid canonical object"),
-            count,
-            &pdu_id,
            &[pdu.event_id.clone()],
            db,
        )?;
@@ -639,6 +692,7 @@ 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(
@@ -652,10 +706,13 @@ async fn join_room_by_id_helper(
            &sender_user,
            &room_id,
            &db,
+            &state_lock,
        )?;
    }

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

    Ok(join_room_by_id::Response::new(room_id.clone()).into())
 }
@@ -724,7 +781,7 @@ async fn validate_and_add_event_id(
    Ok((event_id, value))
 }

-pub async fn invite_helper(
+pub async fn invite_helper<'a>(
    sender_user: &UserId,
    user_id: &UserId,
    room_id: &RoomId,
@@ -732,141 +789,164 @@ pub async fn invite_helper(
    is_direct: bool,
 ) -> Result<()> {
    if user_id.server_name() != db.globals.server_name() {
-        let prev_events = db
-            .rooms
-            .get_pdu_leaves(room_id)?
-            .into_iter()
-            .take(20)
-            .collect::<Vec<_>>();
-
-        let create_event = db
-            .rooms
-            .room_state_get(room_id, &EventType::RoomCreate, "")?;
-
-        let create_event_content = create_event
-            .as_ref()
-            .map(|create_event| {
-                serde_json::from_value::<Raw<CreateEventContent>>(create_event.content.clone())
-                    .expect("Raw::from_value always works.")
-                    .deserialize()
-                    .map_err(|_| Error::bad_database("Invalid PowerLevels event in db."))
-            })
-            .transpose()?;
-
-        let create_prev_event = if prev_events.len() == 1
-            && Some(&prev_events[0]) == create_event.as_ref().map(|c| &c.event_id)
-        {
-            create_event
-        } else {
-            None
-        };
-
-        // If there was no create event yet, assume we are creating a version 6 room right now
-        let room_version_id = create_event_content
-            .map_or(RoomVersionId::Version6, |create_event| {
-                create_event.room_version
-            });
-        let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");
-
-        let content = serde_json::to_value(MemberEventContent {
-            avatar_url: None,
-            displayname: None,
-            is_direct: Some(is_direct),
-            membership: MembershipState::Invite,
-            third_party_invite: None,
-        })
-        .expect("member event is valid value");
-
-        let state_key = user_id.to_string();
-        let kind = EventType::RoomMember;
-
-        let auth_events =
-            db.rooms
-                .get_auth_events(room_id, &kind, &sender_user, Some(&state_key), &content)?;
-
-        // Our depth is the maximum depth of prev_events + 1
-        let depth = prev_events
-            .iter()
-            .filter_map(|event_id| Some(db.rooms.get_pdu(event_id).ok()??.depth))
-            .max()
-            .unwrap_or_else(|| uint!(0))
-            + uint!(1);
-
-        let mut unsigned = BTreeMap::new();
-
-        if let Some(prev_pdu) = db.rooms.room_state_get(room_id, &kind, &state_key)? {
-            unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone());
-            unsigned.insert(
-                "prev_sender".to_owned(),
-                serde_json::to_value(&prev_pdu.sender).expect("UserId::to_value always works"),
+        let (room_version_id, pdu_json, invite_room_state) = {
+            let mutex_state = Arc::clone(
+                db.globals
+                    .roomid_mutex_state
+                    .write()
+                    .unwrap()
+                    .entry(room_id.clone())
+                    .or_default(),
            );
-        }
+            let state_lock = mutex_state.lock().await;

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

-        let auth_check = state_res::auth_check(
-            &room_version,
-            &Arc::new(pdu.clone()),
-            create_prev_event,
-            &auth_events,
-            None, // TODO: third_party_invite
-        )
-        .map_err(|e| {
-            error!("{:?}", e);
-            Error::bad_database("Auth check failed.")
-        })?;
-
-        if !auth_check {
-            return Err(Error::BadRequest(
-                ErrorKind::Forbidden,
-                "Event is not authorized.",
-            ));
-        }
-
-        // Hash and sign
-        let mut pdu_json =
-            utils::to_canonical_object(&pdu).expect("event is valid, we just created it");
-
-        pdu_json.remove("event_id");
-
-        // Add origin because synapse likes that (and it's required in the spec)
-        pdu_json.insert(
-            "origin".to_owned(),
-            to_canonical_value(db.globals.server_name())
-                .expect("server name is a valid CanonicalJsonValue"),
-        );
-
-        ruma::signatures::hash_and_sign_event(
-            db.globals.server_name().as_str(),
-            db.globals.keypair(),
-            &mut pdu_json,
-            &room_version_id,
-        )
-        .expect("event is valid, we just created it");
-
-        let invite_room_state = db.rooms.calculate_invite_state(&pdu)?;
        let response = db
            .sending
            .send_federation_request(
@@ -875,7 +955,7 @@ pub async fn invite_helper(
                create_invite::v2::Request {
                    room_id: room_id.clone(),
                    event_id: ruma::event_id!("$receivingservershouldsetthis"),
-                    room_version: RoomVersionId::Version6,
+                    room_version: room_version_id,
                    event: PduEvent::convert_to_outgoing_federation_event(pdu_json),
                    invite_room_state,
                },
@@ -905,19 +985,26 @@ pub async fn invite_helper(
        )
        .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Origin field is invalid."))?;

-        let pdu_id =
-            server_server::handle_incoming_pdu(&origin, &event_id, value, true, &db, &pub_key_map)
-                .await
-                .map_err(|_| {
-                    Error::BadRequest(
-                        ErrorKind::InvalidParam,
-                        "Error while handling incoming PDU.",
-                    )
-                })?
-                .ok_or(Error::BadRequest(
-                    ErrorKind::InvalidParam,
-                    "Could not accept incoming PDU as timeline event.",
-                ))?;
+        let pdu_id = server_server::handle_incoming_pdu(
+            &origin,
+            &event_id,
+            &room_id,
+            value,
+            true,
+            &db,
+            &pub_key_map,
+        )
+        .await
+        .map_err(|_| {
+            Error::BadRequest(
+                ErrorKind::InvalidParam,
+                "Error while handling incoming PDU.",
+            )
+        })?
+        .ok_or(Error::BadRequest(
+            ErrorKind::InvalidParam,
+            "Could not accept incoming PDU as timeline event.",
+        ))?;

        for server in db
            .rooms
@@ -931,6 +1018,16 @@ pub async fn invite_helper(
        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,
@@ -940,6 +1037,7 @@ pub async fn invite_helper(
                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,
@@ -949,7 +1047,10 @@ pub async fn invite_helper(
        &sender_user,
        room_id,
        &db,
+        &state_lock,
    )?;

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

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

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

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

    Ok(send_message_event::Response::new(event_id).into())
 }
@@ -86,7 +98,7 @@ pub async fn send_message_event_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_message_events_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<get_message_events::Request<'_>>,
 ) -> ConduitResult<get_message_events::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -64,9 +64,7 @@ pub use voip::*;
 use super::State;
 #[cfg(feature = "conduit_bin")]
 use {
-    crate::ConduitResult,
-    rocket::{options, State},
-    ruma::api::client::r0::to_device::send_event_to_device,
+    crate::ConduitResult, rocket::options, ruma::api::client::r0::to_device::send_event_to_device,
 };

 pub const DEVICE_ID_LENGTH: usize = 10;
@@ -77,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())
 }
@@ -1,7 +1,6 @@
-use super::State;
-use crate::{utils, ConduitResult, Database, Ruma};
+use crate::{database::DatabaseGuard, utils, ConduitResult, Ruma};
 use ruma::api::client::r0::presence::{get_presence, set_presence};
-use std::{convert::TryInto, sync::Arc, time::Duration};
+use std::{convert::TryInto, time::Duration};

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

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

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

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

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

 #[cfg_attr(
    feature = "conduit_bin",
@@ -21,7 +23,7 @@ use std::{convert::TryInto, sync::Arc};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_displayname_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<set_display_name::Request<'_>>,
 ) -> ConduitResult<set_display_name::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -30,9 +32,10 @@ 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
-    for (pdu_builder, room_id) in db
-        .rooms
-        .rooms_joined(&sender_user)
+    let all_rooms_joined = db.rooms.rooms_joined(&sender_user).collect::<Vec<_>>();
+
+    for (pdu_builder, room_id) in all_rooms_joined
+        .into_iter()
        .filter_map(|r| r.ok())
        .map(|room_id| {
            Ok::<_, Error>((
@@ -70,9 +73,19 @@ pub async fn set_displayname_route(
        })
        .filter_map(|r| r.ok())
    {
-        let _ = db
-            .rooms
-            .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db);
+        let mutex_state = Arc::clone(
+            db.globals
+                .roomid_mutex_state
+                .write()
+                .unwrap()
+                .entry(room_id.clone())
+                .or_default(),
+        );
+        let state_lock = mutex_state.lock().await;
+
+        let _ =
+            db.rooms
+                .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock);

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

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

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

 #[cfg_attr(
@@ -108,9 +121,28 @@ pub async fn set_displayname_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_displayname_route(
-    db: State<'_, Arc<Database>>,
+    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)?,
    }
@@ -123,7 +155,7 @@ pub async fn get_displayname_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn set_avatar_url_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<set_avatar_url::Request<'_>>,
 ) -> ConduitResult<set_avatar_url::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -131,10 +163,13 @@ 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
-    for (pdu_builder, room_id) in db
-        .rooms
-        .rooms_joined(&sender_user)
+    let all_joined_rooms = db.rooms.rooms_joined(&sender_user).collect::<Vec<_>>();
+
+    for (pdu_builder, room_id) in all_joined_rooms
+        .into_iter()
        .filter_map(|r| r.ok())
        .map(|room_id| {
            Ok::<_, Error>((
@@ -172,9 +207,19 @@ pub async fn set_avatar_url_route(
        })
        .filter_map(|r| r.ok())
    {
-        let _ = db
-            .rooms
-            .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db);
+        let mutex_state = Arc::clone(
+            db.globals
+                .roomid_mutex_state
+                .write()
+                .unwrap()
+                .entry(room_id.clone())
+                .or_default(),
+        );
+        let state_lock = mutex_state.lock().await;
+
+        let _ =
+            db.rooms
+                .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock);

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

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

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

 #[cfg_attr(
@@ -210,11 +255,32 @@ pub async fn set_avatar_url_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_avatar_url_route(
-    db: State<'_, Arc<Database>>,
+    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())
 }
@@ -225,9 +291,30 @@ pub async fn get_avatar_url_route(
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn get_profile_route(
-    db: State<'_, Arc<Database>>,
+    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(
@@ -238,6 +325,7 @@ pub async fn get_profile_route(

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(redact_event::Response { event_id }.into())
 }
@@ -1,10 +1,11 @@
-use super::State;
-use crate::{client_server::invite_helper, pdu::PduBuilder, ConduitResult, Database, Error, Ruma};
-use log::info;
+use crate::{
+    client_server::invite_helper, database::DatabaseGuard, pdu::PduBuilder, ConduitResult, Error,
+    Ruma,
+};
 use ruma::{
    api::client::{
        error::ErrorKind,
-        r0::room::{self, create_room, get_room_event, upgrade_room},
+        r0::room::{self, aliases, create_room, get_room_event, upgrade_room},
    },
    events::{
        room::{guest_access, history_visibility, join_rules, member, name, topic},
@@ -14,6 +15,7 @@ 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};
@@ -24,13 +26,23 @@ use rocket::{get, post};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn create_room_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<create_room::Request<'_>>,
 ) -> ConduitResult<create_room::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

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

+    let mutex_state = Arc::clone(
+        db.globals
+            .roomid_mutex_state
+            .write()
+            .unwrap()
+            .entry(room_id.clone())
+            .or_default(),
+    );
+    let state_lock = mutex_state.lock().await;
+
    let alias = body
        .room_alias_name
        .as_ref()
@@ -53,7 +65,19 @@ 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 = RoomVersionId::Version6;
+    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,
+    };

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

    // 2. Let the room creator join
@@ -79,6 +104,7 @@ 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,
@@ -88,6 +114,7 @@ pub async fn create_room_route(
        &sender_user,
        &room_id,
        &db,
+        &state_lock,
    )?;

    // 3. Power levels
@@ -99,7 +126,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,
-            room::Visibility::_Custom(_) => create_room::RoomPreset::PrivateChat, // Room visibility should not be custom
+            _ => create_room::RoomPreset::PrivateChat, // Room visibility should not be custom
        });

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

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

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

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

    // 5. Events listed in initial_state
    for event in &body.initial_state {
-        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."))?;
+        let pdu_builder = PduBuilder::from(event.deserialize().map_err(|e| {
+            warn!("Invalid initial state event: {:?}", e);
+            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() {
@@ -225,7 +256,7 @@ pub async fn create_room_route(
        }

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

    // 6. Events implied by name and topic
@@ -233,12 +264,8 @@ 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(name.clone()).map_err(|_| {
-                        Error::BadRequest(ErrorKind::InvalidParam, "Name is invalid.")
-                    })?,
-                )
-                .expect("event is valid, we just created it"),
+                content: serde_json::to_value(name::NameEventContent::new(Some(name.clone())))
+                    .expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
                redacts: None,
@@ -246,6 +273,7 @@ pub async fn create_room_route(
            &sender_user,
            &room_id,
            &db,
+            &state_lock,
        )?;
    }

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

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

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

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

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

 #[cfg_attr(
    feature = "conduit_bin",
-    post("/_matrix/client/r0/rooms/<_room_id>/upgrade", data = "<body>")
+    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>")
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn upgrade_room_route(
-    db: State<'_, Arc<Database>>,
+    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::Version6) {
+    if !matches!(
+        body.new_version,
+        RoomVersionId::Version5 | RoomVersionId::Version6
+    ) {
        return Err(Error::BadRequest(
            ErrorKind::UnsupportedRoomVersion,
            "This server does not support that room version.",
@@ -338,6 +398,16 @@ pub async fn upgrade_room_route(
    // Create a replacement room
    let replacement_room = RoomId::new(db.globals.server_name());

+    let mutex_state = Arc::clone(
+        db.globals
+            .roomid_mutex_state
+            .write()
+            .unwrap()
+            .entry(body.room_id.clone())
+            .or_default(),
+    );
+    let state_lock = mutex_state.lock().await;
+
    // Send a m.room.tombstone event to the old room to indicate that it is not intended to be used any further
    // Fail if the sender does not have the required permissions
    let tombstone_event_id = db.rooms.build_and_append_pdu(
@@ -355,8 +425,21 @@ pub async fn upgrade_room_route(
        sender_user,
        &body.room_id,
        &db,
+        &state_lock,
    )?;

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

    // Join the new room
@@ -407,6 +491,7 @@ 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,
@@ -416,6 +501,7 @@ pub async fn upgrade_room_route(
        sender_user,
        &replacement_room,
        &db,
+        &state_lock,
    )?;

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

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

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

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

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

 #[derive(Debug, Deserialize)]
 struct Claims {
@@ -52,7 +50,7 @@ pub async fn get_login_types_route() -> ConduitResult<get_login_types::Response>
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn login_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<login::Request<'_>>,
 ) -> ConduitResult<login::Response> {
    // Validate login method
@@ -145,7 +143,7 @@ pub async fn login_route(

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Ok(event_id)
@@ -1,6 +1,4 @@
-use super::State;
-use crate::{ConduitResult, Database, Error, Result, Ruma, RumaResponse};
-use log::error;
+use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Result, Ruma, RumaResponse};
 use ruma::{
    api::client::r0::{sync::sync_events, uiaa::UiaaResponse},
    events::{room::member::MembershipState, AnySyncEphemeralRoomEvent, EventType},
@@ -8,12 +6,13 @@ use ruma::{
    DeviceId, RoomId, UserId,
 };
 use std::{
-    collections::{btree_map::Entry, hash_map, BTreeMap, HashMap, HashSet},
+    collections::{hash_map::Entry, 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};
@@ -35,13 +34,15 @@ use rocket::{get, tokio};
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn sync_events_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<sync_events::Request<'_>>,
 ) -> std::result::Result<RumaResponse<sync_events::Response>, RumaResponse<UiaaResponse>> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
    let sender_device = body.sender_device.as_ref().expect("user is authenticated");

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

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

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

    let we_have_to_wait = rx.borrow().is_none();
    if we_have_to_wait {
-        let _ = rx.changed().await;
+        if let Err(e) = rx.changed().await {
+            error!("Error waiting for sync: {}", e);
+        }
    }

    let result = match rx
@@ -104,7 +107,7 @@ pub async fn sync_events_route(
 }

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

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

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

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

+        // Get and drop the lock to wait for remaining operations to finish
+        // This will make sure the we have all events until next_batch
+        let mutex_insert = Arc::clone(
+            db.globals
+                .roomid_mutex_insert
+                .write()
+                .unwrap()
+                .entry(room_id.clone())
+                .or_default(),
+        );
+        let insert_lock = mutex_insert.lock().unwrap();
+        drop(insert_lock);
+
        let mut non_timeline_pdus = db
            .rooms
            .pdus_until(&sender_user, &room_id, u64::MAX)
@@ -222,13 +241,16 @@ async fn sync_helper(

        // Database queries:

-        let current_shortstatehash = db.rooms.current_shortstatehash(&room_id)?;
+        let current_shortstatehash = db
+            .rooms
+            .current_shortstatehash(&room_id)?
+            .expect("All rooms have state");

-        // These type is Option<Option<_>>. The outer Option is None when there is no event between
-        // since and the current room state, meaning there should be no updates.
-        // The inner Option is None when there is an event, but there is no state hash associated
-        // with it. This can happen for the RoomCreate event, so all updates should arrive.
-        let first_pdu_before_since = db.rooms.pdus_until(&sender_user, &room_id, since).next();
+        let first_pdu_before_since = db
+            .rooms
+            .pdus_until(&sender_user, &room_id, since)
+            .next()
+            .transpose()?;

        let pdus_after_since = db
            .rooms
@@ -236,11 +258,82 @@ async fn sync_helper(
            .next()
            .is_some();

-        let since_shortstatehash = first_pdu_before_since.as_ref().map(|pdu| {
-            db.rooms
-                .pdu_shortstatehash(&pdu.as_ref().ok()?.1.event_id)
-                .ok()?
-        });
+        let since_shortstatehash = first_pdu_before_since
+            .as_ref()
+            .map(|pdu| {
+                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")
+                    })
+            })
+            .transpose()?
+            .transpose()?;
+
+        // Calculates joined_member_count, invited_member_count and heroes
+        let calculate_counts = || {
+            let joined_member_count = db.rooms.room_members(&room_id).count();
+            let invited_member_count = db.rooms.room_members_invited(&room_id).count();
+
+            // Recalculate heroes (first 5 members)
+            let mut heroes = Vec::new();
+
+            if joined_member_count + invited_member_count <= 5 {
+                // Go through all PDUs and for each member event, check if the user is still joined or
+                // invited until we have 5 or we reach the end
+
+                for hero in db
+                    .rooms
+                    .all_pdus(&sender_user, &room_id)
+                    .filter_map(|pdu| pdu.ok()) // Ignore all broken pdus
+                    .filter(|(_, pdu)| pdu.kind == EventType::RoomMember)
+                    .map(|(_, pdu)| {
+                        let content = serde_json::from_value::<
+                            ruma::events::room::member::MemberEventContent,
+                        >(pdu.content.clone())
+                        .map_err(|_| Error::bad_database("Invalid member event in database."))?;
+
+                        if let Some(state_key) = &pdu.state_key {
+                            let user_id = UserId::try_from(state_key.clone()).map_err(|_| {
+                                Error::bad_database("Invalid UserId in member PDU.")
+                            })?;
+
+                            // The membership was and still is invite or join
+                            if matches!(
+                                content.membership,
+                                MembershipState::Join | MembershipState::Invite
+                            ) && (db.rooms.is_joined(&user_id, &room_id)?
+                                || db.rooms.is_invited(&user_id, &room_id)?)
+                            {
+                                Ok::<_, Error>(Some(state_key.clone()))
+                            } else {
+                                Ok(None)
+                            }
+                        } else {
+                            Ok(None)
+                        }
+                    })
+                    // Filter out buggy users
+                    .filter_map(|u| u.ok())
+                    // Filter for possible heroes
+                    .flatten()
+                {
+                    if heroes.contains(&hero) || hero == sender_user.as_str() {
+                        continue;
+                    }
+
+                    heroes.push(hero);
+                }
+            }
+
+            (
+                Some(joined_member_count),
+                Some(invited_member_count),
+                heroes,
+            )
+        };

        let (
            heroes,
@@ -248,63 +341,110 @@ async fn sync_helper(
            invited_member_count,
            joined_since_last_sync,
            state_events,
-        ) = if pdus_after_since && Some(current_shortstatehash) != since_shortstatehash {
-            let current_state = db.rooms.room_state_full(&room_id)?;
-            let current_members = current_state
-                .iter()
-                .filter(|(key, _)| key.0 == EventType::RoomMember)
-                .map(|(key, value)| (&key.1, value)) // Only keep state key
-                .collect::<Vec<_>>();
-            let encrypted_room = current_state
-                .get(&(EventType::RoomEncryption, "".to_owned()))
-                .is_some();
-            let since_state = since_shortstatehash
-                .as_ref()
-                .map(|since_shortstatehash| {
-                    since_shortstatehash
-                        .map(|since_shortstatehash| db.rooms.state_full(since_shortstatehash))
-                        .transpose()
-                })
-                .transpose()?;
+        ) = if since_shortstatehash.is_none() {
+            // Probably since = 0, we will do an initial sync
+            let (joined_member_count, invited_member_count, heroes) = calculate_counts();

-            let since_encryption = since_state.as_ref().map(|state| {
-                state
-                    .as_ref()
-                    .map(|state| state.get(&(EventType::RoomEncryption, "".to_owned())))
-            });
+            let current_state_ids = db.rooms.state_full_ids(current_shortstatehash)?;
+            let state_events = current_state_ids
+                .iter()
+                .map(|id| db.rooms.get_pdu(id))
+                .filter_map(|r| r.ok().flatten())
+                .collect::<Vec<_>>();
+
+            (
+                heroes,
+                joined_member_count,
+                invited_member_count,
+                true,
+                state_events,
+            )
+        } else if !pdus_after_since || since_shortstatehash == Some(current_shortstatehash) {
+            // No state changes
+            (Vec::new(), None, None, false, Vec::new())
+        } else {
+            // Incremental /sync
+            let since_shortstatehash = since_shortstatehash.unwrap();
+
+            let since_sender_member = db
+                .rooms
+                .state_get(
+                    since_shortstatehash,
+                    &EventType::RoomMember,
+                    sender_user.as_str(),
+                )?
+                .and_then(|pdu| {
+                    serde_json::from_value::<Raw<ruma::events::room::member::MemberEventContent>>(
+                        pdu.content.clone(),
+                    )
+                    .expect("Raw::from_value always works")
+                    .deserialize()
+                    .map_err(|_| Error::bad_database("Invalid PDU in database."))
+                    .ok()
+                });
+
+            let joined_since_last_sync = since_sender_member
+                .map_or(true, |member| member.membership != MembershipState::Join);
+
+            let current_state_ids = db.rooms.state_full_ids(current_shortstatehash)?;
+
+            let since_state_ids = db.rooms.state_full_ids(since_shortstatehash)?;
+
+            let state_events = if joined_since_last_sync {
+                current_state_ids
+                    .iter()
+                    .map(|id| db.rooms.get_pdu(id))
+                    .filter_map(|r| r.ok().flatten())
+                    .collect::<Vec<_>>()
+            } else {
+                current_state_ids
+                    .difference(&since_state_ids)
+                    .filter(|id| {
+                        !timeline_pdus
+                            .iter()
+                            .any(|(_, timeline_pdu)| timeline_pdu.event_id == **id)
+                    })
+                    .map(|id| db.rooms.get_pdu(id))
+                    .filter_map(|r| r.ok().flatten())
+                    .collect()
+            };
+
+            let encrypted_room = db
+                .rooms
+                .state_get(current_shortstatehash, &EventType::RoomEncryption, "")?
+                .is_some();
+
+            let since_encryption =
+                db.rooms
+                    .state_get(since_shortstatehash, &EventType::RoomEncryption, "")?;

            // Calculations:
-            let new_encrypted_room =
-                encrypted_room && since_encryption.map_or(true, |encryption| encryption.is_none());
+            let new_encrypted_room = encrypted_room && since_encryption.is_none();

-            let send_member_count = since_state.as_ref().map_or(true, |since_state| {
-                since_state.as_ref().map_or(true, |since_state| {
-                    current_members.len()
-                        != since_state
-                            .iter()
-                            .filter(|(key, _)| key.0 == EventType::RoomMember)
-                            .count()
-                })
-            });
-
-            let since_sender_member = since_state.as_ref().map(|since_state| {
-                since_state.as_ref().and_then(|state| {
-                    state
-                        .get(&(EventType::RoomMember, sender_user.as_str().to_owned()))
-                        .and_then(|pdu| {
-                            serde_json::from_value::<
-                                Raw<ruma::events::room::member::MemberEventContent>,
-                            >(pdu.content.clone())
-                            .expect("Raw::from_value always works")
-                            .deserialize()
-                            .map_err(|_| Error::bad_database("Invalid PDU in database."))
-                            .ok()
-                        })
-                })
-            });
+            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
+                });

            if encrypted_room {
-                for (user_id, current_member) in current_members {
+                for (user_id, current_member) in db
+                    .rooms
+                    .room_members(&room_id)
+                    .filter_map(|r| r.ok())
+                    .filter_map(|user_id| {
+                        db.rooms
+                            .state_get(
+                                current_shortstatehash,
+                                &EventType::RoomMember,
+                                user_id.as_str(),
+                            )
+                            .ok()
+                            .flatten()
+                            .map(|current_member| (user_id, current_member))
+                    })
+                {
                    let current_membership = serde_json::from_value::<
                        Raw<ruma::events::room::member::MemberEventContent>,
                    >(current_member.content.clone())
@@ -313,31 +453,23 @@ async fn sync_helper(
                    .map_err(|_| Error::bad_database("Invalid PDU in database."))?
                    .membership;

-                    let since_membership =
-                        since_state
-                            .as_ref()
-                            .map_or(MembershipState::Leave, |since_state| {
-                                since_state
-                                    .as_ref()
-                                    .and_then(|since_state| {
-                                        since_state
-                                            .get(&(EventType::RoomMember, user_id.clone()))
-                                            .and_then(|since_member| {
-                                                serde_json::from_value::<
-                                                Raw<ruma::events::room::member::MemberEventContent>,
-                                            >(
-                                                since_member.content.clone()
-                                            )
-                                            .expect("Raw::from_value always works")
-                                            .deserialize()
-                                            .map_err(|_| {
-                                                Error::bad_database("Invalid PDU in database.")
-                                            })
-                                            .ok()
-                                            })
-                                    })
-                                    .map_or(MembershipState::Leave, |member| member.membership)
-                            });
+                    let since_membership = db
+                        .rooms
+                        .state_get(
+                            since_shortstatehash,
+                            &EventType::RoomMember,
+                            user_id.as_str(),
+                        )?
+                        .and_then(|since_member| {
+                            serde_json::from_value::<
+                                Raw<ruma::events::room::member::MemberEventContent>,
+                            >(since_member.content.clone())
+                            .expect("Raw::from_value always works")
+                            .deserialize()
+                            .map_err(|_| Error::bad_database("Invalid PDU in database."))
+                            .ok()
+                        })
+                        .map_or(MembershipState::Leave, |member| member.membership);

                    let user_id = UserId::try_from(user_id.clone())
                        .map_err(|_| Error::bad_database("Invalid UserId in member PDU."))?;
@@ -359,10 +491,6 @@ async fn sync_helper(
                }
            }

-            let joined_since_last_sync = since_sender_member.map_or(true, |member| {
-                member.map_or(true, |member| member.membership != MembershipState::Join)
-            });
-
            if joined_since_last_sync && encrypted_room || new_encrypted_room {
                // If the user is in a new encrypted room, give them all joined users
                device_list_updates.extend(
@@ -382,100 +510,11 @@ async fn sync_helper(
            }

            let (joined_member_count, invited_member_count, heroes) = if send_member_count {
-                let joined_member_count = db.rooms.room_members(&room_id).count();
-                let invited_member_count = db.rooms.room_members_invited(&room_id).count();
-
-                // Recalculate heroes (first 5 members)
-                let mut heroes = Vec::new();
-
-                if joined_member_count + invited_member_count <= 5 {
-                    // Go through all PDUs and for each member event, check if the user is still joined or
-                    // invited until we have 5 or we reach the end
-
-                    for hero in db
-                        .rooms
-                        .all_pdus(&sender_user, &room_id)
-                        .filter_map(|pdu| pdu.ok()) // Ignore all broken pdus
-                        .filter(|(_, pdu)| pdu.kind == EventType::RoomMember)
-                        .map(|(_, pdu)| {
-                            let content = serde_json::from_value::<
-                                ruma::events::room::member::MemberEventContent,
-                            >(pdu.content.clone())
-                            .map_err(|_| {
-                                Error::bad_database("Invalid member event in database.")
-                            })?;
-
-                            if let Some(state_key) = &pdu.state_key {
-                                let user_id =
-                                    UserId::try_from(state_key.clone()).map_err(|_| {
-                                        Error::bad_database("Invalid UserId in member PDU.")
-                                    })?;
-
-                                // The membership was and still is invite or join
-                                if matches!(
-                                    content.membership,
-                                    MembershipState::Join | MembershipState::Invite
-                                ) && (db.rooms.is_joined(&user_id, &room_id)?
-                                    || db.rooms.is_invited(&user_id, &room_id)?)
-                                {
-                                    Ok::<_, Error>(Some(state_key.clone()))
-                                } else {
-                                    Ok(None)
-                                }
-                            } else {
-                                Ok(None)
-                            }
-                        })
-                        // Filter out buggy users
-                        .filter_map(|u| u.ok())
-                        // Filter for possible heroes
-                        .flatten()
-                    {
-                        if heroes.contains(&hero) || hero == sender_user.as_str() {
-                            continue;
-                        }
-
-                        heroes.push(hero);
-                    }
-                }
-
-                (
-                    Some(joined_member_count),
-                    Some(invited_member_count),
-                    heroes,
-                )
+                calculate_counts()
            } else {
                (None, None, Vec::new())
            };

-            let state_events = if joined_since_last_sync {
-                current_state
-                    .iter()
-                    .map(|(_, pdu)| pdu.to_sync_state_event())
-                    .collect()
-            } else {
-                match since_state {
-                    None => Vec::new(),
-                    Some(Some(since_state)) => current_state
-                        .iter()
-                        .filter(|(key, value)| {
-                            since_state.get(key).map(|e| &e.event_id) != Some(&value.event_id)
-                        })
-                        .filter(|(_, value)| {
-                            !timeline_pdus.iter().any(|(_, timeline_pdu)| {
-                                timeline_pdu.kind == value.kind
-                                    && timeline_pdu.state_key == value.state_key
-                            })
-                        })
-                        .map(|(_, pdu)| pdu.to_sync_state_event())
-                        .collect(),
-                    Some(None) => current_state
-                        .iter()
-                        .map(|(_, pdu)| pdu.to_sync_state_event())
-                        .collect(),
-                }
-            };
-
            (
                heroes,
                joined_member_count,
@@ -483,8 +522,6 @@ async fn sync_helper(
                joined_since_last_sync,
                state_events,
            )
-        } else {
-            (Vec::new(), None, None, false, Vec::new())
        };

        // Look for device list updates in this room
@@ -575,7 +612,10 @@ async fn sync_helper(
                events: room_events,
            },
            state: sync_events::State {
-                events: state_events,
+                events: state_events
+                    .iter()
+                    .map(|pdu| pdu.to_sync_state_event())
+                    .collect(),
            },
            ephemeral: sync_events::Ephemeral { events: edus },
        };
@@ -591,10 +631,10 @@ async fn sync_helper(
                .presence_since(&room_id, since, &db.rooms, &db.globals)?
        {
            match presence_updates.entry(user_id) {
-                hash_map::Entry::Vacant(v) => {
+                Entry::Vacant(v) => {
                    v.insert(presence);
                }
-                hash_map::Entry::Occupied(mut o) => {
+                Entry::Occupied(mut o) => {
                    let p = o.get_mut();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+    // TODO: uncomment when https://github.com/vector-im/element-android/issues/3589 is solved
    // Check if this is a new transaction id
+    /*
    if db
        .transaction_ids
        .existing_txnid(sender_user, sender_device, &body.txn_id)?
@@ -30,9 +35,32 @@ pub async fn send_event_to_device_route(
    {
        return Ok(send_event_to_device::Response.into());
    }
+    */

    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,
@@ -67,7 +95,7 @@ pub async fn send_event_to_device_route(
    db.transaction_ids
        .add_txnid(sender_user, sender_device, &body.txn_id, &[])?;

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

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

@@ -14,7 +11,7 @@ use rocket::put;
 )]
 #[tracing::instrument(skip(db, body))]
 pub fn create_typing_event_route(
-    db: State<'_, Arc<Database>>,
+    db: DatabaseGuard,
    body: Ruma<create_typing_event::Request<'_>>,
 ) -> ConduitResult<create_typing_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -32,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())
 }
@@ -1,7 +1,4 @@
-use std::sync::Arc;
-
-use super::State;
-use crate::{ConduitResult, Database, Ruma};
+use crate::{database::DatabaseGuard, ConduitResult, Ruma};
 use ruma::api::client::r0::user_directory::search_users;

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

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

@@ -17,18 +17,26 @@ 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};
-use ruma::{DeviceId, ServerName, UserId};
-use serde::Deserialize;
+use rocket::{
+    futures::{channel::mpsc, stream::FuturesUnordered, StreamExt},
+    outcome::{try_outcome, IntoOutcome},
+    request::{FromRequest, Request},
+    Shutdown, State,
+};
+use ruma::{DeviceId, RoomId, ServerName, UserId};
+use serde::{de::IgnoredAny, Deserialize};
 use std::{
-    collections::HashMap,
+    collections::{BTreeMap, HashMap},
+    convert::TryFrom,
    fs::{self, remove_dir_all},
    io::Write,
-    sync::{Arc, RwLock},
+    ops::Deref,
+    path::Path,
+    sync::{Arc, Mutex, RwLock},
 };
-use tokio::sync::Semaphore;
+use tokio::sync::{OwnedRwLockReadGuard, RwLock as TokioRwLock, Semaphore};
+use tracing::{debug, error, warn};

 use self::proxy::ProxyConfig;

@@ -36,8 +44,10 @@ use self::proxy::ProxyConfig;
 pub struct Config {
    server_name: Box<ServerName>,
    database_path: String,
-    #[serde(default = "default_cache_capacity")]
-    cache_capacity: u32,
+    #[serde(default = "default_db_cache_capacity_mb")]
+    db_cache_capacity_mb: f64,
+    #[serde(default = "default_sqlite_wal_clean_second_interval")]
+    sqlite_wal_clean_second_interval: u32,
    #[serde(default = "default_max_request_size")]
    max_request_size: u32,
    #[serde(default = "default_max_concurrent_requests")]
@@ -50,6 +60,8 @@ 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>,
@@ -57,6 +69,29 @@ pub struct Config {
    trusted_servers: Vec<Box<ServerName>>,
    #[serde(default = "default_log")]
    pub log: String,
+
+    #[serde(flatten)]
+    catchall: BTreeMap<String, IgnoredAny>,
+}
+
+const DEPRECATED_KEYS: &[&str] = &["cache_capacity"];
+
+impl Config {
+    pub fn warn_deprecated(&self) {
+        let mut was_deprecated = false;
+        for key in self
+            .catchall
+            .keys()
+            .filter(|key| DEPRECATED_KEYS.iter().any(|s| s == key))
+        {
+            warn!("Config parameter {} is deprecated", key);
+            was_deprecated = true;
+        }
+
+        if was_deprecated {
+            warn!("Read conduit documentation and check your configuration if any new configuration parameters should be adjusted");
+        }
+    }
 }

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

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

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

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

-#[cfg(feature = "rocksdb")]
-pub type Engine = abstraction::RocksDbEngine;
+#[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,
    pub users: users::Users,
    pub uiaa: uiaa::Uiaa,
@@ -117,8 +160,37 @@ 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<Self>> {
+    pub async fn load_or_create(config: &Config) -> Result<Arc<TokioRwLock<Self>>> {
+        Self::check_sled_or_sqlite_db(&config)?;
+
        let builder = Engine::open(&config)?;

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

-        let db = Arc::new(Self {
+        let db = Arc::new(TokioRwLock::from(Self {
+            _db: builder.clone(),
            users: users::Users {
                userid_password: builder.open_tree("userid_password")?,
                userid_displayname: builder.open_tree("userid_displayname")?,
                userid_avatarurl: builder.open_tree("userid_avatarurl")?,
+                userid_blurhash: builder.open_tree("userid_blurhash")?,
                userdeviceid_token: builder.open_tree("userdeviceid_token")?,
                userdeviceid_metadata: builder.open_tree("userdeviceid_metadata")?,
                userid_devicelistversion: builder.open_tree("userid_devicelistversion")?,
@@ -176,6 +250,7 @@ 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")?,
@@ -194,11 +269,14 @@ impl Database {
                statehash_shortstatehash: builder.open_tree("statehash_shortstatehash")?,

                eventid_outlierpdu: builder.open_tree("eventid_outlierpdu")?,
-                prevevent_parent: builder.open_tree("prevevent_parent")?,
-                pdu_cache: RwLock::new(LruCache::new(1_000_000)),
+                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)),
            },
            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")?,
@@ -213,8 +291,8 @@ impl Database {
            },
            sending: sending::Sending {
                servername_educount: builder.open_tree("servername_educount")?,
-                servernamepduids: builder.open_tree("servernamepduids")?,
-                servercurrentevents: builder.open_tree("servercurrentevents")?,
+                servernameevent_data: builder.open_tree("servernameevent_data")?,
+                servercurrentevent_data: builder.open_tree("servercurrentevent_data")?,
                maximum_requests: Arc::new(Semaphore::new(config.max_concurrent_requests as usize)),
                sender: sending_sender,
            },
@@ -231,104 +309,170 @@ impl Database {
            globals: globals::Globals::load(
                builder.open_tree("global")?,
                builder.open_tree("server_signingkeys")?,
-                config,
+                config.clone(),
            )?,
-        });
+        }));

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

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

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

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

-            db.globals.bump_database_version(4)?;
+            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();

-            println!("Migration: 3 -> 4 finished");
+                    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");
+            }
        }

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

-        db.admin.start_handler(Arc::clone(&db), admin_receiver);
-        db.sending.start_handler(Arc::clone(&db), sending_receiver);
+        // This data is probably outdated
+        guard.rooms.edus.presenceid_presence.clear()?;
+
+        guard.admin.start_handler(Arc::clone(&db), admin_receiver);
+        guard
+            .sending
+            .start_handler(Arc::clone(&db), sending_receiver);
+
+        drop(guard);
+
+        #[cfg(feature = "sqlite")]
+        {
+            Self::start_wal_clean_task(Arc::clone(&db), &config).await;
+        }

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

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

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

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

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

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

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

-#[cfg(feature = "rocksdb")]
-pub struct RocksDbEngine(rocksdb::DBWithThreadMode<rocksdb::MultiThreaded>);
-#[cfg(feature = "rocksdb")]
-pub struct RocksDbEngineTree<'a> {
-    db: Arc<RocksDbEngine>,
-    name: &'a str,
-    watchers: RwLock<BTreeMap<Vec<u8>, Vec<tokio::sync::oneshot::Sender<()>>>>,
-}
+#[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>>;
+    fn flush(self: &Arc<Self>) -> Result<()>;
 }

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

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

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

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

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

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

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

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

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

-        // 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 roomuserdataid = prefix.clone();
+        roomuserdataid.extend_from_slice(&globals.next_count()?.to_be_bytes());
+        roomuserdataid.push(0xff);
+        roomuserdataid.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 mut key = prefix.clone();
+        key.extend_from_slice(event_type.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,29 +52,58 @@ impl AccountData {
        }

        self.roomuserdataid_accountdata.insert(
-            &key,
+            &roomuserdataid,
            &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>> {
-        self.find_event(room_id, user_id, &kind)?
-            .map(|(_, v)| {
-                serde_json::from_slice(&v).map_err(|_| Error::bad_database("could not deserialize"))
+        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"))
            })
            .transpose()
    }

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

        Ok(userdata)
    }
-
-    fn find_event(
-        &self,
-        room_id: Option<&RoomId>,
-        user_id: &UserId,
-        kind: &EventType,
-    ) -> Result<Option<(Box<[u8]>, Box<[u8]>)>> {
-        let mut prefix = room_id
-            .map(|r| r.to_string())
-            .unwrap_or_default()
-            .as_bytes()
-            .to_vec();
-        prefix.push(0xff);
-        prefix.extend_from_slice(&user_id.as_bytes());
-        prefix.push(0xff);
-
-        let mut last_possible_key = prefix.clone();
-        last_possible_key.extend_from_slice(&u64::MAX.to_be_bytes());
-
-        let kind = kind.clone();
-
-        Ok(self
-            .roomuserdataid_accountdata
-            .iter_from(&last_possible_key, true)
-            .take_while(move |(k, _)| k.starts_with(&prefix))
-            .find(move |(k, _)| {
-                k.rsplit(|&b| b == 0xff)
-                    .next()
-                    .map(|current_event_type| current_event_type == kind.as_ref().as_bytes())
-                    .unwrap_or(false)
-            }))
-    }
 }
@@ -4,12 +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),
@@ -25,73 +26,97 @@ pub struct Admin {
 impl Admin {
    pub fn start_handler(
        &self,
-        db: Arc<Database>,
+        db: Arc<RwLock<Database>>,
        mut receiver: mpsc::UnboundedReceiver<AdminCommand>,
    ) {
        tokio::spawn(async move {
            // TODO: Use futures when we have long admin commands
            //let mut futures = FuturesUnordered::new();

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

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

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

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

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

 use super::abstraction::Tree;
@@ -25,6 +26,11 @@ 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>>,
@@ -35,18 +41,14 @@ 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<BTreeMap<EventId, RateLimitState>>>,
-    pub bad_signature_ratelimiter: Arc<RwLock<BTreeMap<Vec<String>, RateLimitState>>>,
-    pub servername_ratelimiter: Arc<RwLock<BTreeMap<Box<ServerName>, Arc<Semaphore>>>>,
-    pub sync_receivers: RwLock<
-        BTreeMap<
-            (UserId, Box<DeviceId>),
-            (
-                Option<String>,
-                tokio::sync::watch::Receiver<Option<ConduitResult<sync_events::Response>>>,
-            ), // since, rx
-        >,
-    >,
+    pub bad_event_ratelimiter: Arc<RwLock<HashMap<EventId, RateLimitState>>>,
+    pub bad_signature_ratelimiter: Arc<RwLock<HashMap<Vec<String>, RateLimitState>>>,
+    pub servername_ratelimiter: Arc<RwLock<HashMap<Box<ServerName>, Arc<Semaphore>>>>,
+    pub sync_receivers: RwLock<HashMap<(UserId, Box<DeviceId>), SyncHandle>>,
+    pub roomid_mutex_insert: RwLock<HashMap<RoomId, Arc<Mutex<()>>>>,
+    pub roomid_mutex_state: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>,
+    pub roomid_mutex_federation: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>, // this lock will be held longer
+    pub rotate: RotationHandler,
 }

 struct MatrixServerVerifier {
@@ -55,6 +57,7 @@ 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,
@@ -82,6 +85,37 @@ 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 {
+    pub fn new() -> Self {
+        let (s, r) = broadcast::channel::<()>(1);
+
+        Self(s, r)
+    }
+
+    pub fn watch(&self) -> impl Future<Output = ()> {
+        let mut r = self.0.subscribe();
+
+        async move {
+            let _ = r.recv().await;
+        }
+    }
+
+    pub fn fire(&self) {
+        let _ = self.0.send(());
+    }
+}
+
+impl Default for RotationHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Globals {
    pub fn load(
        globals: Arc<dyn Tree>,
@@ -164,10 +198,14 @@ impl Globals {
            tls_name_override,
            server_signingkeys,
            jwt_decoding_key,
-            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())),
-            sync_receivers: RwLock::new(BTreeMap::new()),
+            bad_event_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
+            bad_signature_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
+            servername_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
+            roomid_mutex_state: RwLock::new(HashMap::new()),
+            roomid_mutex_insert: RwLock::new(HashMap::new()),
+            roomid_mutex_federation: RwLock::new(HashMap::new()),
+            sync_receivers: RwLock::new(HashMap::new()),
+            rotate: RotationHandler::new(),
        };

        fs::create_dir_all(s.get_media_folder())?;
@@ -185,11 +223,13 @@ 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,6 +54,7 @@ impl Media {
    }

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

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

-        if let Some((key, _)) = self.mediaid_file.scan_prefix(thumbnail_prefix).next() {
+        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 {
            // Using saved thumbnail
            let path = globals.get_media_file(&key);
            let mut file = Vec::new();
@@ -224,7 +227,7 @@ impl Media {
                content_type,
                file: file.to_vec(),
            }))
-        } else if let Some((key, _)) = self.mediaid_file.scan_prefix(original_prefix).next() {
+        } else if let Some((key, _)) = first_originalprefix {
            // Generate a thumbnail
            let path = globals.get_media_file(&key);
            let mut file = Vec::new();
@@ -1,6 +1,5 @@
 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},
@@ -10,10 +9,13 @@ use ruma::{
        },
        IncomingResponse, OutgoingRequest, SendAccessToken,
    },
-    events::{room::power_levels::PowerLevelsEventContent, EventType},
+    events::{room::power_levels::PowerLevelsEventContent, AnySyncRoomEvent, EventType},
+    identifiers::RoomName,
    push::{Action, PushConditionRoomCtx, PushFormat, Ruleset, Tweak},
-    uint, UInt, UserId,
+    serde::Raw,
+    uint, RoomId, UInt, UserId,
 };
+use tracing::{error, info, warn};

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

@@ -25,6 +27,7 @@ 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);
@@ -47,6 +50,7 @@ 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)?
@@ -57,6 +61,7 @@ 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);
@@ -70,10 +75,11 @@ impl PushData {
            .collect()
    }

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

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

+#[tracing::instrument(skip(globals, destination, request))]
 pub async fn send_request<T: OutgoingRequest>(
    globals: &crate::database::globals::Globals,
    destination: &str,
@@ -154,6 +161,7 @@ where
    }
 }

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

-    for action in get_actions(user, &ruleset, pdu, db)? {
+    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,
+    )? {
        let n = match action {
            Action::DontNotify => false,
            // TODO: Implement proper support for coalesce
@@ -193,37 +218,31 @@ pub async fn send_push_notice(
    Ok(())
 }

+#[tracing::instrument(skip(user, ruleset, pdu, db))]
 pub fn get_actions<'a>(
    user: &UserId,
    ruleset: &'a Ruleset,
-    pdu: &PduEvent,
+    power_levels: &PowerLevelsEventContent,
+    pdu: &Raw<AnySyncRoomEvent>,
+    room_id: &RoomId,
    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: pdu.room_id.clone(),
+        room_id: 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,
+        users_power_levels: power_levels.users.clone(),
        default_power_level: power_levels.users_default,
-        notification_power_levels: power_levels.notifications,
+        notification_power_levels: power_levels.notifications.clone(),
    };

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

+#[tracing::instrument(skip(unread, pusher, tweaks, event, db))]
 async fn send_notice(
    unread: UInt,
    pusher: &get_pushers::Pusher,
@@ -299,7 +318,9 @@ 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(s.to_string()),
+                Some(serde_json::Value::String(s)) => {
+                    Some(Box::<RoomName>::try_from(&**s).expect("room name is valid"))
+                }
                _ => None,
            })
            .flatten();
@@ -116,6 +116,7 @@ impl RoomEdus {
    }

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

    /// Sets all users to offline who have been quiet for too long.
-    pub fn presence_maintain(
+    fn presence_maintain(
        &self,
        rooms: &super::Rooms,
        globals: &super::super::globals::Globals,
@@ -496,7 +497,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,7 +10,6 @@ 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,
@@ -30,7 +29,11 @@ use ruma::{
    receipt::ReceiptType,
    MilliSecondsSinceUnixEpoch, ServerName, UInt, UserId,
 };
-use tokio::{select, sync::Semaphore};
+use tokio::{
+    select,
+    sync::{RwLock, Semaphore},
+};
+use tracing::{error, warn};

 use super::abstraction::Tree;

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

 impl OutgoingKind {
+    #[tracing::instrument(skip(self))]
    pub fn get_prefix(&self) -> Vec<u8> {
        let mut prefix = match self {
            OutgoingKind::Appservice(server) => {
@@ -77,10 +81,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) servernamepduids: Arc<dyn Tree>, // ServernamePduId = (+ / $)SenderKey / ServerName / UserId + PduId
-    pub(super) servercurrentevents: Arc<dyn Tree>, // ServerCurrentEvents = (+ / $)ServerName / UserId + PduId / (*)EduEvent
+    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) maximum_requests: Arc<Semaphore>,
-    pub sender: mpsc::UnboundedSender<Vec<u8>>,
+    pub sender: mpsc::UnboundedSender<(Vec<u8>, Vec<u8>)>,
 }

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

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

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

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

                entry.push(event);
            }

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

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

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

                                if !new_events.is_empty() {
                                    // Insert pdus we found
-                                    for event in &new_events {
-                                        let mut current_key = prefix.clone();
-                                        match event {
-                                            SendingEventType::Pdu(b) |
-                                            SendingEventType::Edu(b) => {
-                                                current_key.extend_from_slice(&b);
-                                                db.sending.servercurrentevents.insert(&current_key, &[]).unwrap();
-                                                db.sending.servernamepduids.remove(&current_key).unwrap();
-                                             }
-                                        }
+                                    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();
                                    }

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

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

                // If it was a PDU we have to unqueue it
                // TODO: don't try to unqueue EDUs
-                db.sending.servernamepduids.remove(&full_key)?;
+                db.sending.servernameevent_data.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_from_slice(&select_edus);
+                    events.extend(select_edus.into_iter().map(SendingEventType::Edu));
+
                    db.sending
                        .servername_educount
                        .insert(server_name.as_bytes(), &last_count.to_be_bytes())?;
@@ -278,7 +304,8 @@ impl Sending {
        Ok(Some(events))
    }

-    pub fn select_edus(db: &Database, server: &ServerName) -> Result<(Vec<SendingEventType>, u64)> {
+    #[tracing::instrument(skip(db, server))]
+    pub fn select_edus(db: &Database, server: &ServerName) -> Result<(Vec<Vec<u8>>, u64)> {
        // u64: count of last edu
        let since = db
            .sending
@@ -343,9 +370,7 @@ impl Sending {
                    }
                };

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

                if events.len() >= 20 {
                    break 'outer;
@@ -356,25 +381,36 @@ impl Sending {
        Ok((events, max_edu_count))
    }

-    #[tracing::instrument(skip(self))]
-    pub fn send_push_pdu(&self, pdu_id: &[u8], senderkey: Box<[u8]>) -> Result<()> {
+    #[tracing::instrument(skip(self, pdu_id, senderkey))]
+    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.servernamepduids.insert(&key, b"")?;
-        self.sender.unbounded_send(key).unwrap();
+        self.servernameevent_data.insert(&key, &[])?;
+        self.sender.unbounded_send((key, vec![])).unwrap();

        Ok(())
    }

-    #[tracing::instrument(skip(self))]
+    #[tracing::instrument(skip(self, server, pdu_id))]
    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.servernamepduids.insert(&key, b"")?;
-        self.sender.unbounded_send(key).unwrap();
+        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();

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

        Ok(())
    }

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

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

-    fn parse_servercurrentevent(key: &[u8]) -> Result<(OutgoingKind, SendingEventType)> {
+    #[tracing::instrument(skip(key))]
+    fn parse_servercurrentevent(
+        key: &[u8],
+        value: Vec<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);
@@ -647,7 +685,7 @@ impl Sending {
                    Error::bad_database("Invalid server string in server_currenttransaction")
                })?),
                if event.starts_with(b"*") {
-                    SendingEventType::Edu(event[1..].to_vec())
+                    SendingEventType::Edu(value)
                } else {
                    SendingEventType::Pdu(event.to_vec())
                },
@@ -665,7 +703,7 @@ impl Sending {
            (
                OutgoingKind::Push(user.to_vec(), pushkey.to_vec()),
                if event.starts_with(b"*") {
-                    SendingEventType::Edu(event[1..].to_vec())
+                    SendingEventType::Edu(value)
                } else {
                    SendingEventType::Pdu(event.to_vec())
                },
@@ -694,7 +732,7 @@ impl Sending {
        })
    }

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

-    #[tracing::instrument(skip(self, globals))]
+    #[tracing::instrument(skip(self, globals, registration, request))]
    pub async fn send_appservice_request<T: OutgoingRequest>(
        &self,
        globals: &crate::database::globals::Globals,
@@ -8,6 +8,7 @@ use ruma::{
    DeviceId, DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, UInt, UserId,
 };
 use std::{collections::BTreeMap, convert::TryFrom, mem, sync::Arc};
+use tracing::warn;

 use super::abstraction::Tree;

@@ -15,6 +16,7 @@ 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
@@ -33,11 +35,13 @@ 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
@@ -50,17 +54,20 @@ 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())?
@@ -88,6 +95,7 @@ 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(|_| {
@@ -98,6 +106,7 @@ 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())?
@@ -109,6 +118,7 @@ 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) {
@@ -128,6 +138,7 @@ 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())?
@@ -139,6 +150,7 @@ 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
@@ -150,7 +162,8 @@ impl Users {
        Ok(())
    }

-    /// Get a the avatar_url of a user.
+    /// Get the avatar_url of a user.
+    #[tracing::instrument(skip(self, user_id))]
    pub fn avatar_url(&self, user_id: &UserId) -> Result<Option<MxcUri>> {
        self.userid_avatarurl
            .get(user_id.as_bytes())?
@@ -163,6 +176,7 @@ 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
@@ -174,7 +188,35 @@ 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,
@@ -209,6 +251,7 @@ 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);
@@ -239,6 +282,7 @@ 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,
@@ -261,6 +305,7 @@ 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);
@@ -284,6 +329,14 @@ 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,
@@ -320,7 +373,7 @@ impl Users {
        Ok(())
    }

-    #[tracing::instrument(skip(self))]
+    #[tracing::instrument(skip(self, user_id))]
    pub fn last_one_time_keys_update(&self, user_id: &UserId) -> Result<u64> {
        self.userid_lastonetimekeyupdate
            .get(&user_id.as_bytes())?
@@ -332,6 +385,7 @@ 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,
@@ -371,7 +425,7 @@ impl Users {
            .transpose()
    }

-    #[tracing::instrument(skip(self))]
+    #[tracing::instrument(skip(self, user_id, device_id))]
    pub fn count_one_time_keys(
        &self,
        user_id: &UserId,
@@ -404,6 +458,7 @@ 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,
@@ -426,6 +481,14 @@ 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,
@@ -526,6 +589,7 @@ impl Users {
        Ok(())
    }

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

-    #[tracing::instrument(skip(self))]
+    #[tracing::instrument(skip(self, user_or_room_id, from, to))]
    pub fn keys_changed<'a>(
        &'a self,
        user_or_room_id: &str,
@@ -582,9 +646,24 @@ 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))
+            .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
+                    }
+            })
            .map(|(_, bytes)| {
                UserId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
                    Error::bad_database("User ID in devicekeychangeid_userid is invalid unicode.")
@@ -593,6 +672,7 @@ impl Users {
            })
    }

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

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

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

+    #[tracing::instrument(skip(self, user_id, allowed_signatures))]
    pub fn get_self_signing_key<F: Fn(&UserId) -> bool>(
        &self,
        user_id: &UserId,
@@ -694,6 +777,7 @@ 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())?
@@ -706,6 +790,15 @@ 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,
@@ -726,15 +819,14 @@ impl Users {
        json.insert("sender".to_owned(), sender.to_string().into());
        json.insert("content".to_owned(), content);

-        self.todeviceid_events.insert(
-            &key,
-            &serde_json::to_vec(&json).expect("Map::to_vec always works"),
-        )?;
+        let value = serde_json::to_vec(&json).expect("Map::to_vec always works");
+
+        self.todeviceid_events.insert(&key, &value)?;

        Ok(())
    }

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

-    #[tracing::instrument(skip(self))]
+    #[tracing::instrument(skip(self, user_id, device_id, until))]
    pub fn remove_to_device_events(
        &self,
        user_id: &UserId,
@@ -774,7 +866,7 @@ impl Users {

        for (key, _) in self
            .todeviceid_events
-            .iter_from(&last, true)
+            .iter_from(&last, true) // this includes last
            .take_while(move |(k, _)| k.starts_with(&prefix))
            .map(|(key, _)| {
                Ok::<_, Error>((
@@ -792,6 +884,7 @@ impl Users {
        Ok(())
    }

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

    /// Get device metadata.
+    #[tracing::instrument(skip(self, user_id, device_id))]
    pub fn get_device_metadata(
        &self,
        user_id: &UserId,
@@ -835,6 +929,7 @@ 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())?
@@ -845,6 +940,7 @@ impl Users {
            })
    }

+    #[tracing::instrument(skip(self, user_id))]
    pub fn all_devices_metadata<'a>(
        &'a self,
        user_id: &UserId,
@@ -861,6 +957,7 @@ 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,4 +1,3 @@
-use log::{error, warn};
 use ruma::{
    api::client::{
        error::{Error as RumaError, ErrorKind},
@@ -7,6 +6,7 @@ use ruma::{
    ServerName,
 };
 use thiserror::Error;
+use tracing::warn;

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

 pub type Result<T> = std::result::Result<T, Error>;
@@ -29,12 +30,15 @@ pub enum Error {
        #[from]
        source: sled::Error,
    },
-    #[cfg(feature = "rocksdb")]
-    #[error("There was a problem with the connection to the rocksdb database: {source}")]
-    RocksDbError {
+    #[cfg(feature = "sqlite")]
+    #[error("There was a problem with the connection to the sqlite database: {source}")]
+    SqliteError {
        #[from]
-        source: rocksdb::Error,
+        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::Database;
+pub use database::{Config, Database};
 pub use error::{Error, Result};
 pub use pdu::PduEvent;
-pub use rocket::Config;
+pub use rocket::Config as RocketConfig;
 pub use ruma_wrapper::{ConduitResult, Ruma, RumaResponse};
 use std::ops::Deref;

@@ -17,6 +17,7 @@ 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;
@@ -30,10 +31,10 @@ use rocket::{
    },
    routes, Request,
 };
-use tracing::span;
-use tracing_subscriber::{prelude::*, Registry};
+use tokio::sync::RwLock;
+use tracing_subscriber::{prelude::*, EnvFilter};

-fn setup_rocket(config: Figment, data: Arc<Database>) -> rocket::Rocket<rocket::Build> {
+fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<rocket::Build> {
    rocket::custom(config)
        .manage(data)
        .mount(
@@ -49,6 +50,7 @@ fn setup_rocket(config: Figment, data: Arc<Database>) -> rocket::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,
@@ -59,6 +61,7 @@ fn setup_rocket(config: Figment, data: Arc<Database>) -> rocket::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,
@@ -184,7 +187,7 @@ async fn main() {
    std::env::set_var("CONDUIT_LOG_LEVEL", "off");

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

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

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

    if config.allow_jaeger {
-        let (tracer, _uninstall) = opentelemetry_jaeger::new_pipeline()
+        let tracer = opentelemetry_jaeger::new_pipeline()
            .with_service_name("conduit")
-            .install()
+            .install_simple()
            .unwrap();
-        let telemetry = tracing_opentelemetry::layer().with_tracer(tracer);
-        Registry::default().with(telemetry).try_init().unwrap();

-        let root = span!(tracing::Level::INFO, "app_start", work_units = 2);
-        let _enter = root.enter();
-
-        let rocket = setup_rocket(raw_config, db);
-        rocket.launch().await.unwrap();
+        let span = tracer.start("conduit");
+        start.await;
+        drop(span);
    } else {
-        std::env::set_var("RUST_LOG", config.log);
-        tracing_subscriber::fmt::init();
+        std::env::set_var("RUST_LOG", &config.log);

-        let rocket = setup_rocket(raw_config, db);
-        rocket.launch().await.unwrap();
+        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;
+        }
    }
 }

@@ -250,3 +282,30 @@ 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,10 +1,9 @@
 use crate::Error;
-use log::error;
 use ruma::{
    events::{
-        pdu::EventHash, room::member::MemberEventContent, AnyEphemeralRoomEvent, AnyRoomEvent,
-        AnyStateEvent, AnyStrippedStateEvent, AnySyncRoomEvent, AnySyncStateEvent, EventType,
-        StateEvent,
+        pdu::EventHash, room::member::MemberEventContent, AnyEphemeralRoomEvent,
+        AnyInitialStateEvent, AnyRoomEvent, AnyStateEvent, AnyStrippedStateEvent, AnySyncRoomEvent,
+        AnySyncStateEvent, EventType, StateEvent,
    },
    serde::{CanonicalJsonObject, CanonicalJsonValue, Raw},
    state_res, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, ServerName,
@@ -13,6 +12,7 @@ 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,6 +328,7 @@ 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")
    ))
@@ -346,3 +347,17 @@ pub struct PduBuilder {
    pub state_key: Option<String>,
    pub redacts: Option<EventId>,
 }
+
+/// Direct conversion prevents loss of the empty `state_key` that ruma requires.
+impl From<AnyInitialStateEvent> for PduBuilder {
+    fn from(event: AnyInitialStateEvent) -> Self {
+        Self {
+            event_type: EventType::from(event.event_type()),
+            content: serde_json::value::to_value(event.content())
+                .expect("AnyStateEventContent came from JSON and can thus turn back into JSON."),
+            unsigned: None,
+            state_key: Some(event.state_key().to_owned()),
+            redacts: None,
+        }
+    }
+}
@@ -1,4 +1,4 @@
-use crate::Error;
+use crate::{database::DatabaseGuard, Error};
 use ruma::{
    api::{client::r0::uiaa::UiaaResponse, OutgoingResponse},
    identifiers::{DeviceId, UserId},
@@ -9,21 +9,20 @@ use std::ops::Deref;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -254,14 +257,17 @@ 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 {}: {}", origin, e);
+                            warn!(
+                                "Failed to verify json request from {}: {}\n{:?}",
+                                origin, e, request_map
+                            );

                            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::raw(580), ()));
+                            return Failure((Status::new(580), ()));
                        }
                    }
                }
@@ -318,7 +324,8 @@ where
            }),
            Err(e) => {
                warn!("{:?}", e);
-                Failure((Status::raw(583), ()))
+                // Bad Json
+                Failure((Status::new(583), ()))
            }
        }
    }
@@ -344,7 +351,7 @@ pub fn response<T: OutgoingResponse>(response: RumaResponse<T>) -> response::Res
    let mut response = rocket::response::Response::build();

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

    for header in http_response.headers() {
        response.raw_header(header.0.to_string(), header.1.to_str().unwrap().to_owned());
@@ -9,6 +9,7 @@ use std::{
    time::{SystemTime, UNIX_EPOCH},
 };

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

+#[tracing::instrument(skip(deserializer))]
 pub fn deserialize_from_str<
    'de,
    D: serde::de::Deserializer<'de>,
@@ -137,7 +136,7 @@ pub fn deserialize_from_str<
        where
            E: serde::de::Error,
        {
-            v.parse().map_err(|e| serde::de::Error::custom(e))
+            v.parse().map_err(serde::de::Error::custom)
        }
    }
    deserializer.deserialize_str(Visitor(std::marker::PhantomData))
@@ -0,0 +1,101 @@
+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();
+}
@@ -0,0 +1,15 @@
+[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	3e79b15bbf	fix: long prev event fetch times for huge rooms	2021-08-12 17:55:16 +02:00
Timo Kösters	b0a2877f20	less warnings	2021-08-11 21:17:01 +02:00
Timo Kösters	e46f2199c9	improvement: cache for short event ids	2021-08-11 21:14:22 +02:00
Timo Kösters	03d78b25f2	improvement: use u64s in auth chain cache	2021-08-11 19:15:38 +02:00
Timo Kösters	67749364aa	improvement: smaller cache, better prev event fetching	2021-08-11 10:24:16 +02:00
Timo Kösters	dd3c60fb5a	Merge branch 'master' into 'master' Bump version of alpine docker image to 3.14 See merge request famedly/conduit!150	2021-08-10 05:44:16 +00:00
Timo Kösters	e83c226b1b	Merge branch 'zap-displayname' into 'master' Set nicer displayname See merge request famedly/conduit!149	2021-08-10 05:43:44 +00:00
Jonathan de Jong	8335f44bfe	Set nicer displayname	2021-08-10 05:43:44 +00:00
Timo Kösters	3745a7cbe6	Merge branch '3pid' into 'master' Add support for a minimal `r0/account/3pid`. See merge request famedly/conduit!151	2021-08-10 05:42:50 +00:00
Timo Kösters	610b4f9ad1	Merge branch 'fetchprev' into 'master' improvement: try to load missing prev events See merge request famedly/conduit!152	2021-08-10 05:30:12 +00:00
Ahmed Charles	879aeafa9e	Add support for a minimal `r0/account/3pid`.	2021-08-09 12:34:25 -07:00
Daniel Wiesenberg	a7b6af7caf	Bump version of alpine docker image to 3.14	2021-08-09 21:21:18 +02:00
Timo Kösters	260db9fcc7	improvement: try to load missing prev events	2021-08-09 21:05:41 +02:00
Timo Kösters	1cbc61c558	Merge branch 'badeventfix' into 'master' fix: handle bad events in db better See merge request famedly/conduit!148	2021-08-08 19:48:08 +00:00
Timo Kösters	d2f406e0e8	fix: handle bad events in db better	2021-08-08 21:33:28 +02:00
Timo Kösters	a816e3decd	Merge branch 'room_create_version' into 'master' Support creating rooms with a version See merge request famedly/conduit!147	2021-08-07 15:36:45 +00:00
Kurt Roeckx	989a20e99c	Support creating rooms with a version	2021-08-07 16:25:21 +02:00
Timo Kösters	1cf9da26bf	Merge branch 'timeout' into 'master' improvement: longer timeout, more descriptive errors See merge request famedly/conduit!146	2021-08-04 21:09:48 +00:00
Timo Kösters	55a2ff025f	improvement: longer timeout, more descriptive errors	2021-08-04 22:55:03 +02:00
Timo Kösters	76660bf189	Merge branch 'sqlitefixes' into 'master' Sqlitefixes See merge request famedly/conduit!144	2021-08-04 19:52:30 +00:00
Timo Kösters	df727688ef	remove rocksdb	2021-08-04 21:17:40 +02:00
Timo Kösters	902404d48d	improvement: save member count + sled fixes	2021-08-04 21:15:01 +02:00
Timo Kösters	b813c34642	improvement: more auth chain caching	2021-08-04 18:30:56 +02:00
Timo Kösters	ab7835dedb	fix: early return from state res	2021-08-04 15:19:50 +02:00
Timo Kösters	9bb4c3cd01	improvement: batched inserts for tokenids	2021-08-04 12:54:26 +02:00
Timo Kösters	fce22362d4	improvement: better auth chain calculation	2021-08-03 19:18:41 +02:00
Timo Kösters	41ec7cf5d0	improvement: batch inserts for stateids	2021-08-03 16:14:07 +02:00
Timo Kösters	49ade0cfbd	improvement: allow batch inserts	2021-08-03 11:24:21 +02:00
Timo Kösters	0eeba86b32	fix: improve locks	2021-08-03 11:17:39 +02:00
Timo Kösters	6b06fc9707	fix: don't run push rules for users that don't exist	2021-08-03 10:24:20 +02:00
Timo Kösters	bd63797213	improvement: make better use of sqlite connections	2021-08-03 10:24:14 +02:00
Timo Kösters	2c4f966d60	improvement: use sqlite properly	2021-08-01 16:59:52 +02:00
Timo Kösters	8174b16c38	Merge branch 'master' into 'master' Also push docker image to docker hub See merge request famedly/conduit!142	2021-08-01 10:10:51 +00:00
Timo Kösters	6666aae5a5	Merge branch 'docs' into 'master' docs: make it clear that database_path is a folder See merge request famedly/conduit!143	2021-07-30 17:44:33 +00:00
Timo Kösters	0f045890eb	docs: make it clear that database_path is a folder	2021-07-30 19:27:37 +02:00
Timo Kösters	9cb99a05e0	Merge branch 'tracing_flame' into 'master' feat: tracing flame graph See merge request famedly/conduit!140	2021-07-30 16:42:25 +00:00
Timo Kösters	dc85a8fafd	fix: migration and push edu bugs	2021-07-30 18:05:26 +02:00
Daniel Wiesenberg	fcd127aadc	Also push docker image to docker hub	2021-07-30 17:15:44 +02:00
Timo Kösters	5df6b8cd5f	improvement: better account data implementation	2021-07-30 16:08:24 +02:00
Timo Kösters	5c776e9ba7	feat: heed db backend (LMDB)	2021-07-29 23:11:53 +02:00
Timo Kösters	c209775abd	fix: pdu without state bug	2021-07-29 12:33:44 +02:00
Timo Kösters	5e924227b6	feat: add threadpool for iterator threads, bug fixes, tracing_flame support	2021-07-29 08:49:28 +02:00
Timo Kösters	734c4637f0	Merge branch 'ci-build-docker-image' into 'master' CI: Build docker image See merge request famedly/conduit!134	2021-07-21 15:05:20 +00:00
Timo Kösters	e0072eff63	Merge branch 'v5' into 'master' feat: support room version 5 See merge request famedly/conduit!138	2021-07-21 11:05:59 +00:00
Timo Kösters	cae2b200cc	Merge branch 'initial_state_keys' into 'master' Implement From<AnyInitialStateEvent> on PduBuilder Closes #116 See merge request famedly/conduit!136	2021-07-21 10:03:08 +00:00
Timo Kösters	918df9ca6d	feat: support room version 5	2021-07-21 11:59:56 +02:00
Timo Kösters	387e864659	Merge branch 'aliases' into 'master' Implement getting room aliases See merge request famedly/conduit!116	2021-07-21 09:48:17 +00:00
Timo Kösters	c84960df91	Merge branch 'deploy-guide-remove-arm-add-x86_64-musl' into 'master' Docs: Remove arm download, but add x86_64 musl one See merge request famedly/conduit!137	2021-07-21 09:34:14 +00:00
Jonas Zohren	32db4c09a0	Docs: Remove arm download, but add x86_64 musl one	2021-07-21 09:21:49 +00:00
Kurt Roeckx	0d33cc4acd	Implement getting room aliases Signed-off-by: Kurt Roeckx <kurt@roeckx.be>	2021-07-21 10:56:22 +02:00
phesch	666e1d30a3	Implement From<AnyInitialStateEvent> on PduBuilder The conversion between the two is now direct and thus shouldn't lose the state_keys.	2021-07-21 10:55:23 +02:00
Timo Kösters	f43fd6a475	Merge branch 'e2ee-fed' into 'master' Initial E2EE over federation support See merge request famedly/conduit!135	2021-07-21 08:41:00 +00:00
Timo Kösters	1587f2cd52	fix: check events in timeline (not only state) for member changes	2021-07-21 09:39:54 +02:00
Timo Kösters	f121978897	fix: state bug	2021-07-20 23:36:03 +02:00
Timo Kösters	80533bfab2	fix: improve code when skipping /state_ids	2021-07-20 22:06:42 +02:00
Timo Kösters	08a3326431	docs: Initial end-to-end encryption over federation support	2021-07-20 21:37:08 +02:00
Timo Kösters	fe3b5d32a7	feat: send to-device events over federation	2021-07-20 21:17:15 +02:00
Timo Kösters	e20f55970e	feat: call /query/profile over federation when local user asks	2021-07-20 19:49:47 +02:00
Timo Kösters	728e176a06	feat: /keys/query and /keys/claim over federation	2021-07-20 19:40:25 +02:00
Timo Kösters	7d14a46607	Merge branch 'improvements' into 'master' Update ruma See merge request famedly/conduit!127	2021-07-20 16:59:49 +00:00
Timo Kösters	68cc743f2a	fix: use get_auth_chain method more often	2021-07-20 18:45:21 +02:00
Timo Kösters	56e5d5e3d2	fix: add warning for strange bug	2021-07-20 18:38:17 +02:00
Timo Kösters	f0ac7ed933	chore: update ruma again	2021-07-20 15:25:17 +02:00
Timo Kösters	0f8ecdc625	fix: state res fixes	2021-07-20 15:25:17 +02:00
Timo Kösters	cfaa900e83	improvement: auth chain cache	2021-07-20 15:25:16 +02:00
Timo Kösters	f5273f7eb1	improvement: upgrade ruma and implement blurhashes	2021-07-20 15:25:16 +02:00
Timo Kösters	0fcefa4125	fix: ruma	2021-07-20 15:25:16 +02:00
Timo Kösters	d07762f596	Merge branch 'connection-cushion' into 'master' Spillover connection cushion See merge request famedly/conduit!133	2021-07-20 10:39:04 +00:00
Jonathan de Jong	d253f9236a	change fraction type	2021-07-20 11:01:35 +02:00
Jonathan de Jong	ec44f3d568	change to f64	2021-07-20 10:47:36 +02:00
Jonas Zohren	167e903a56	Fix typo	2021-07-19 22:02:10 +02:00
Jonas Zohren	0a8dadb797	Add hardcoded artifacts.expose_as to show them in MRs	2021-07-19 20:39:58 +02:00
Jonas Zohren	678ce0abc6	CI: Create docker image with musl binary	2021-07-19 20:39:58 +02:00
Jonathan de Jong	e7a51c07d0	log change feedback	2021-07-19 17:17:10 +02:00
Jonathan de Jong	79bf7fc597	some logging shuffling	2021-07-19 16:46:59 +02:00
Jonathan de Jong	7e579f8d34	change to fraction-based approach	2021-07-19 16:25:41 +02:00
Jonathan de Jong	0f2dc9a239	add stuff and bits	2021-07-19 15:56:20 +02:00
Timo Kösters	59d538206f	Merge branch 'fix-shutdown-period' into 'master' Fix shutdown period See merge request famedly/conduit!131	2021-07-19 13:11:25 +00:00
Jonathan de Jong	faa283d35b	review feedback	2021-07-19 13:44:53 +02:00
Timo Kösters	86160597ea	Merge branch 'ci-package-upload-hotfix' into 'master' CI: Fix package upload See merge request famedly/conduit!132	2021-07-19 11:20:00 +00:00
Jonas Zohren	d6b37480e7	CI: Fix package upload	2021-07-19 10:00:44 +00:00
Jonathan de Jong	3ce75d1f02	apply fix	2021-07-19 11:55:39 +02:00
Timo Kösters	a50abeedad	Merge branch 'ci-rough-sytest-integration' into 'master' CI: Add sytest See merge request famedly/conduit!130	2021-07-19 08:47:32 +00:00
Jonas Zohren	130b9841da	CI: Add sytest	2021-07-19 08:47:31 +00:00
Timo Kösters	ffa10a68b9	Merge branch 'more-detailed-issue-templates' into 'master' Docs: More (detailed) templates for Issues and MRs See merge request famedly/conduit!129	2021-07-19 08:28:10 +00:00
Timo Kösters	124b5484b5	Merge branch 'test-registering-with-element-web' into 'master' CI: Test registration with element web See merge request famedly/conduit!128	2021-07-19 08:23:05 +00:00
Jonas Zohren	2babff1e41	CI: Test registration with element web	2021-07-19 08:23:04 +00:00
Jonas Zohren	cdd01262d2	Shorten more templates	2021-07-18 20:43:21 +00:00
Jonas Zohren	092221ca3f	Reduce amount of text in Bug Report template	2021-07-18 20:30:57 +00:00
Jonas Zohren	5d8ad4fd72	Add some more details to the MR template	2021-07-17 12:22:11 +02:00
Jonas Zohren	7054f74783	Add issue template for GitHub which redirects to Gitlab	2021-07-17 12:21:41 +02:00
Jonas Zohren	82a4ec9cbd	Add more detailed issue templates Shamelessly stolen from https://github.com/HedgeDoc/client Originally written by https://github.com/ErikMichelson and https://github.com/DerMolly	2021-07-17 12:00:38 +02:00
Timo Kösters	f924ebf8a6	Merge branch 'fix-windows-signal' into 'master' fix signal compiling on windows See merge request famedly/conduit!126	2021-07-15 16:29:47 +00:00
Jonathan de Jong	b1993421c2	fix signal compiling on windows	2021-07-15 18:09:10 +02:00
Timo Kösters	8e2d6f7e43	Merge branch 'sled-fix' into 'master' Sled fixes See merge request famedly/conduit!125	2021-07-15 15:38:40 +00:00
Jonathan de Jong	d76e95e8fc	use existing db cache size	2021-07-15 13:47:21 +02:00
Jonathan de Jong	661101c9ae	add sled cache_capacity back	2021-07-15 13:29:08 +02:00
Timo Kösters	f7ecf83ac3	Merge branch 'stuff' into 'master' fix: stuck/duplicate messages, e2ee and sync timeouts See merge request famedly/conduit!123	2021-07-15 08:18:56 +00:00
Timo Kösters	9a4789efdc	Merge branch 'ci-format-check-before-cargo-test' into 'master' CI: Check format before running test See merge request famedly/conduit!124	2021-07-14 20:53:10 +00:00
Jonas Zohren	eaa4c77641	CI: Check format before running test Testing needs compilation and is slow. Format checking is quick. As format checking fails more often than tests, switching them should result in faster failure and feedback	2021-07-14 20:33:19 +00:00
Timo Kösters	9268b33c3f	Merge branch 'shutdown-sync' into 'master' Make shutdown short-circuit sync helpers See merge request famedly/conduit!122	2021-07-14 13:49:00 +00:00
Timo Kösters	9de32ae12f	fix toolchain	2021-07-14 15:46:30 +02:00
Jonathan de Jong	952fb75795	add shutdown handler to kick sync	2021-07-14 14:50:07 +02:00
Timo Kösters	e12b1ff863	improvement: locks	2021-07-14 13:21:25 +02:00
Timo Kösters	e15e6d4405	improvement: efficient /sync, mutex for federation transactions	2021-07-14 13:20:39 +02:00
Timo Kösters	1c25492a7e	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-14 13:19:24 +02:00
Timo Kösters	8c44312485	fix: e2ee verification	2021-07-14 13:10:56 +02:00
Timo Kösters	ac0027756e	improvement: more efficient state res	2021-07-14 13:10:49 +02:00
Timo Kösters	f3e806096b	Merge branch 'clippy-fix' into 'master' Fix clippy lint See merge request famedly/conduit!121	2021-07-14 10:57:44 +00:00
Jonathan de Jong	e1b89c1248	apply lint suggestions and version bump	2021-07-14 12:31:38 +02:00
Timo Kösters	be6b6c3cf0	Merge branch 'rocket-update' into 'master' Update rocket to rc1 and lock file See merge request famedly/conduit!120	2021-07-14 09:48:17 +00:00
Jonathan de Jong	15471d9ac4	update rocket and lock	2021-07-14 11:28:24 +02:00
Timo Kösters	3c236fb671	Merge branch 'sqlite' into 'master' Sqlite See merge request famedly/conduit!114	2021-07-14 07:07:09 +00:00
Jonathan de Jong	9d4fa9a220	Sqlite	2021-07-14 07:07:08 +00:00
Timo Kösters	bd4bd58612	Merge branch 'capabilities_auth' into 'master' Getting capabilities requires authentication See merge request famedly/conduit!117	2021-07-13 07:55:19 +00:00
Timo Kösters	0eec1cc696	Merge branch 'ci-tag-jobs-with-docker' into 'master' Better CI (run on faster CI hosts, incremental release builds, thin-lto) See merge request famedly/conduit!118	2021-07-12 20:35:00 +00:00
Jonas Zohren	3fa09ff57d	Use thin-lto [1] for "better" release builds. This performs a rather quick variant of Link Time Optimization [2]. It should add negligible build time but also more optimized binaries. [1]: https://doc.rust-lang.org/cargo/reference/profiles.html#lto [2]: https://llvm.org/docs/LinkTimeOptimization.html	2021-07-12 20:21:13 +00:00
Jonas Zohren	0080932aef	Speed up release builds Setting cargo to run incremental builds means partial build results should be cached. This is not enabled by default in release mode. Incremental builds use 256 codegen units by default [1]. We set them to 16 (release default) again for somewhat faster code but slightly slower builds. [1]: https://doc.rust-lang.org/cargo/reference/profiles.html#codegen-units	2021-07-12 20:18:14 +00:00
Jonas Zohren	888a2f7fa1	Make CI run on famedly runners By default, jobs without tags only run on CI runners configured to do so [1]. Conduit can use famedly runners, which are more powerfull than gitlab's runners, but require a tag on the job to run it there. This commit tags each job with the "docker" tag. On the famedly/conduit repo this means faster CI. On other gitlab.com forks the normal ci. Selfhosted gitlab's might need to add a "docker" tag to their runner. [1]: https://docs.gitlab.com/ee/ci/runners/configure_runners.html#use-tags-to-limit-the-number-of-jobs-using-the-runner	2021-07-12 19:58:35 +00:00
Kurt Roeckx	dcb5e5900f	Getting capabilities requires authentication	2021-07-11 22:07:10 +02:00
Timo Kösters	4732aa6782	Merge branch 'invalid_utf8' into 'master' Return proper error in case of invalid UTF-8 See merge request famedly/conduit!110	2021-07-11 13:44:27 +00:00
Kurt Roeckx	699f77671f	Return proper error in case of invalid UTF-8 in json_body json_body is used in places that need authentication. In case an unknown field is set, Ruma doesn't parse the field and so doesn't give an error on invalid UTF-8. But Conduit has parsed and on error makes json_body None. Return an error to the client instead of generating an internal error.	2021-07-11 14:47:13 +02:00
Timo Kösters	fcfb9b51de	Merge branch 'fix-ci-failing-duplicate-nightly-release' into 'master' Fix: Duplicate releases don't work, remove nightly Closes #100 See merge request famedly/conduit!113	2021-07-11 11:43:48 +00:00
Jonas Zohren	36681dd3ac	Fix: Duplicate releases don't work, remove nightly	2021-07-11 11:43:48 +00:00
Timo Kösters	13c0beafa6	Merge branch 'lib-fix' into 'master' Export conduits Config struct and fix clippy warnings See merge request famedly/conduit!99	2021-07-11 11:42:07 +00:00
Timo Kösters	a313a93ff5	Merge branch 'master' into 'master' Change default port in docker to the new See merge request famedly/conduit!115	2021-07-11 11:41:12 +00:00
Daniel Wiesenberg	6a96cfaac1	Change default port in docker to the new conduit default port 6167 and fix the docker healthcheck	2021-07-06 10:43:33 +02:00
Devin Ragotzy	09a8737f24	Export conduits Config struct and fix clipp warningsy	2021-06-29 16:02:12 -04:00
@@ -1 +1 @@
 .51.0
 .52