improvement: locks

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.

.github/ISSUE_TEMPLATE/Issue.md

@@ -1,11 +0,0 @@
----
-name: "Issue with / Feature Request for Conduit"
-about: "Please file issues on GitLab: https://gitlab.com/famedly/conduit/-/issues/new"
-title: "CLOSE ME"
----
-
-
-
-**⚠️ Conduit development does not happen on GitHub. Issues opened here will not be addressed** 
-
-Please open issues on GitLab: https://gitlab.com/famedly/conduit/-/issues/new

.gitlab-ci.yml

@@ -1,8 +1,8 @@
 stages:
-  - build
-  - build docker image
   - test
-  - upload artifacts
+  - build
+  - publish artifacts
+  - release nightly
 
 variables:
   GIT_SUBMODULE_STRATEGY: recursive
@@ -10,6 +10,29 @@ variables:
   CACHE_COMPRESSION_LEVEL: fastest
 
 
+test:cargo:
+  stage: "test"
+  needs: []
+  image: "rust:latest"
+  variables:
+    CARGO_HOME: "cargohome"
+  cache:
+    paths:
+      - target
+      - cargohome
+    key: test_cache
+  interruptible: true
+  before_script:
+    - mkdir -p $CARGO_HOME && echo "using $CARGO_HOME to cache cargo deps"
+    - apt-get update -yqq
+    - apt-get install -yqq --no-install-recommends build-essential libssl-dev pkg-config
+    - rustup component add clippy rustfmt
+  script:
+    - rustc --version && cargo --version  # Print version info for debugging
+    - cargo test --workspace --verbose --locked
+    - cargo fmt --all -- --check
+    - cargo clippy
+
 # --------------------------------------------------------------------- #
 #  Cargo: Compiling for different architectures                         #
 # --------------------------------------------------------------------- #
@@ -21,15 +44,11 @@ variables:
     - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
   interruptible: true
   image: "rust:latest"
-  tags: ["docker"]
   cache:
     paths:
       - cargohome
       - target/
-    key: "build_cache-$TARGET-release"
+    key: "build_cache-$TARGET"
-  variables:
-    CARGO_PROFILE_RELEASE_LTO=true
-    CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1
   before_script:
     - 'echo "Building for target $TARGET"'
     - 'mkdir -p cargohome && CARGOHOME="cargohome"'
@@ -41,19 +60,18 @@ variables:
   script:
     - 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:
-build:release:cargo:x86_64-unknown-linux-gnu:
   extends: .build-cargo-shared-settings
   variables:
     TARGET: "x86_64-unknown-linux-gnu"
-  artifacts:
-    name: "conduit-x86_64-unknown-linux-gnu"
-    paths:
-      - "conduit-x86_64-unknown-linux-gnu"
-    expose_as: "Conduit for x86_64-unknown-linux-gnu"
 
-build:release:cargo:armv7-unknown-linux-gnueabihf:
+build:cargo:armv7-unknown-linux-gnueabihf:
   extends: .build-cargo-shared-settings
   variables:
     TARGET: "armv7-unknown-linux-gnueabihf"
@@ -61,13 +79,8 @@ build:release: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: "Conduit for armv7-unknown-linux-gnueabihf"
 
-build:release:cargo:aarch64-unknown-linux-gnu:
+build:cargo:aarch64-unknown-linux-gnu:
   extends: .build-cargo-shared-settings
   variables:
     TARGET: "aarch64-unknown-linux-gnu"
@@ -77,68 +90,6 @@ build:release: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: "Conduit for aarch64-unknown-linux-gnu"
-
-build:release:cargo:x86_64-unknown-linux-musl:
-  extends: .build-cargo-shared-settings
-  image: "rust:alpine"
-  variables:
-    TARGET: "x86_64-unknown-linux-musl"
-  before_script:
-    - 'echo "Building for target $TARGET"'
-    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
-    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
-    - "rustup target add $TARGET"
-    - "apk add libc-dev"
-  artifacts:
-    name: "conduit-x86_64-unknown-linux-musl"
-    paths:
-      - "conduit-x86_64-unknown-linux-musl"
-    expose_as: "Conduit for x86_64-unknown-linux-musl"
-
-
-
-.cargo-debug-shared-settings:
-  extends: ".build-cargo-shared-settings"
-  rules:
-    - if: '$CI_COMMIT_BRANCH'
-  cache:
-    key: "build_cache-$TARGET-debug"
-  script:
-    - "time cargo build --target $TARGET"
-    - 'mv "target/$TARGET/debug/conduit" "conduit-debug-$TARGET"'
-
-build:debug:cargo:x86_64-unknown-linux-gnu:
-  extends: ".cargo-debug-shared-settings"
-  variables:
-    TARGET: "x86_64-unknown-linux-gnu"
-  artifacts:
-    name: "conduit-debug-x86_64-unknown-linux-gnu"
-    paths:
-      - "conduit-debug-x86_64-unknown-linux-gnu"
-    expose_as: "Conduit DEBUG for x86_64-unknown-linux-gnu"
-
-build:debug:cargo:x86_64-unknown-linux-musl:
-  extends: ".cargo-debug-shared-settings"
-  image: "rust:alpine"
-  variables:
-    TARGET: "x86_64-unknown-linux-musl"
-  before_script:
-    - 'echo "Building for target $TARGET"'
-    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
-    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
-    - "rustup target add $TARGET"
-    - "apk add libc-dev"
-  artifacts:
-    name: "conduit-debug-x86_64-unknown-linux-musl"
-    paths:
-      - "conduit-debug-x86_64-unknown-linux-musl"
-    expose_as: "Conduit DEBUG for x86_64-unknown-linux-musl"
-
 
 
 # --------------------------------------------------------------------- #
@@ -153,7 +104,6 @@ build:debug:cargo:x86_64-unknown-linux-musl:
     - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
   interruptible: true
   image: "rust:latest"
-  tags: ["docker"]
   cache:
     paths:
       - cargohome
@@ -171,165 +121,35 @@ build:debug:cargo:x86_64-unknown-linux-musl:
   script:
     - time cargo deb --target $TARGET
     - 'mv target/$TARGET/debian/*.deb "conduit-$TARGET.deb"'
+  artifacts:
+    name: "conduit-$TARGET.deb"
+    expose_as: "Debian Package"
+    paths:
+      - "conduit-$TARGET.deb"
 
 build:cargo-deb:x86_64-unknown-linux-gnu:
   extends: .build-cargo-deb-shared-settings
   variables:
     TARGET: "x86_64-unknown-linux-gnu"
     NEEDED_PACKAGES: ""
-  artifacts:
+
-    name: "conduit-x86_64-unknown-linux-gnu.deb"
-    paths:
-      - "conduit-x86_64-unknown-linux-gnu.deb"
-    expose_as: "Debian Package x86_64"
 
 
 
 # --------------------------------------------------------------------- #
-#  Create and publish docker image                                      #
+#  Storing and releasing compiled binaries                              #
-# --------------------------------------------------------------------- #
-
-.docker-shared-settings:
-  stage: "build docker image"
-  needs: []
-  interruptible: true
-  image:
-    name: "gcr.io/kaniko-project/executor:debug"
-    entrypoint: [""]
-  tags: ["docker"]
-  variables:
-    # Configure Kaniko Caching: https://cloud.google.com/build/docs/kaniko-cache
-    KANIKO_CACHE_ARGS: "--cache=true --cache-copy-layers=true --cache-ttl=120h --cache-repo $CI_REGISTRY_IMAGE/kaniko-ci-cache"
-  before_script:
-    - "mkdir -p /kaniko/.docker"
-    - 'echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"},\"$DOCKER_HUB\":{\"username\":\"$DOCKER_HUB_USER\",\"password\":\"$DOCKER_HUB_PASSWORD\"}}}" > /kaniko/.docker/config.json'
-
-
-# Build a docker image by packaging up the x86_64-unknown-linux-musl binary into an alpine image
-build:docker:main:
-  extends: .docker-shared-settings
-  needs:
-    - "build:release:cargo:x86_64-unknown-linux-musl"
-  script:
-    - >
-      /kaniko/executor
-      $KANIKO_CACHE_ARGS
-      --context $CI_PROJECT_DIR
-      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
-      --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
-      --build-arg "GIT_REF=$CI_COMMIT_REF_NAME"
-      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
-      --destination "$CI_REGISTRY_IMAGE/conduit:latest"
-      --destination "$CI_REGISTRY_IMAGE/conduit:alpine"
-      --destination "$CI_REGISTRY_IMAGE/conduit:commit-$CI_COMMIT_SHORT_SHA"
-      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest"
-      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:alpine"
-      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:commit-$CI_COMMIT_SHORT_SHA"
-  rules:
-    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
-
-
-
-# --------------------------------------------------------------------- #
-#  Run tests                                                            #
-# --------------------------------------------------------------------- #
-
-test:cargo:
-  stage: "test"
-  needs: [ ]
-  image: "rust:latest"
-  tags: [ "docker" ]
-  variables:
-    CARGO_HOME: "cargohome"
-  cache:
-    paths:
-      - target
-      - cargohome
-    key: test_cache
-  interruptible: true
-  before_script:
-    - mkdir -p $CARGO_HOME && echo "using $CARGO_HOME to cache cargo deps"
-    - apt-get update -yqq
-    - apt-get install -yqq --no-install-recommends build-essential libssl-dev pkg-config
-    - rustup component add clippy rustfmt
-  script:
-    - rustc --version && cargo --version  # Print version info for debugging
-    - cargo fmt --all -- --check
-    - cargo test --workspace --verbose --locked
-    - cargo clippy
-
-test:sytest:
-  stage: "test"
-  allow_failure: true
-  needs:
-    - "build:debug:cargo:x86_64-unknown-linux-musl"
-  image:
-    name: "valkum/sytest-conduit:latest"
-    entrypoint: [ "" ]
-  tags: [ "docker" ]
-  variables:
-    PLUGINS: "https://github.com/valkum/sytest_conduit/archive/master.tar.gz"
-  before_script:
-    - "mkdir -p /app"
-    - "cp ./conduit-debug-x86_64-unknown-linux-musl /app/conduit"
-    - "chmod +x /app/conduit"
-    - "rm -rf /src && ln -s $CI_PROJECT_DIR/ /src"
-    - "mkdir -p /work/server-0/database/ && mkdir -p /work/server-1/database/ && mkdir -p /work/server-2/database/"
-    - "cd /"
-  script:
-    - "SYTEST_EXIT_CODE=0"
-    - "/bootstrap.sh conduit || SYTEST_EXIT_CODE=1"
-    - "perl /sytest/tap-to-junit-xml.pl --puretap --input /logs/results.tap --output $CI_PROJECT_DIR/sytest.xml \"Sytest\" && cp /logs/results.tap $CI_PROJECT_DIR/results.tap"
-    - "exit $SYTEST_EXIT_CODE"
-  artifacts:
-    when: always
-    paths:
-      - "$CI_PROJECT_DIR/sytest.xml"
-      - "$CI_PROJECT_DIR/results.tap"
-    reports:
-      junit: "$CI_PROJECT_DIR/sytest.xml"
-
-
-test:register:element-web-stable:
-  stage: "test"
-  needs:
-    - "build:debug:cargo:x86_64-unknown-linux-gnu"
-  image: "buildkite/puppeteer:latest"
-  tags: [ "docker" ]
-  interruptible: true
-  script:
-    - "CONDUIT_CONFIG=tests/test-config.toml ./conduit-debug-x86_64-unknown-linux-gnu > conduit.log &"
-    - "cd tests/client-element-web/"
-    - "npm install puppeteer"
-    - "node test-element-web-registration.js \"https://app.element.io/\" \"http://localhost:6167\""
-    - "killall --regexp \"conduit\""
-    - "cd ../.."
-    - "cat conduit.log"
-  artifacts:
-    paths:
-      - "tests/client-element-web/*.png"
-      - "*.log"
-    expire_in: 1 week
-    when: always
-  retry: 1
-
-
-# --------------------------------------------------------------------- #
-#  Store binaries as package so they have download urls                 #
 # --------------------------------------------------------------------- #
 
 publish:package:
-  stage: "upload artifacts"
+  stage: "publish artifacts"
   needs:
-    - "build:release:cargo:x86_64-unknown-linux-gnu"
+    - "build:cargo:x86_64-unknown-linux-gnu"
-    - "build:release:cargo:armv7-unknown-linux-gnueabihf"
+    - "build:cargo:armv7-unknown-linux-gnueabihf"
-    - "build:release:cargo:aarch64-unknown-linux-gnu"
+    - "build:cargo:aarch64-unknown-linux-gnu"
-    - "build:release:cargo:x86_64-unknown-linux-musl"
     - "build:cargo-deb:x86_64-unknown-linux-gnu"
   rules:
     - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
   image: curlimages/curl:latest
-  tags: ["docker"]
   variables:
     GIT_STRATEGY: "none" # Don't need a clean copy of the code, we just operate on artifacts
   script:
@@ -337,7 +157,32 @@ publish:package:
     - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-gnu "${BASE_URL}/conduit-x86_64-unknown-linux-gnu"'
     - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-armv7-unknown-linux-gnueabihf "${BASE_URL}/conduit-armv7-unknown-linux-gnueabihf"'
     - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-aarch64-unknown-linux-gnu "${BASE_URL}/conduit-aarch64-unknown-linux-gnu"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-musl "${BASE_URL}/conduit-x86_64-unknown-linux-musl"'
     - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-gnu.deb "${BASE_URL}/conduit-x86_64-unknown-linux-gnu.deb"'
 
 
+
+publish:nightly:
+  stage: "release nightly"
+  image: registry.gitlab.com/gitlab-org/release-cli:latest
+  needs:
+    - job: "publish:package"
+      artifacts: false
+  variables:
+    GIT_STRATEGY: "none" # Don't need a clean copy of the code, we just operate on artifacts
+  script: "echo 'Releasing current state as release'"
+  rules:
+    - if: "$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH"           # Run this job on the main branch
+  release:
+    name: 'Nightly'
+    description: '⚠️ The latest development version of the day, fresh from the repository. Use at your own risk!'
+    tag_name: 'nightly'
+    assets: 
+      links:
+        - name: 'conduit-x86_64-unknown-linux-gnu'
+          url: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}/conduit-x86_64-unknown-linux-gnu"
+        - name: 'conduit-armv7-unknown-linux-gnueabihf'
+          url: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}/conduit-armv7-unknown-linux-gnueabihf"
+        - name: 'conduit-aarch64-unknown-linux-gnu'
+          url: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}/conduit-aarch64-unknown-linux-gnu"
+        - name: 'conduit-x86_64-unknown-linux-gnu.deb'
+          url: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}/conduit-x86_64-unknown-linux-gnu.deb"

.gitlab/issue_templates/Bug Report.md

@@ -1,19 +0,0 @@
-<!--
-If you're requesting a new feature, that isn't part of this project yet,
-then please consider filling out a "Feature Request" instead!
-
-If you need a hand setting up your conduit server, feel free to ask for help in the
-Conduit Matrix Chat: https://matrix.to/#/#conduit:fachschaften.org.
--->
-
-### Description
-<!-- What did you do and what happened? Why is that bad? -->
-
-### System Configuration
-<!-- Other data that might help us debug this issue, like os, conduit version, database backend -->
-
-Conduit Version:
-Database backend (default is sqlite): sqlite
-
-
-/label ~conduit

.gitlab/issue_templates/Feature Request.md

@@ -1,17 +0,0 @@
-<!--
-If you want to report a bug or an error,
-then please consider filling out a "Bug Report" instead!
--->
-
-
-### Is your feature request related to a problem? Please describe.
-
-<!-- Eg. I'm always frustrated when [...] -->
-
-
-### Describe the solution you'd like
-
-
-
-
-/label ~conduit

.gitlab/issue_templates/Issue Template.md

@@ -0,0 +1,15 @@
+# Headline
+
+### Description
+
+
+
+
+
+
+
+
+
+
+
+/label ~conduit

.gitlab/merge_request_templates/MR.md

@@ -1,8 +0,0 @@
-
-<!-- Please describe your changes here -->
-
------------------------------------------------------------------------------
-
-- [ ] I ran `cargo fmt` and `cargo test`
-- [ ] I agree to release my code and all other changes of this MR under the Apache-2.0 license
-

Cargo.toml

@@ -14,45 +14,45 @@ edition = "2018"
 [dependencies]
 # Used to handle requests
 # TODO: This can become optional as soon as proper configs are supported
-# rocket = { git = "https://github.com/SergioBenitez/Rocket.git", rev = "801e04bd5369eb39e126c75f6d11e1e9597304d8", features = ["tls"] } # Used to handle requests
+rocket = { 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 = { version = "0.4.0", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
+ruma = { git = "https://github.com/ruma/ruma", rev = "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 = "f5ab038e22421ed338396ece977b6b2844772ced", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
-ruma = { git = "https://github.com/DevinR528/ruma", rev = "c7860fcb89dbde636e2c83d0636934fb9924f40c", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
 #ruma = { path = "../ruma/crates/ruma", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
 
 # Used for long polling and federation sender, should be the same as rocket::tokio
-tokio = "1.8.2"
+tokio = "1.2.0"
 # Used for storing data permanently
 sled = { version = "0.34.6", features = ["compression", "no_metrics"], optional = true }
+rocksdb = { version = "0.16.0", features = ["multi-threaded-cf"], optional = true }
 #sled = { git = "https://github.com/spacejam/sled.git", rev = "e4640e0773595229f398438886f19bca6f7326a2", features = ["compression"] }
 
 # Used for the http request / response body type for Ruma endpoints used with reqwest
 bytes = "1.0.1"
+# Used for emitting log entries
+log = "0.4.14"
 # Used for rocket<->ruma conversions
-http = "0.2.4"
+http = "0.2.3"
 # Used to find data directory for default db path
-directories = "3.0.2"
+directories = "3.0.1"
 # Used for ruma wrapper
 serde_json = { version = "1.0.64", features = ["raw_value"] }
 # Used for appservice registration files
 serde_yaml = "0.8.17"
 # Used for pdu definition
-serde = "1.0.126"
+serde = "1.0.123"
 # Used for secure identifiers
-rand = "0.8.4"
+rand = "0.8.3"
 # Used to hash passwords
 rust-argon2 = "0.8.3"
 # Used to send requests
-reqwest = { version = "0.11.4", default-features = false, features = ["rustls-tls-native-roots", "socks"] }
+reqwest = { version = "0.11.3", default-features = false, features = ["rustls-tls-native-roots", "socks"] }
 # Custom TLS verifier
-rustls = { version = "0.19.1", features = ["dangerous_configuration"] }
+rustls = { version = "0.19", features = ["dangerous_configuration"] }
 rustls-native-certs = "0.5.0"
 webpki = "0.21.0"
 # Used for conduit::Error type
-thiserror = "1.0.26"
+thiserror = "1.0.24"
 # Used to generate thumbnails for images
 image = { version = "0.23.14", default-features = false, features = ["jpeg", "png", "gif"] }
 # Used to encode server public key
@@ -60,33 +60,30 @@ base64 = "0.13.0"
 # Used when hashing the state
 ring = "0.16.20"
 # Used when querying the SRV record of other servers
-trust-dns-resolver = "0.20.3"
+trust-dns-resolver = "0.20.0"
 # Used to find matching events for appservices
-regex = "1.5.4"
+regex = "1.4.3"
 # jwt jsonwebtokens
 jsonwebtoken = "7.2.0"
 # Performance measurements
-tracing = { version = "0.1.26", features = ["release_max_level_warn"] }
+tracing = "0.1.25"
-tracing-subscriber = "0.2.19"
+opentelemetry = "0.12.0"
-tracing-opentelemetry = "0.14.0"
+tracing-subscriber = "0.2.16"
-tracing-flame = "0.1.0"
+tracing-opentelemetry = "0.11.0"
-opentelemetry = { version = "0.16.0", features = ["rt-tokio"] }
+opentelemetry-jaeger = "0.11.0"
-opentelemetry-jaeger = { version = "0.15.0", features = ["rt-tokio"] }
 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"
+num_cpus = { version = "1.13.0", optional = true }
-threadpool = "1.8.1"
-heed = { git = "https://github.com/timokoesters/heed.git", rev = "f6f825da7fb2c758867e05ad973ef800a6fe1d5d", optional = true }
 
 [features]
 default = ["conduit_bin", "backend_sqlite"]
 backend_sled = ["sled"]
+backend_rocksdb = ["rocksdb"]
 backend_sqlite = ["sqlite"]
-backend_heed = ["heed", "crossbeam"]
+sqlite = ["rusqlite", "parking_lot", "crossbeam", "num_cpus", "tokio/signal"]
-sqlite = ["rusqlite", "parking_lot", "crossbeam", "tokio/signal"]
 conduit_bin = [] # TODO: add rocket to this when it is optional
 
 [[bin]]
@@ -120,20 +117,6 @@ conf-files = [
 maintainer-scripts = "debian/"
 systemd-units = { unit-name = "matrix-conduit" }
 
-[profile.dev]
+# For flamegraphs:
-lto = 'thin'
+#[profile.release]
-incremental = true
-
-[profile.release]
-lto = 'thin'
-incremental = true
-
-codegen-units=32
-# If you want to make flamegraphs, enable debug info:
 #debug = true
-
-# For releases also try to max optimizations for dependencies:
-[profile.release.build-override]
-opt-level = 3
-[profile.release.package."*"]
-opt-level = 3

DEPLOY.md

@@ -6,21 +6,12 @@ If you run into any problems while setting up Conduit, write an email to `timo@k
 
 ## Installing Conduit
 
-You may simply download the binary that fits your machine. Run `uname -m` to see what you need. Now copy the right url:
+You may simply download the binary that fits your machine. Run `uname -m` to see
-
+what you need. Now copy the right url:
-| CPU Architecture     | GNU (Ubuntu, Debian, ArchLinux, ...)  | MUSL (Alpine, ... )     |
+- x84_64: `https://conduit.rs/master/x86_64/conduit-bin`
-| -------------------- | ------------------------------------- | ----------------------- |
+- armv7: `https://conduit.rs/master/armv7/conduit-bin`
-| x84_64 / amd64       | [Download][x84_64-gnu]                | [Download][x84_64-musl] |
+- armv8: `https://conduit.rs/master/armv8/conduit-bin`
-| armv7 (Raspberry Pi) | [Download][armv7-gnu]                 | -                       |
+- arm: `https://conduit.rs/master/arm/conduit-bin`
-| armv8 / aarch64      | [Download][armv8-gnu]                 | -                       |
-
-[x84_64-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-gnu?job=build:release:cargo:x86_64-unknown-linux-gnu
-
-[x84_64-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-musl?job=build:release:cargo:x86_64-unknown-linux-musl
-
-[armv7-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-armv7-unknown-linux-gnueabihf?job=build:release:cargo:armv7-unknown-linux-gnueabihf
-
-[armv8-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-aarch64-unknown-linux-gnu?job=build:release:cargo:aarch64-unknown-linux-gnu
 
 ```bash
 $ sudo wget -O /usr/local/bin/matrix-conduit <url>
@@ -28,7 +19,6 @@ $ sudo chmod +x /usr/local/bin/matrix-conduit
 ```
 
 Alternatively, you may compile the binary yourself using
-
 ```bash
 $ cargo build --release
 ```
@@ -36,7 +26,6 @@ Note that this currently requires Rust 1.50.
 
 If you want to cross compile Conduit to another architecture, read the [Cross-Compile Guide](CROSS_COMPILE.md).
 
-
 ## Adding a Conduit user
 
 While Conduit can run as any user it is usually better to use dedicated users for different services.
@@ -117,13 +106,11 @@ allow_federation = true
 
 trusted_servers = ["matrix.org"]
 
+#db_cache_capacity = 1073741824 # in bytes, 1024 * 1024 * 1024
 #max_concurrent_requests = 100 # How many requests Conduit sends to other servers at the same time
 #workers = 4 # default: cpu core count * 2
 
 address = "127.0.0.1" # This makes sure Conduit can only be reached using the reverse proxy
-
-# The total amount of memory that the database will use.
-#db_cache_capacity_mb = 200
 ```
 
 ## Setting the correct file permissions

Dockerfile

@@ -5,7 +5,7 @@
 
 ##########################  BUILD IMAGE  ##########################
 # Alpine build image to build Conduit's statically compiled binary
-FROM alpine:3.14 as builder
+FROM alpine:3.12 as builder
 
 # Specifies if the local project is build or if Conduit gets build
 # from the official git repository. Defaults to the git repo.
@@ -13,6 +13,11 @@ ARG LOCAL=false
 # Specifies which revision/commit is build. Defaults to HEAD
 ARG GIT_REF=origin/master
 
+# Add 'edge'-repository to get Rust 1.45
+RUN sed -i \
+	-e 's|v3\.12|edge|' \
+	/etc/apk/repositories
+
 # Install packages needed for building all crates
 RUN apk add --no-cache \
         cargo \
@@ -31,7 +36,7 @@ RUN if [[ $LOCAL == "true" ]]; then \
 ########################## RUNTIME IMAGE ##########################
 # Create new stage with a minimal image for the actual
 # runtime image/container
-FROM alpine:3.14
+FROM alpine:3.12
 
 ARG CREATED
 ARG VERSION
@@ -56,8 +61,8 @@ LABEL org.opencontainers.image.created=${CREATED} \
       org.label-schema.docker.build="docker build . -t matrixconduit/matrix-conduit:latest --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ') --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)" \
       maintainer="Weasy666"
 
-# Standard port on which Conduit launches. You still need to map the port when using the docker command or docker-compose.
+# Standard port on which Rocket launches
-EXPOSE 6167
+EXPOSE 8000
 
 # Copy config files from context and the binary from
 # the "builder" stage to the current stage into folder
@@ -81,11 +86,11 @@ RUN apk add --no-cache \
         curl \
         libgcc
 
+# Create a volume for the database, to persist its contents
+VOLUME ["/srv/conduit/.local/share/conduit"]
+
 # Test if Conduit is still alive, uses the same endpoint as Element
-HEALTHCHECK --start-period=5s \
+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
-    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

README.md

@@ -38,8 +38,8 @@ are not aware of such a bug today, but we would like to do more testing.
 There are still a few important features missing:
 
 - Database stability (currently you might have to do manual upgrades or even wipe the db for new versions)
-- Edge cases for end-to-end encryption over federation
+- End-to-end encrypted chats over federation
-- Typing and presence over federation
+- Typing, presence, read receipts etc. over federation
 - Lots of testing
 
 Check out the [Conduit 1.0 Release Milestone](https://gitlab.com/famedly/conduit/-/milestones/3).

conduit-example.toml

@@ -12,7 +12,7 @@
 #server_name = "your.server.name"
 
 # This is the only directory where Conduit will save its data
-database_path = "/var/lib/conduit/"
+database_path = "/var/lib/conduit/conduit.db"
 
 # The port Conduit will be running on. You need to set up a reverse proxy in
 # your web server (e.g. apache or nginx), so all requests to /_matrix on port
@@ -35,6 +35,7 @@ max_request_size = 20_000_000 # in bytes
 
 trusted_servers = ["matrix.org"]
 
+#db_cache_capacity = 1073741824 # in bytes, 1024 * 1024 * 1024
 #max_concurrent_requests = 100 # How many requests Conduit sends to other servers at the same time
 #log = "info,state_res=warn,rocket=off,_=off,sled=off"
 #workers = 4 # default: cpu core count * 2
@@ -42,6 +43,3 @@ trusted_servers = ["matrix.org"]
 address = "127.0.0.1" # This makes sure Conduit can only be reached using the reverse proxy
 
 proxy = "none" # more examples can be found at src/database/proxy.rs:6
-
-# The total amount of memory that the database will use.
-#db_cache_capacity_mb = 200

debian/postinst

@@ -73,12 +73,10 @@ max_request_size = 20_000_000 # in bytes
 # Enable jaeger to support monitoring and troubleshooting through jaeger.
 #allow_jaeger = false
 
+#db_cache_capacity = 1073741824 # in bytes, 1024 * 1024 * 1024
 #max_concurrent_requests = 100 # How many requests Conduit sends to other servers at the same time
 #log = "info,state_res=warn,rocket=off,_=off,sled=off"
 #workers = 4 # default: cpu core count * 2
-
-# The total amount of memory that the database will use.
-#db_cache_capacity_mb = 200
 EOF
     fi
     ;;

docker-compose.yml

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

docker/ci-binaries-packaging.Dockerfile

@@ -1,70 +0,0 @@
-# ---------------------------------------------------------------------------------------------------------
-# This Dockerfile is intended to be built as part of Conduit's CI pipeline.
-# It does not build Conduit in Docker, but just copies the matching build artifact from the build job.
-# As a consequence, this is not a multiarch capable image. It always expects and packages a x86_64 binary.
-#
-# It is mostly based on the normal Conduit Dockerfile, but adjusted in a few places to maximise caching.
-# Credit's for the original Dockerfile: Weasy666.
-# ---------------------------------------------------------------------------------------------------------
-
-FROM alpine:3.14
-
-ARG CREATED
-ARG VERSION
-ARG GIT_REF
-
-ENV CONDUIT_CONFIG="/srv/conduit/conduit.toml"
-
-# Labels according to https://github.com/opencontainers/image-spec/blob/master/annotations.md
-# including a custom label specifying the build command
-LABEL org.opencontainers.image.created=${CREATED} \
-      org.opencontainers.image.authors="Conduit Contributors" \
-      org.opencontainers.image.title="Conduit" \
-      org.opencontainers.image.version=${VERSION} \
-      org.opencontainers.image.vendor="Conduit Contributors" \
-      org.opencontainers.image.description="A Matrix homeserver written in Rust" \
-      org.opencontainers.image.url="https://conduit.rs/" \
-      org.opencontainers.image.revision=${GIT_REF} \
-      org.opencontainers.image.source="https://gitlab.com/famedly/conduit.git" \
-      org.opencontainers.image.licenses="Apache-2.0" \
-      org.opencontainers.image.documentation="" \
-      org.opencontainers.image.ref.name=""
-
-# Standard port on which Conduit launches. You still need to map the port when using the docker command or docker-compose.
-EXPOSE 6167
-
-# create data folder for database
-RUN mkdir -p /srv/conduit/.local/share/conduit
-
-# Add www-data user and group with UID 82, as used by alpine
-# https://git.alpinelinux.org/aports/tree/main/nginx/nginx.pre-install
-RUN set -x ; \
-    addgroup -Sg 82 www-data 2>/dev/null ; \
-    adduser -S -D -H -h /srv/conduit -G www-data -g www-data www-data 2>/dev/null ; \
-    addgroup www-data www-data 2>/dev/null && exit 0 ; exit 1
-
-# Change ownership of Conduit files to www-data user and group
-RUN chown -cR www-data:www-data /srv/conduit
-
-# Install packages needed to run Conduit
-RUN apk add --no-cache \
-        ca-certificates \
-        curl \
-        libgcc
-
-# Test if Conduit is still alive, uses the same endpoint as Element
-HEALTHCHECK --start-period=5s \
-    CMD curl --fail -s "http://localhost:$(grep -m1 -o 'port\s=\s[0-9]*' conduit.toml | grep -m1 -o '[0-9]*')/_matrix/client/versions" || \
-        curl -k --fail -s "https://localhost:$(grep -m1 -o 'port\s=\s[0-9]*' conduit.toml | grep -m1 -o '[0-9]*')/_matrix/client/versions" || \
-        exit 1
-
-# Set user to www-data
-USER www-data
-# Set container home directory
-WORKDIR /srv/conduit
-# Run Conduit
-ENTRYPOINT [ "/srv/conduit/conduit" ]
-
-
-# Copy the Conduit binary into the image at the latest possible moment to maximise caching:
-COPY ./conduit-x86_64-unknown-linux-musl /srv/conduit/conduit

docker/docker-compose.traefik.yml

@@ -12,8 +12,8 @@ services:
         # build:
         #     context: .
         #     args:
-        #         CREATED: '2021-03-16T08:18:27Z'
+        #         CREATED:
-        #         VERSION: '0.1.0'
+        #         VERSION:
         #         LOCAL: 'false'
         #         GIT_REF: origin/master
         restart: unless-stopped
@@ -25,12 +25,12 @@ services:
         networks:
             - proxy
         environment:
-            CONDUIT_SERVER_NAME: localhost:6167  # replace with your own name
+            CONDUIT_SERVER_NAME: localhost:8000  # replace with your own name
             CONDUIT_TRUSTED_SERVERS: '["matrix.org"]'
             ### Uncomment and change values as desired
-            # CONDUIT_ADDRESS: 0.0.0.0
+            # CONDUIT_ADDRESS: 127.0.0.1
-            # CONDUIT_PORT: 6167
+            # CONDUIT_PORT: 8000
-            # CONDUIT_CONFIG: '/srv/conduit/conduit.toml'  # if you want to configure purely by env vars, set this to an empty string ''
+            # CONDUIT_CONFIG: '/srv/conduit/conduit.toml'  # if want to configure purely by env vars, set this to an empty string ''
             # Available levels are: error, warn, info, debug, trace - more info at: https://docs.rs/env_logger/*/env_logger/#enabling-logging
             # CONDUIT_LOG: info  # default is: "info,rocket=off,_=off,sled=off"
             # CONDUIT_ALLOW_JAEGER: 'false'
@@ -59,7 +59,7 @@ volumes:
     db:
 
 networks:
-    # This is the network Traefik listens to, if your network has a different
+    # This is the network Traefik listens to, if you network has a different
     # name, don't forget to change it here and in the docker-compose.override.yml
     proxy:
         external: true

rust-toolchain

@@ -1 +1 @@
-1.52
+1.51.0

src/appservice_server.rs

@@ -1,5 +1,6 @@
 use crate::{utils, Error, Result};
 use bytes::BytesMut;
+use log::warn;
 use ruma::api::{IncomingResponse, OutgoingRequest, SendAccessToken};
 use std::{
     convert::{TryFrom, TryInto},
@@ -7,7 +8,6 @@ use std::{
     mem,
     time::Duration,
 };
-use tracing::warn;
 
 pub async fn send_request<T: OutgoingRequest>(
     globals: &crate::database::globals::Globals,
@@ -46,11 +46,7 @@ where
     *reqwest_request.timeout_mut() = Some(Duration::from_secs(30));
 
     let url = reqwest_request.url().clone();
-    let mut response = globals
+    let mut response = globals.reqwest_client().execute(reqwest_request).await?;
-        .reqwest_client()?
-        .build()?
-        .execute(reqwest_request)
-        .await?;
 
     // reqwest::Response -> http::Response conversion
     let status = response.status();

src/client_server/account.rs

@@ -1,11 +1,8 @@
-use std::{
+use std::{collections::BTreeMap, convert::TryInto, sync::Arc};
-    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
-    sync::Arc,
-};
 
 use super::{DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
 use crate::{database::DatabaseGuard, pdu::PduBuilder, utils, ConduitResult, Error, Ruma};
+use log::info;
 use ruma::{
     api::client::{
         error::ErrorKind,
@@ -14,7 +11,6 @@ use ruma::{
                 change_password, deactivate, get_username_availability, register, whoami,
                 ThirdPartyIdRemovalStatus,
             },
-            contact::get_contacts,
             uiaa::{AuthFlow, UiaaInfo},
         },
     },
@@ -25,10 +21,8 @@ use ruma::{
         },
         EventType,
     },
-    identifiers::RoomName,
     push, RoomAliasId, RoomId, RoomVersionId, UserId,
 };
-use tracing::info;
 
 use register::RegistrationKind;
 #[cfg(feature = "conduit_bin")]
@@ -162,18 +156,16 @@ pub async fn register_route(
                 return Err(Error::Uiaa(uiaainfo));
             }
         // Success!
-        } else if let Some(json) = body.json_body {
+        } else {
             uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
             db.uiaa.create(
                 &UserId::parse_with_server_name("", db.globals.server_name())
                     .expect("we know this is valid"),
                 "".into(),
                 &uiaainfo,
-                &json,
+                &body.json_body.expect("body is json"),
             )?;
             return Err(Error::Uiaa(uiaainfo));
-        } else {
-            return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
         }
     }
 
@@ -193,11 +185,6 @@ pub async fn register_route(
     // Create user
     db.users.create(&user_id, password)?;
 
-    let displayname = format!("{} ⚡️", user_id.localpart());
-
-    db.users
-        .set_displayname(&user_id, Some(displayname.clone()))?;
-
     // Initial data
     db.account_data.update(
         None,
@@ -249,17 +236,15 @@ pub async fn register_route(
 
         let room_id = RoomId::new(db.globals.server_name());
 
-        db.rooms.get_or_create_shortroomid(&room_id, &db.globals)?;
+        let mutex = Arc::clone(
-
-        let mutex_state = Arc::clone(
             db.globals
-                .roomid_mutex_state
+                .roomid_mutex
                 .write()
                 .unwrap()
                 .entry(room_id.clone())
                 .or_default(),
         );
-        let state_lock = mutex_state.lock().await;
+        let mutex_lock = mutex.lock().await;
 
         let mut content = ruma::events::room::create::CreateEventContent::new(conduit_user.clone());
         content.federate = true;
@@ -278,7 +263,7 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         // 2. Make conduit bot join
@@ -291,8 +276,6 @@ pub async fn register_route(
                     avatar_url: None,
                     is_direct: None,
                     third_party_invite: None,
-                    blurhash: None,
-                    reason: None,
                 })
                 .expect("event is valid, we just created it"),
                 unsigned: None,
@@ -302,7 +285,7 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         // 3. Power levels
@@ -327,7 +310,7 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         // 4.1 Join Rules
@@ -345,7 +328,7 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         // 4.2 History Visibility
@@ -365,7 +348,7 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         // 4.3 Guest Access
@@ -383,17 +366,18 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         // 6. Events implied by name and topic
-        let room_name =
-            Box::<RoomName>::try_from(format!("{} Admin Room", db.globals.server_name()))
-                .expect("Room name is valid");
         db.rooms.build_and_append_pdu(
             PduBuilder {
                 event_type: EventType::RoomName,
-                content: serde_json::to_value(name::NameEventContent::new(Some(room_name)))
+                content: serde_json::to_value(
+                    name::NameEventContent::new("Admin Room".to_owned()).map_err(|_| {
+                        Error::BadRequest(ErrorKind::InvalidParam, "Name is invalid.")
+                    })?,
+                )
                 .expect("event is valid, we just created it"),
                 unsigned: None,
                 state_key: Some("".to_owned()),
@@ -402,7 +386,7 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         db.rooms.build_and_append_pdu(
@@ -419,7 +403,7 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         // Room alias
@@ -442,7 +426,7 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         db.rooms.set_alias(&alias, Some(&room_id), &db.globals)?;
@@ -457,8 +441,6 @@ pub async fn register_route(
                     avatar_url: None,
                     is_direct: None,
                     third_party_invite: None,
-                    blurhash: None,
-                    reason: None,
                 })
                 .expect("event is valid, we just created it"),
                 unsigned: None,
@@ -468,19 +450,17 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
         db.rooms.build_and_append_pdu(
             PduBuilder {
                 event_type: EventType::RoomMember,
                 content: serde_json::to_value(member::MemberEventContent {
                     membership: member::MembershipState::Join,
-                    displayname: Some(displayname),
+                    displayname: None,
                     avatar_url: None,
                     is_direct: None,
                     third_party_invite: None,
-                    blurhash: None,
-                    reason: None,
                 })
                 .expect("event is valid, we just created it"),
                 unsigned: None,
@@ -490,7 +470,7 @@ pub async fn register_route(
             &user_id,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
 
         // Send welcome message
@@ -509,13 +489,13 @@ pub async fn register_route(
             &conduit_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
     }
 
     info!("{} registered on this server", user_id);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(register::Response {
         access_token: Some(token),
@@ -567,13 +547,15 @@ pub async fn change_password_route(
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
     } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
     }
 
     db.users
@@ -591,9 +573,9 @@ pub async fn change_password_route(
         }
     }
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(change_password::Response {}.into())
+    Ok(change_password::Response.into())
 }
 
 /// # `GET _matrix/client/r0/account/whoami`
@@ -657,27 +639,23 @@ pub async fn deactivate_route(
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
     } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
     }
 
     // Leave all joined rooms and reject all invitations
-    let all_rooms = db
+    for room_id in db.rooms.rooms_joined(&sender_user).chain(
-        .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,
@@ -685,19 +663,17 @@ pub async fn deactivate_route(
             avatar_url: None,
             is_direct: None,
             third_party_invite: None,
-            blurhash: None,
-            reason: None,
         };
 
-        let mutex_state = Arc::clone(
+        let mutex = Arc::clone(
             db.globals
-                .roomid_mutex_state
+                .roomid_mutex
                 .write()
                 .unwrap()
                 .entry(room_id.clone())
                 .or_default(),
         );
-        let state_lock = mutex_state.lock().await;
+        let mutex_lock = mutex.lock().await;
 
         db.rooms.build_and_append_pdu(
             PduBuilder {
@@ -710,7 +686,7 @@ pub async fn deactivate_route(
             &sender_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
     }
 
@@ -719,7 +695,7 @@ pub async fn deactivate_route(
 
     info!("{} deactivated their account", sender_user);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(deactivate::Response {
         id_server_unbind_result: ThirdPartyIdRemovalStatus::NoSupport,
@@ -727,17 +703,16 @@ pub async fn deactivate_route(
     .into())
 }
 
-/// # `GET _matrix/client/r0/account/3pid`
+/*/
-///
-/// Get a list of third party identifiers associated with this account.
 #[cfg_attr(
     feature = "conduit_bin",
     get("/_matrix/client/r0/account/3pid", data = "<body>")
 )]
 pub async fn third_party_route(
-    body: Ruma<get_contacts::Request>,
+    body: Ruma<account::add_3pid::Request<'_>>,
-) -> ConduitResult<get_contacts::Response> {
+) -> ConduitResult<account::add_3pid::Response> {
-    let _sender_user = body.sender_user.as_ref().expect("user is authenticated");
+    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    Ok(get_contacts::Response::new(Vec::new()).into())
+    Ok(account::add_3pid::Response::default().into())
 }
+*/

src/client_server/alias.rs

@@ -31,7 +31,7 @@ pub async fn create_alias_route(
     db.rooms
         .set_alias(&body.room_alias, Some(&body.room_id), &db.globals)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(create_alias::Response::new().into())
 }
@@ -47,7 +47,7 @@ pub async fn delete_alias_route(
 ) -> ConduitResult<delete_alias::Response> {
     db.rooms.set_alias(&body.room_alias, None, &db.globals)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(delete_alias::Response::new().into())
 }
@@ -85,7 +85,8 @@ pub async fn get_alias_helper(
     match db.rooms.id_from_alias(&room_alias)? {
         Some(r) => room_id = Some(r),
         None => {
-            for (_id, registration) in db.appservice.all()? {
+            let iter = db.appservice.iter_all()?;
+            for (_id, registration) in iter.filter_map(|r| r.ok()) {
                 let aliases = registration
                     .get("namespaces")
                     .and_then(|ns| ns.get("aliases"))

src/client_server/backup.rs

@@ -26,7 +26,7 @@ pub async fn create_backup_route(
         .key_backups
         .create_backup(&sender_user, &body.algorithm, &db.globals)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(create_backup::Response { version }.into())
 }
@@ -44,9 +44,9 @@ pub async fn update_backup_route(
     db.key_backups
         .update_backup(&sender_user, &body.version, &body.algorithm, &db.globals)?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(update_backup::Response {}.into())
+    Ok(update_backup::Response.into())
 }
 
 #[cfg_attr(
@@ -117,9 +117,9 @@ pub async fn delete_backup_route(
 
     db.key_backups.delete_backup(&sender_user, &body.version)?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(delete_backup::Response {}.into())
+    Ok(delete_backup::Response.into())
 }
 
 /// Add the received backup keys to the database.
@@ -147,7 +147,7 @@ pub async fn add_backup_keys_route(
         }
     }
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(add_backup_keys::Response {
         count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -179,7 +179,7 @@ pub async fn add_backup_key_sessions_route(
         )?
     }
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(add_backup_key_sessions::Response {
         count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -209,7 +209,7 @@ pub async fn add_backup_key_session_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(add_backup_key_session::Response {
         count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -288,7 +288,7 @@ pub async fn delete_backup_keys_route(
     db.key_backups
         .delete_all_keys(&sender_user, &body.version)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(delete_backup_keys::Response {
         count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -311,7 +311,7 @@ pub async fn delete_backup_key_sessions_route(
     db.key_backups
         .delete_room_keys(&sender_user, &body.version, &body.room_id)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(delete_backup_key_sessions::Response {
         count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),
@@ -334,7 +334,7 @@ pub async fn delete_backup_key_session_route(
     db.key_backups
         .delete_room_key(&sender_user, &body.version, &body.room_id, &body.session_id)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(delete_backup_key_session::Response {
         count: (db.key_backups.count_keys(sender_user, &body.version)? as u32).into(),

src/client_server/capabilities.rs

@@ -1,5 +1,4 @@
 use crate::ConduitResult;
-use crate::Ruma;
 use ruma::{
     api::client::r0::capabilities::{
         get_capabilities, Capabilities, RoomVersionStability, RoomVersionsCapability,
@@ -14,16 +13,10 @@ use rocket::get;
 /// # `GET /_matrix/client/r0/capabilities`
 ///
 /// Get information on this server's supported feature set and other relevent capabilities.
-#[cfg_attr(
+#[cfg_attr(feature = "conduit_bin", get("/_matrix/client/r0/capabilities"))]
-    feature = "conduit_bin",
+#[tracing::instrument]
-    get("/_matrix/client/r0/capabilities", data = "<_body>")
+pub async fn get_capabilities_route() -> ConduitResult<get_capabilities::Response> {
-)]
-#[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();

src/client_server/config.rs

@@ -43,9 +43,9 @@ pub async fn set_global_account_data_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_global_account_data::Response {}.into())
+    Ok(set_global_account_data::Response.into())
 }
 
 #[cfg_attr(
@@ -78,9 +78,9 @@ pub async fn set_room_account_data_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_room_account_data::Response {}.into())
+    Ok(set_room_account_data::Response.into())
 }
 
 #[cfg_attr(
@@ -98,7 +98,7 @@ pub async fn get_global_account_data_route(
         .account_data
         .get::<Box<RawJsonValue>>(None, sender_user, body.event_type.clone().into())?
         .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
-    db.flush()?;
+    db.flush().await?;
 
     let account_data = serde_json::from_str::<ExtractGlobalEventContent>(event.get())
         .map_err(|_| Error::bad_database("Invalid account data event in db."))?
@@ -129,7 +129,7 @@ pub async fn get_room_account_data_route(
             body.event_type.clone().into(),
         )?
         .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
-    db.flush()?;
+    db.flush().await?;
 
     let account_data = serde_json::from_str::<ExtractRoomEventContent>(event.get())
         .map_err(|_| Error::bad_database("Invalid account data event in db."))?

src/client_server/context.rs

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

src/client_server/device.rs

@@ -71,9 +71,9 @@ pub async fn update_device_route(
     db.users
         .update_device_metadata(&sender_user, &body.device_id, &device)?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(update_device::Response {}.into())
+    Ok(update_device::Response.into())
 }
 
 #[cfg_attr(
@@ -112,20 +112,22 @@ pub async fn delete_device_route(
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
     } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
     }
 
     db.users.remove_device(&sender_user, &body.device_id)?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(delete_device::Response {}.into())
+    Ok(delete_device::Response.into())
 }
 
 #[cfg_attr(
@@ -164,20 +166,22 @@ pub async fn delete_devices_route(
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
     } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
     }
 
     for device_id in &body.devices {
         db.users.remove_device(&sender_user, &device_id)?
     }
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(delete_devices::Response {}.into())
+    Ok(delete_devices::Response.into())
 }

src/client_server/directory.rs

@@ -1,6 +1,5 @@
-use std::convert::TryInto;
-
 use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Result, Ruma};
+use log::info;
 use ruma::{
     api::{
         client::{
@@ -23,7 +22,6 @@ use ruma::{
     serde::Raw,
     ServerName, UInt,
 };
-use tracing::{info, warn};
 
 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post, put};
@@ -89,22 +87,22 @@ pub async fn set_room_visibility_route(
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
     match &body.visibility {
-        room::Visibility::Public => {
+        room::Visibility::_Custom(_s) => {
-            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.",
             ));
         }
+        room::Visibility::Public => {
+            db.rooms.set_public(&body.room_id, true)?;
+            info!("{} made {} public", sender_user, body.room_id);
+        }
+        room::Visibility::Private => db.rooms.set_public(&body.room_id, false)?,
     }
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_room_visibility::Response {}.into())
+    Ok(set_room_visibility::Response.into())
 }
 
 #[cfg_attr(
@@ -233,18 +231,10 @@ pub async fn get_public_rooms_filtered_helper(
                             .map_err(|_| {
                                 Error::bad_database("Invalid room name event in database.")
                             })?
-                            .name
+                            .name()
-                            .map(|n| n.to_owned().into()))
+                            .map(|n| n.to_owned()))
                         })?,
-                    num_joined_members: db
+                    num_joined_members: (db.rooms.room_members(&room_id).count() as u32).into(),
-                        .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, "")?
@@ -326,7 +316,7 @@ pub async fn get_public_rooms_filtered_helper(
                     .map(|q| q.to_lowercase())
                 {
                     if let Some(name) = &chunk.name {
-                        if name.as_str().to_lowercase().contains(&query) {
+                        if name.to_lowercase().contains(&query) {
                             return true;
                         }
                     }

src/client_server/keys.rs

@@ -1,9 +1,7 @@
 use super::SESSION_ID_LENGTH;
 use crate::{database::DatabaseGuard, utils, ConduitResult, Database, Error, Result, Ruma};
-use rocket::futures::{prelude::*, stream::FuturesUnordered};
 use ruma::{
-    api::{
+    api::client::{
-        client::{
         error::ErrorKind,
         r0::{
             keys::{
@@ -13,13 +11,10 @@ use ruma::{
             uiaa::{AuthFlow, UiaaInfo},
         },
     },
-        federation,
-    },
     encryption::UnsignedDeviceInfo,
     DeviceId, DeviceKeyAlgorithm, UserId,
 };
-use serde_json::json;
+use std::collections::{BTreeMap, HashSet};
-use std::collections::{BTreeMap, HashMap, HashSet};
 
 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post};
@@ -65,7 +60,7 @@ pub async fn upload_keys_route(
         }
     }
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(upload_keys::Response {
         one_time_key_counts: db.users.count_one_time_keys(sender_user, sender_device)?,
@@ -89,8 +84,7 @@ pub async fn get_keys_route(
         &body.device_keys,
         |u| u == sender_user,
         &db,
-    )
+    )?;
-    .await?;
 
     Ok(response.into())
 }
@@ -104,16 +98,16 @@ pub async fn claim_keys_route(
     db: DatabaseGuard,
     body: Ruma<claim_keys::Request>,
 ) -> ConduitResult<claim_keys::Response> {
-    let response = claim_keys_helper(&body.one_time_keys, &db).await?;
+    let response = claim_keys_helper(&body.one_time_keys, &db)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(response.into())
 }
 
 #[cfg_attr(
     feature = "conduit_bin",
-    post("/_matrix/client/r0/keys/device_signing/upload", data = "<body>")
+    post("/_matrix/client/unstable/keys/device_signing/upload", data = "<body>")
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn upload_signing_keys_route(
@@ -147,13 +141,15 @@ pub async fn upload_signing_keys_route(
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
-    } else if let Some(json) = body.json_body {
-        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        db.uiaa
-            .create(&sender_user, &sender_device, &uiaainfo, &json)?;
-        return Err(Error::Uiaa(uiaainfo));
     } else {
-        return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
+        uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
+        db.uiaa.create(
+            &sender_user,
+            &sender_device,
+            &uiaainfo,
+            &body.json_body.expect("body is json"),
+        )?;
+        return Err(Error::Uiaa(uiaainfo));
     }
 
     if let Some(master_key) = &body.master_key {
@@ -167,14 +163,14 @@ pub async fn upload_signing_keys_route(
         )?;
     }
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(upload_signing_keys::Response {}.into())
+    Ok(upload_signing_keys::Response.into())
 }
 
 #[cfg_attr(
     feature = "conduit_bin",
-    post("/_matrix/client/r0/keys/signatures/upload", data = "<body>")
+    post("/_matrix/client/unstable/keys/signatures/upload", data = "<body>")
 )]
 #[tracing::instrument(skip(db, body))]
 pub async fn upload_signatures_route(
@@ -228,9 +224,9 @@ pub async fn upload_signatures_route(
         }
     }
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(upload_signatures::Response {}.into())
+    Ok(upload_signatures::Response.into())
 }
 
 #[cfg_attr(
@@ -284,7 +280,7 @@ pub async fn get_key_changes_route(
     .into())
 }
 
-pub async fn get_keys_helper<F: Fn(&UserId) -> bool>(
+pub fn get_keys_helper<F: Fn(&UserId) -> bool>(
     sender_user: Option<&UserId>,
     device_keys_input: &BTreeMap<UserId, Vec<Box<DeviceId>>>,
     allowed_signatures: F,
@@ -295,17 +291,7 @@ pub async fn get_keys_helper<F: Fn(&UserId) -> bool>(
     let mut user_signing_keys = BTreeMap::new();
     let mut device_keys = BTreeMap::new();
 
-    let mut get_over_federation = HashMap::new();
-
     for (user_id, device_ids) in device_keys_input {
-        if user_id.server_name() != db.globals.server_name() {
-            get_over_federation
-                .entry(user_id.server_name())
-                .or_insert_with(Vec::new)
-                .push((user_id, device_ids));
-            continue;
-        }
-
         if device_ids.is_empty() {
             let mut container = BTreeMap::new();
             for device_id in db.users.all_device_ids(user_id) {
@@ -363,68 +349,21 @@ pub async fn get_keys_helper<F: Fn(&UserId) -> bool>(
         }
     }
 
-    let mut failures = BTreeMap::new();
-
-    let mut futures = get_over_federation
-        .into_iter()
-        .map(|(server, vec)| async move {
-            let mut device_keys_input_fed = BTreeMap::new();
-            for (user_id, keys) in vec {
-                device_keys_input_fed.insert(user_id.clone(), keys.clone());
-            }
-            (
-                server,
-                db.sending
-                    .send_federation_request(
-                        &db.globals,
-                        server,
-                        federation::keys::get_keys::v1::Request {
-                            device_keys: device_keys_input_fed,
-                        },
-                    )
-                    .await,
-            )
-        })
-        .collect::<FuturesUnordered<_>>();
-
-    while let Some((server, response)) = futures.next().await {
-        match response {
-            Ok(response) => {
-                master_keys.extend(response.master_keys);
-                self_signing_keys.extend(response.self_signing_keys);
-                device_keys.extend(response.device_keys);
-            }
-            Err(_e) => {
-                failures.insert(server.to_string(), json!({}));
-            }
-        }
-    }
-
     Ok(get_keys::Response {
         master_keys,
         self_signing_keys,
         user_signing_keys,
         device_keys,
-        failures,
+        failures: BTreeMap::new(),
     })
 }
 
-pub async fn claim_keys_helper(
+pub fn claim_keys_helper(
     one_time_keys_input: &BTreeMap<UserId, BTreeMap<Box<DeviceId>, DeviceKeyAlgorithm>>,
     db: &Database,
 ) -> Result<claim_keys::Response> {
     let mut one_time_keys = BTreeMap::new();
-
-    let mut get_over_federation = BTreeMap::new();
-
     for (user_id, map) in one_time_keys_input {
-        if user_id.server_name() != db.globals.server_name() {
-            get_over_federation
-                .entry(user_id.server_name())
-                .or_insert_with(Vec::new)
-                .push((user_id, map));
-        }
-
         let mut container = BTreeMap::new();
         for (device_id, key_algorithm) in map {
             if let Some(one_time_keys) =
@@ -439,33 +378,8 @@ pub async fn claim_keys_helper(
         one_time_keys.insert(user_id.clone(), container);
     }
 
-    let mut failures = BTreeMap::new();
-
-    for (server, vec) in get_over_federation {
-        let mut one_time_keys_input_fed = BTreeMap::new();
-        for (user_id, keys) in vec {
-            one_time_keys_input_fed.insert(user_id.clone(), keys.clone());
-        }
-        // Ignore failures
-        if let Ok(keys) = db
-            .sending
-            .send_federation_request(
-                &db.globals,
-                server,
-                federation::keys::claim_keys::v1::Request {
-                    one_time_keys: one_time_keys_input_fed,
-                },
-            )
-            .await
-        {
-            one_time_keys.extend(keys.one_time_keys);
-        } else {
-            failures.insert(server.to_string(), json!({}));
-        }
-    }
-
     Ok(claim_keys::Response {
-        failures,
+        failures: BTreeMap::new(),
         one_time_keys,
     })
 }

src/client_server/media.rs

@@ -52,7 +52,7 @@ pub async fn create_content_route(
         )
         .await?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(create_content::Response {
         content_uri: mxc.try_into().expect("Invalid mxc:// URI"),

src/client_server/membership.rs

@@ -4,6 +4,7 @@ use crate::{
     pdu::{PduBuilder, PduEvent},
     server_server, utils, ConduitResult, Database, Error, Result, Ruma,
 };
+use log::{debug, error, warn};
 use member::{MemberEventContent, MembershipState};
 use rocket::futures;
 use ruma::{
@@ -28,12 +29,11 @@ use ruma::{
     uint, EventId, RoomId, RoomVersionId, ServerName, UserId,
 };
 use std::{
-    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
+    collections::{btree_map::Entry, BTreeMap, HashSet},
     convert::{TryFrom, TryInto},
     sync::{Arc, RwLock},
     time::{Duration, Instant},
 };
-use tracing::{debug, error, warn};
 
 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post};
@@ -74,7 +74,7 @@ pub async fn join_room_by_id_route(
     )
     .await;
 
-    db.flush()?;
+    db.flush().await?;
 
     ret
 }
@@ -125,7 +125,7 @@ pub async fn join_room_by_id_or_alias_route(
     )
     .await?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(join_room_by_id_or_alias::Response {
         room_id: join_room_response.0.room_id,
@@ -146,7 +146,7 @@ pub async fn leave_room_route(
 
     db.rooms.leave_room(sender_user, &body.room_id, &db).await?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(leave_room::Response::new().into())
 }
@@ -164,8 +164,8 @@ pub async fn invite_user_route(
 
     if let invite_user::IncomingInvitationRecipient::UserId { user_id } = &body.recipient {
         invite_helper(sender_user, user_id, &body.room_id, &db, false).await?;
-        db.flush()?;
+        db.flush().await?;
-        Ok(invite_user::Response {}.into())
+        Ok(invite_user::Response.into())
     } else {
         Err(Error::BadRequest(ErrorKind::NotFound, "User not found."))
     }
@@ -203,15 +203,15 @@ pub async fn kick_user_route(
     event.membership = ruma::events::room::member::MembershipState::Leave;
     // TODO: reason
 
-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
         db.globals
-            .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(body.room_id.clone())
             .or_default(),
     );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
     db.rooms.build_and_append_pdu(
         PduBuilder {
@@ -224,12 +224,12 @@ pub async fn kick_user_route(
         &sender_user,
         &body.room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    drop(state_lock);
+    drop(mutex_lock);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(kick_user::Response::new().into())
 }
@@ -261,8 +261,6 @@ pub async fn ban_user_route(
                 avatar_url: db.users.avatar_url(&body.user_id)?,
                 is_direct: None,
                 third_party_invite: None,
-                blurhash: db.users.blurhash(&body.user_id)?,
-                reason: None,
             }),
             |event| {
                 let mut event = serde_json::from_value::<Raw<member::MemberEventContent>>(
@@ -276,15 +274,15 @@ pub async fn ban_user_route(
             },
         )?;
 
-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
         db.globals
-            .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(body.room_id.clone())
             .or_default(),
     );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
     db.rooms.build_and_append_pdu(
         PduBuilder {
@@ -297,12 +295,12 @@ pub async fn ban_user_route(
         &sender_user,
         &body.room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    drop(state_lock);
+    drop(mutex_lock);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(ban_user::Response::new().into())
 }
@@ -338,15 +336,15 @@ pub async fn unban_user_route(
 
     event.membership = ruma::events::room::member::MembershipState::Leave;
 
-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
         db.globals
-            .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(body.room_id.clone())
             .or_default(),
     );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
     db.rooms.build_and_append_pdu(
         PduBuilder {
@@ -359,12 +357,12 @@ pub async fn unban_user_route(
         &sender_user,
         &body.room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    drop(state_lock);
+    drop(mutex_lock);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(unban_user::Response::new().into())
 }
@@ -382,7 +380,7 @@ pub async fn forget_room_route(
 
     db.rooms.forget(&body.room_id, &sender_user)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(forget_room::Response::new().into())
 }
@@ -487,15 +485,15 @@ async fn join_room_by_id_helper(
 ) -> ConduitResult<join_room_by_id::Response> {
     let sender_user = sender_user.expect("user is authenticated");
 
-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
         db.globals
-            .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(room_id.clone())
             .or_default(),
     );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
     // Ask a remote server if we don't have this room
     if !db.rooms.exists(&room_id)? && room_id.server_name() != db.globals.server_name() {
@@ -512,7 +510,7 @@ async fn join_room_by_id_helper(
                     federation::membership::create_join_event_template::v1::Request {
                         room_id,
                         user_id: sender_user,
-                        ver: &[RoomVersionId::Version5, RoomVersionId::Version6],
+                        ver: &[RoomVersionId::Version6],
                     },
                 )
                 .await;
@@ -527,12 +525,7 @@ async fn join_room_by_id_helper(
         let (make_join_response, remote_server) = make_join_response_and_server?;
 
         let room_version = match make_join_response.room_version {
-            Some(room_version)
+            Some(room_version) if room_version == RoomVersionId::Version6 => room_version,
-                if room_version == RoomVersionId::Version5
-                    || room_version == RoomVersionId::Version6 =>
-            {
-                room_version
-            }
             _ => return Err(Error::BadServerResponse("Room version is not supported")),
         };
 
@@ -563,8 +556,6 @@ async fn join_room_by_id_helper(
                 avatar_url: db.users.avatar_url(&sender_user)?,
                 is_direct: None,
                 third_party_invite: None,
-                blurhash: db.users.blurhash(&sender_user)?,
-                reason: None,
             })
             .expect("event is valid, we just created it"),
         );
@@ -611,12 +602,10 @@ async fn join_room_by_id_helper(
             )
             .await?;
 
-        db.rooms.get_or_create_shortroomid(&room_id, &db.globals)?;
-
         let pdu = PduEvent::from_id_val(&event_id, join_event.clone())
             .map_err(|_| Error::BadServerResponse("Invalid join event PDU."))?;
 
-        let mut state = HashMap::new();
+        let mut state = BTreeMap::new();
         let pub_key_map = RwLock::new(BTreeMap::new());
 
         for result in futures::future::join_all(
@@ -640,40 +629,23 @@ async fn join_room_by_id_helper(
 
             db.rooms.add_pdu_outlier(&event_id, &value)?;
             if let Some(state_key) = &pdu.state_key {
-                let shortstatekey =
+                state.insert((pdu.kind.clone(), state_key.clone()), pdu.event_id.clone());
-                    db.rooms
-                        .get_or_create_shortstatekey(&pdu.kind, state_key, &db.globals)?;
-                state.insert(shortstatekey, pdu.event_id.clone());
             }
         }
 
-        let incoming_shortstatekey = db.rooms.get_or_create_shortstatekey(
+        state.insert(
-            &pdu.kind,
+            (
-            pdu.state_key
+                pdu.kind.clone(),
-                .as_ref()
+                pdu.state_key.clone().expect("join event has state key"),
-                .expect("Pdu is a membership state event"),
+            ),
-            &db.globals,
+            pdu.event_id.clone(),
-        )?;
+        );
 
-        state.insert(incoming_shortstatekey, pdu.event_id.clone());
+        if state.get(&(EventType::RoomCreate, "".to_owned())).is_none() {
-
-        let create_shortstatekey = db
-            .rooms
-            .get_shortstatekey(&EventType::RoomCreate, "")?
-            .expect("Room exists");
-
-        if state.get(&create_shortstatekey).is_none() {
             return Err(Error::BadServerResponse("State contained no create event."));
         }
 
-        db.rooms.force_state(
+        db.rooms.force_state(room_id, state, &db)?;
-            room_id,
-            state
-                .into_iter()
-                .map(|(k, id)| db.rooms.compress_state_event(k, &id, &db.globals))
-                .collect::<Result<HashSet<_>>>()?,
-            &db,
-        )?;
 
         for result in futures::future::join_all(
             send_join_response
@@ -713,8 +685,6 @@ async fn join_room_by_id_helper(
             avatar_url: db.users.avatar_url(&sender_user)?,
             is_direct: None,
             third_party_invite: None,
-            blurhash: db.users.blurhash(&sender_user)?,
-            reason: None,
         };
 
         db.rooms.build_and_append_pdu(
@@ -728,13 +698,13 @@ async fn join_room_by_id_helper(
             &sender_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
     }
 
-    drop(state_lock);
+    drop(mutex_lock);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(join_room_by_id::Response::new(room_id.clone()).into())
 }
@@ -810,18 +780,17 @@ pub async fn invite_helper<'a>(
     db: &Database,
     is_direct: bool,
 ) -> Result<()> {
-    if user_id.server_name() != db.globals.server_name() {
+    let mutex = Arc::clone(
-        let (room_version_id, pdu_json, invite_room_state) = {
-            let mutex_state = Arc::clone(
         db.globals
-                    .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(room_id.clone())
             .or_default(),
     );
-            let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
+    if user_id.server_name() != db.globals.server_name() {
         let prev_events = db
             .rooms
             .get_pdu_leaves(room_id)?
@@ -839,10 +808,7 @@ pub async fn invite_helper<'a>(
                 serde_json::from_value::<Raw<CreateEventContent>>(create_event.content.clone())
                     .expect("Raw::from_value always works.")
                     .deserialize()
-                        .map_err(|e| {
+                    .map_err(|_| Error::bad_database("Invalid PowerLevels event in db."))
-                            warn!("Invalid create event: {}", e);
-                            Error::bad_database("Invalid create event in db.")
-                        })
             })
             .transpose()?;
 
@@ -859,8 +825,7 @@ pub async fn invite_helper<'a>(
             .map_or(RoomVersionId::Version6, |create_event| {
                 create_event.room_version
             });
-            let room_version =
+        let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");
-                RoomVersion::new(&room_version_id).expect("room version is supported");
 
         let content = serde_json::to_value(MemberEventContent {
             avatar_url: None,
@@ -868,21 +833,15 @@ pub async fn invite_helper<'a>(
             is_direct: Some(is_direct),
             membership: MembershipState::Invite,
             third_party_invite: None,
-                blurhash: None,
-                reason: 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(
+        let auth_events =
-                room_id,
+            db.rooms
-                &kind,
+                .get_auth_events(room_id, &kind, &sender_user, Some(&state_key), &content)?;
-                &sender_user,
-                Some(&state_key),
-                &content,
-            )?;
 
         // Our depth is the maximum depth of prev_events + 1
         let depth = prev_events
@@ -930,8 +889,8 @@ pub async fn invite_helper<'a>(
             &room_version,
             &Arc::new(pdu.clone()),
             create_prev_event,
+            &auth_events,
             None, // TODO: third_party_invite
-                |k, s| auth_events.get(&(k.clone(), s.to_owned())).map(Arc::clone),
         )
         .map_err(|e| {
             error!("{:?}", e);
@@ -966,13 +925,9 @@ pub async fn invite_helper<'a>(
         )
         .expect("event is valid, we just created it");
 
+        drop(mutex_lock);
+
         let invite_room_state = db.rooms.calculate_invite_state(&pdu)?;
-
-            drop(state_lock);
-
-            (room_version_id, pdu_json, invite_room_state)
-        };
-
         let response = db
             .sending
             .send_federation_request(
@@ -981,7 +936,7 @@ pub async fn invite_helper<'a>(
                 create_invite::v2::Request {
                     room_id: room_id.clone(),
                     event_id: ruma::event_id!("$receivingservershouldsetthis"),
-                    room_version: room_version_id,
+                    room_version: RoomVersionId::Version6,
                     event: PduEvent::convert_to_outgoing_federation_event(pdu_json),
                     invite_room_state,
                 },
@@ -1044,16 +999,6 @@ pub async fn invite_helper<'a>(
         return Ok(());
     }
 
-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(room_id.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
     db.rooms.build_and_append_pdu(
         PduBuilder {
             event_type: EventType::RoomMember,
@@ -1063,8 +1008,6 @@ pub async fn invite_helper<'a>(
                 avatar_url: db.users.avatar_url(&user_id)?,
                 is_direct: Some(is_direct),
                 third_party_invite: None,
-                blurhash: db.users.blurhash(&user_id)?,
-                reason: None,
             })
             .expect("event is valid, we just created it"),
             unsigned: None,
@@ -1074,10 +1017,8 @@ pub async fn invite_helper<'a>(
         &sender_user,
         room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    drop(state_lock);
-
     Ok(())
 }

src/client_server/message.rs

@@ -28,15 +28,15 @@ pub async fn send_message_event_route(
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
     let sender_device = body.sender_device.as_deref();
 
-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
         db.globals
-            .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(body.room_id.clone())
             .or_default(),
     );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
     // Check if this is a new transaction id
     if let Some(response) =
@@ -75,7 +75,7 @@ pub async fn send_message_event_route(
         &sender_user,
         &body.room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
     db.transaction_ids.add_txnid(
@@ -85,9 +85,9 @@ pub async fn send_message_event_route(
         event_id.as_bytes(),
     )?;
 
-    drop(state_lock);
+    drop(mutex_lock);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(send_message_event::Response::new(event_id).into())
 }
@@ -128,7 +128,7 @@ pub async fn get_message_events_route(
         get_message_events::Direction::Forward => {
             let events_after = db
                 .rooms
-                .pdus_after(&sender_user, &body.room_id, from)?
+                .pdus_after(&sender_user, &body.room_id, from)
                 .take(limit)
                 .filter_map(|r| r.ok()) // Filter out buggy events
                 .filter_map(|(pdu_id, pdu)| {
@@ -158,7 +158,7 @@ pub async fn get_message_events_route(
         get_message_events::Direction::Backward => {
             let events_before = db
                 .rooms
-                .pdus_until(&sender_user, &body.room_id, from)?
+                .pdus_until(&sender_user, &body.room_id, from)
                 .take(limit)
                 .filter_map(|r| r.ok()) // Filter out buggy events
                 .filter_map(|(pdu_id, pdu)| {

src/client_server/mod.rs

@@ -75,5 +75,5 @@ pub const SESSION_ID_LENGTH: usize = 256;
 #[options("/<_..>")]
 #[tracing::instrument]
 pub async fn options_route() -> ConduitResult<send_event_to_device::Response> {
-    Ok(send_event_to_device::Response {}.into())
+    Ok(send_event_to_device::Response.into())
 }

src/client_server/presence.rs

@@ -41,9 +41,9 @@ pub async fn set_presence_route(
         )?;
     }
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_presence::Response {}.into())
+    Ok(set_presence::Response.into())
 }
 
 #[cfg_attr(

src/client_server/profile.rs

@@ -1,14 +1,11 @@
 use crate::{database::DatabaseGuard, pdu::PduBuilder, utils, ConduitResult, Error, Ruma};
 use ruma::{
-    api::{
+    api::client::{
-        client::{
         error::ErrorKind,
         r0::profile::{
             get_avatar_url, get_display_name, get_profile, set_avatar_url, set_display_name,
         },
     },
-        federation::{self, query::get_profile_information::v1::ProfileField},
-    },
     events::EventType,
     serde::Raw,
 };
@@ -32,10 +29,9 @@ pub async fn set_displayname_route(
         .set_displayname(&sender_user, body.displayname.clone())?;
 
     // Send a new membership event and presence update into all joined rooms
-    let all_rooms_joined = db.rooms.rooms_joined(&sender_user).collect::<Vec<_>>();
+    for (pdu_builder, room_id) in db
-
+        .rooms
-    for (pdu_builder, room_id) in all_rooms_joined
+        .rooms_joined(&sender_user)
-        .into_iter()
         .filter_map(|r| r.ok())
         .map(|room_id| {
             Ok::<_, Error>((
@@ -73,19 +69,19 @@ pub async fn set_displayname_route(
         })
         .filter_map(|r| r.ok())
     {
-        let mutex_state = Arc::clone(
+        let mutex = Arc::clone(
             db.globals
-                .roomid_mutex_state
+                .roomid_mutex
                 .write()
                 .unwrap()
                 .entry(room_id.clone())
                 .or_default(),
         );
-        let state_lock = mutex_state.lock().await;
+        let mutex_lock = mutex.lock().await;
 
         let _ =
             db.rooms
-                .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock);
+                .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &mutex_lock);
 
         // Presence update
         db.rooms.edus.update_presence(
@@ -110,9 +106,9 @@ pub async fn set_displayname_route(
         )?;
     }
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_display_name::Response {}.into())
+    Ok(set_display_name::Response.into())
 }
 
 #[cfg_attr(
@@ -124,25 +120,6 @@ pub async fn get_displayname_route(
     db: DatabaseGuard,
     body: Ruma<get_display_name::Request<'_>>,
 ) -> ConduitResult<get_display_name::Response> {
-    if body.user_id.server_name() != db.globals.server_name() {
-        let response = db
-            .sending
-            .send_federation_request(
-                &db.globals,
-                body.user_id.server_name(),
-                federation::query::get_profile_information::v1::Request {
-                    user_id: &body.user_id,
-                    field: Some(&ProfileField::DisplayName),
-                },
-            )
-            .await?;
-
-        return Ok(get_display_name::Response {
-            displayname: response.displayname,
-        }
-        .into());
-    }
-
     Ok(get_display_name::Response {
         displayname: db.users.displayname(&body.user_id)?,
     }
@@ -163,13 +140,10 @@ pub async fn set_avatar_url_route(
     db.users
         .set_avatar_url(&sender_user, body.avatar_url.clone())?;
 
-    db.users.set_blurhash(&sender_user, body.blurhash.clone())?;
-
     // Send a new membership event and presence update into all joined rooms
-    let all_joined_rooms = db.rooms.rooms_joined(&sender_user).collect::<Vec<_>>();
+    for (pdu_builder, room_id) in db
-
+        .rooms
-    for (pdu_builder, room_id) in all_joined_rooms
+        .rooms_joined(&sender_user)
-        .into_iter()
         .filter_map(|r| r.ok())
         .map(|room_id| {
             Ok::<_, Error>((
@@ -207,19 +181,19 @@ pub async fn set_avatar_url_route(
         })
         .filter_map(|r| r.ok())
     {
-        let mutex_state = Arc::clone(
+        let mutex = Arc::clone(
             db.globals
-                .roomid_mutex_state
+                .roomid_mutex
                 .write()
                 .unwrap()
                 .entry(room_id.clone())
                 .or_default(),
         );
-        let state_lock = mutex_state.lock().await;
+        let mutex_lock = mutex.lock().await;
 
         let _ =
             db.rooms
-                .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock);
+                .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &mutex_lock);
 
         // Presence update
         db.rooms.edus.update_presence(
@@ -244,9 +218,9 @@ pub async fn set_avatar_url_route(
         )?;
     }
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_avatar_url::Response {}.into())
+    Ok(set_avatar_url::Response.into())
 }
 
 #[cfg_attr(
@@ -258,29 +232,8 @@ pub async fn get_avatar_url_route(
     db: DatabaseGuard,
     body: Ruma<get_avatar_url::Request<'_>>,
 ) -> ConduitResult<get_avatar_url::Response> {
-    if body.user_id.server_name() != db.globals.server_name() {
-        let response = db
-            .sending
-            .send_federation_request(
-                &db.globals,
-                body.user_id.server_name(),
-                federation::query::get_profile_information::v1::Request {
-                    user_id: &body.user_id,
-                    field: Some(&ProfileField::AvatarUrl),
-                },
-            )
-            .await?;
-
-        return Ok(get_avatar_url::Response {
-            avatar_url: response.avatar_url,
-            blurhash: response.blurhash,
-        }
-        .into());
-    }
-
     Ok(get_avatar_url::Response {
         avatar_url: db.users.avatar_url(&body.user_id)?,
-        blurhash: db.users.blurhash(&body.user_id)?,
     }
     .into())
 }
@@ -294,27 +247,6 @@ pub async fn get_profile_route(
     db: DatabaseGuard,
     body: Ruma<get_profile::Request<'_>>,
 ) -> ConduitResult<get_profile::Response> {
-    if body.user_id.server_name() != db.globals.server_name() {
-        let response = db
-            .sending
-            .send_federation_request(
-                &db.globals,
-                body.user_id.server_name(),
-                federation::query::get_profile_information::v1::Request {
-                    user_id: &body.user_id,
-                    field: None,
-                },
-            )
-            .await?;
-
-        return Ok(get_profile::Response {
-            displayname: response.displayname,
-            avatar_url: response.avatar_url,
-            blurhash: response.blurhash,
-        }
-        .into());
-    }
-
     if !db.users.exists(&body.user_id)? {
         // Return 404 if this user doesn't exist
         return Err(Error::BadRequest(
@@ -325,7 +257,6 @@ pub async fn get_profile_route(
 
     Ok(get_profile::Response {
         avatar_url: db.users.avatar_url(&body.user_id)?,
-        blurhash: db.users.blurhash(&body.user_id)?,
         displayname: db.users.displayname(&body.user_id)?,
     }
     .into())

src/client_server/push.rs

@@ -81,7 +81,7 @@ pub async fn get_pushrule_route(
             .content
             .get(body.rule_id.as_str())
             .map(|rule| rule.clone().into()),
-        _ => None,
+        RuleKind::_Custom(_) => None,
     };
 
     if let Some(rule) = rule {
@@ -181,7 +181,7 @@ pub async fn set_pushrule_route(
                 .into(),
             );
         }
-        _ => {}
+        RuleKind::_Custom(_) => {}
     }
 
     db.account_data.update(
@@ -192,9 +192,9 @@ pub async fn set_pushrule_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_pushrule::Response {}.into())
+    Ok(set_pushrule::Response.into())
 }
 
 #[cfg_attr(
@@ -245,10 +245,10 @@ pub async fn get_pushrule_actions_route(
             .content
             .get(body.rule_id.as_str())
             .map(|rule| rule.actions.clone()),
-        _ => None,
+        RuleKind::_Custom(_) => None,
     };
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(get_pushrule_actions::Response {
         actions: actions.unwrap_or_default(),
@@ -314,7 +314,7 @@ pub async fn set_pushrule_actions_route(
                 global.content.replace(rule);
             }
         }
-        _ => {}
+        RuleKind::_Custom(_) => {}
     };
 
     db.account_data.update(
@@ -325,9 +325,9 @@ pub async fn set_pushrule_actions_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_pushrule_actions::Response {}.into())
+    Ok(set_pushrule_actions::Response.into())
 }
 
 #[cfg_attr(
@@ -383,10 +383,10 @@ pub async fn get_pushrule_enabled_route(
             .iter()
             .find(|rule| rule.rule_id == body.rule_id)
             .map_or(false, |rule| rule.enabled),
-        _ => false,
+        RuleKind::_Custom(_) => false,
     };
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(get_pushrule_enabled::Response { enabled }.into())
 }
@@ -454,7 +454,7 @@ pub async fn set_pushrule_enabled_route(
                 global.content.insert(rule);
             }
         }
-        _ => {}
+        RuleKind::_Custom(_) => {}
     }
 
     db.account_data.update(
@@ -465,9 +465,9 @@ pub async fn set_pushrule_enabled_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_pushrule_enabled::Response {}.into())
+    Ok(set_pushrule_enabled::Response.into())
 }
 
 #[cfg_attr(
@@ -523,7 +523,7 @@ pub async fn delete_pushrule_route(
                 global.content.remove(&rule);
             }
         }
-        _ => {}
+        RuleKind::_Custom(_) => {}
     }
 
     db.account_data.update(
@@ -534,9 +534,9 @@ pub async fn delete_pushrule_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(delete_pushrule::Response {}.into())
+    Ok(delete_pushrule::Response.into())
 }
 
 #[cfg_attr(
@@ -570,7 +570,7 @@ pub async fn set_pushers_route(
 
     db.pusher.set_pusher(sender_user, pusher)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(set_pusher::Response::default().into())
 }

src/client_server/read_marker.rs

@@ -75,9 +75,9 @@ pub async fn set_read_marker_route(
         )?;
     }
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(set_read_marker::Response {}.into())
+    Ok(set_read_marker::Response.into())
 }
 
 #[cfg_attr(
@@ -128,7 +128,7 @@ pub async fn create_receipt_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(create_receipt::Response {}.into())
+    Ok(create_receipt::Response.into())
 }

src/client_server/redact.rs

@@ -20,15 +20,15 @@ pub async fn redact_event_route(
 ) -> ConduitResult<redact_event::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
         db.globals
-            .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(body.room_id.clone())
             .or_default(),
     );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
     let event_id = db.rooms.build_and_append_pdu(
         PduBuilder {
@@ -44,12 +44,12 @@ pub async fn redact_event_route(
         &sender_user,
         &body.room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    drop(state_lock);
+    drop(mutex_lock);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(redact_event::Response { event_id }.into())
 }

src/client_server/room.rs

@@ -2,10 +2,11 @@ use crate::{
     client_server::invite_helper, database::DatabaseGuard, pdu::PduBuilder, ConduitResult, Error,
     Ruma,
 };
+use log::info;
 use ruma::{
     api::client::{
         error::ErrorKind,
-        r0::room::{self, aliases, create_room, get_room_event, upgrade_room},
+        r0::room::{self, create_room, get_room_event, upgrade_room},
     },
     events::{
         room::{guest_access, history_visibility, join_rules, member, name, topic},
@@ -15,7 +16,6 @@ use ruma::{
     RoomAliasId, RoomId, RoomVersionId,
 };
 use std::{cmp::max, collections::BTreeMap, convert::TryFrom, sync::Arc};
-use tracing::{info, warn};
 
 #[cfg(feature = "conduit_bin")]
 use rocket::{get, post};
@@ -33,20 +33,18 @@ pub async fn create_room_route(
 
     let room_id = RoomId::new(db.globals.server_name());
 
-    db.rooms.get_or_create_shortroomid(&room_id, &db.globals)?;
+    let mutex = Arc::clone(
-
-    let mutex_state = Arc::clone(
         db.globals
-            .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(room_id.clone())
             .or_default(),
     );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
-    let alias: Option<RoomAliasId> =
+    let alias = body
-        body.room_alias_name
+        .room_alias_name
         .as_ref()
         .map_or(Ok(None), |localpart| {
             // TODO: Check for invalid characters and maximum length
@@ -67,19 +65,7 @@ pub async fn create_room_route(
     let mut content = ruma::events::room::create::CreateEventContent::new(sender_user.clone());
     content.federate = body.creation_content.federate;
     content.predecessor = body.creation_content.predecessor.clone();
-    content.room_version = match body.room_version.clone() {
+    content.room_version = RoomVersionId::Version6;
-        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(
@@ -93,7 +79,7 @@ pub async fn create_room_route(
         &sender_user,
         &room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
     // 2. Let the room creator join
@@ -106,8 +92,6 @@ pub async fn create_room_route(
                 avatar_url: db.users.avatar_url(&sender_user)?,
                 is_direct: Some(body.is_direct),
                 third_party_invite: None,
-                blurhash: db.users.blurhash(&sender_user)?,
-                reason: None,
             })
             .expect("event is valid, we just created it"),
             unsigned: None,
@@ -117,7 +101,7 @@ pub async fn create_room_route(
         &sender_user,
         &room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
     // 3. Power levels
@@ -129,7 +113,7 @@ pub async fn create_room_route(
         .unwrap_or_else(|| match &body.visibility {
             room::Visibility::Private => create_room::RoomPreset::PrivateChat,
             room::Visibility::Public => create_room::RoomPreset::PublicChat,
-            _ => create_room::RoomPreset::PrivateChat, // Room visibility should not be custom
+            room::Visibility::_Custom(_) => create_room::RoomPreset::PrivateChat, // Room visibility should not be custom
         });
 
     let mut users = BTreeMap::new();
@@ -172,35 +156,12 @@ pub async fn create_room_route(
         &sender_user,
         &room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    // 4. Canonical room alias
+    // 4. Events set by preset
-    if let Some(room_alias_id) = &alias {
-        db.rooms.build_and_append_pdu(
-            PduBuilder {
-                event_type: EventType::RoomCanonicalAlias,
-                content: serde_json::to_value(
-                    ruma::events::room::canonical_alias::CanonicalAliasEventContent {
-                        alias: Some(room_alias_id.clone()),
-                        alt_aliases: vec![],
-                    },
-                )
-                .expect("We checked that alias earlier, it must be fine"),
-                unsigned: None,
-                state_key: Some("".to_owned()),
-                redacts: None,
-            },
-            &sender_user,
-            &room_id,
-            &db,
-            &state_lock,
-        )?;
-    }
 
-    // 5. Events set by preset
+    // 4.1 Join Rules
-
-    // 5.1 Join Rules
     db.rooms.build_and_append_pdu(
         PduBuilder {
             event_type: EventType::RoomJoinRules,
@@ -222,10 +183,10 @@ pub async fn create_room_route(
         &sender_user,
         &room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    // 5.2 History Visibility
+    // 4.2 History Visibility
     db.rooms.build_and_append_pdu(
         PduBuilder {
             event_type: EventType::RoomHistoryVisibility,
@@ -240,10 +201,10 @@ pub async fn create_room_route(
         &sender_user,
         &room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    // 5.3 Guest Access
+    // 4.3 Guest Access
     db.rooms.build_and_append_pdu(
         PduBuilder {
             event_type: EventType::RoomGuestAccess,
@@ -266,15 +227,15 @@ pub async fn create_room_route(
         &sender_user,
         &room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    // 6. Events listed in initial_state
+    // 5. Events listed in initial_state
     for event in &body.initial_state {
-        let pdu_builder = PduBuilder::from(event.deserialize().map_err(|e| {
+        let pdu_builder = serde_json::from_str::<PduBuilder>(
-            warn!("Invalid initial state event: {:?}", e);
+            &serde_json::to_string(&event).expect("AnyInitialStateEvent::to_string always works"),
-            Error::BadRequest(ErrorKind::InvalidParam, "Invalid initial state event.")
+        )
-        })?);
+        .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid initial state event."))?;
 
         // Silently skip encryption events if they are not allowed
         if pdu_builder.event_type == EventType::RoomEncryption && !db.globals.allow_encryption() {
@@ -282,15 +243,19 @@ pub async fn create_room_route(
         }
 
         db.rooms
-            .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &state_lock)?;
+            .build_and_append_pdu(pdu_builder, &sender_user, &room_id, &db, &mutex_lock)?;
     }
 
-    // 7. Events implied by name and topic
+    // 6. Events implied by name and topic
     if let Some(name) = &body.name {
         db.rooms.build_and_append_pdu(
             PduBuilder {
                 event_type: EventType::RoomName,
-                content: serde_json::to_value(name::NameEventContent::new(Some(name.clone())))
+                content: serde_json::to_value(
+                    name::NameEventContent::new(name.clone()).map_err(|_| {
+                        Error::BadRequest(ErrorKind::InvalidParam, "Name is invalid.")
+                    })?,
+                )
                 .expect("event is valid, we just created it"),
                 unsigned: None,
                 state_key: Some("".to_owned()),
@@ -299,7 +264,7 @@ pub async fn create_room_route(
             &sender_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
     }
 
@@ -318,12 +283,12 @@ pub async fn create_room_route(
             &sender_user,
             &room_id,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
     }
 
-    // 8. Events implied by invite (and TODO: invite_3pid)
+    // 7. Events implied by invite (and TODO: invite_3pid)
-    drop(state_lock);
+    drop(mutex_lock);
     for user_id in &body.invite {
         let _ = invite_helper(sender_user, user_id, &room_id, &db, body.is_direct).await;
     }
@@ -339,7 +304,7 @@ pub async fn create_room_route(
 
     info!("{} created a room", sender_user);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(create_room::Response::new(room_id).into())
 }
@@ -374,47 +339,17 @@ pub async fn get_room_event_route(
 
 #[cfg_attr(
     feature = "conduit_bin",
-    get("/_matrix/client/r0/rooms/<_>/aliases", data = "<body>")
+    post("/_matrix/client/r0/rooms/<_room_id>/upgrade", 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: 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!(
+    if !matches!(body.new_version, RoomVersionId::Version6) {
-        body.new_version,
-        RoomVersionId::Version5 | RoomVersionId::Version6
-    ) {
         return Err(Error::BadRequest(
             ErrorKind::UnsupportedRoomVersion,
             "This server does not support that room version.",
@@ -423,18 +358,16 @@ pub async fn upgrade_room_route(
 
     // Create a replacement room
     let replacement_room = RoomId::new(db.globals.server_name());
-    db.rooms
-        .get_or_create_shortroomid(&replacement_room, &db.globals)?;
 
-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
         db.globals
-            .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(body.room_id.clone())
             .or_default(),
     );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
     // Send a m.room.tombstone event to the old room to indicate that it is not intended to be used any further
     // Fail if the sender does not have the required permissions
@@ -453,21 +386,9 @@ pub async fn upgrade_room_route(
         sender_user,
         &body.room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    // Change lock to replacement room
-    drop(state_lock);
-    let mutex_state = Arc::clone(
-        db.globals
-            .roomid_mutex_state
-            .write()
-            .unwrap()
-            .entry(replacement_room.clone())
-            .or_default(),
-    );
-    let state_lock = mutex_state.lock().await;
-
     // Get the old room federations status
     let federate = serde_json::from_value::<Raw<ruma::events::room::create::CreateEventContent>>(
         db.rooms
@@ -506,7 +427,7 @@ pub async fn upgrade_room_route(
         sender_user,
         &replacement_room,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
     // Join the new room
@@ -519,8 +440,6 @@ pub async fn upgrade_room_route(
                 avatar_url: db.users.avatar_url(&sender_user)?,
                 is_direct: None,
                 third_party_invite: None,
-                blurhash: db.users.blurhash(&sender_user)?,
-                reason: None,
             })
             .expect("event is valid, we just created it"),
             unsigned: None,
@@ -530,7 +449,7 @@ pub async fn upgrade_room_route(
         sender_user,
         &replacement_room,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
     // Recommended transferable state events list from the specs
@@ -564,7 +483,7 @@ pub async fn upgrade_room_route(
             sender_user,
             &replacement_room,
             &db,
-            &state_lock,
+            &mutex_lock,
         )?;
     }
 
@@ -608,12 +527,12 @@ pub async fn upgrade_room_route(
         sender_user,
         &body.room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
-    drop(state_lock);
+    drop(mutex_lock);
 
-    db.flush()?;
+    db.flush().await?;
 
     // Return the replacement room id
     Ok(upgrade_room::Response { replacement_room }.into())

src/client_server/session.rs

@@ -1,17 +1,14 @@
 use super::{DEVICE_ID_LENGTH, TOKEN_LENGTH};
 use crate::{database::DatabaseGuard, utils, ConduitResult, Error, Ruma};
+use log::info;
 use ruma::{
     api::client::{
         error::ErrorKind,
-        r0::{
+        r0::session::{get_login_types, login, logout, logout_all},
-            session::{get_login_types, login, logout, logout_all},
-            uiaa::IncomingUserIdentifier,
-        },
     },
     UserId,
 };
 use serde::Deserialize;
-use tracing::info;
 
 #[derive(Debug, Deserialize)]
 struct Claims {
@@ -63,7 +60,7 @@ pub async fn login_route(
             identifier,
             password,
         } => {
-            let username = if let IncomingUserIdentifier::MatrixId(matrix_id) = identifier {
+            let username = if let login::IncomingUserIdentifier::MatrixId(matrix_id) = identifier {
                 matrix_id
             } else {
                 return Err(Error::BadRequest(ErrorKind::Forbidden, "Bad login type."));
@@ -146,7 +143,7 @@ pub async fn login_route(
 
     info!("{} logged in", user_id);
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(login::Response {
         user_id,
@@ -178,7 +175,7 @@ pub async fn logout_route(
 
     db.users.remove_device(&sender_user, sender_device)?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(logout::Response::new().into())
 }
@@ -207,7 +204,7 @@ pub async fn logout_all_route(
         db.users.remove_device(&sender_user, &device_id)?;
     }
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(logout_all::Response::new().into())
 }

src/client_server/state.rs

@@ -43,7 +43,7 @@ pub async fn send_state_event_for_key_route(
     )
     .await?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(send_state_event::Response { event_id }.into())
 }
@@ -69,7 +69,7 @@ pub async fn send_state_event_for_empty_key_route(
     )
     .await?;
 
-    db.flush()?;
+    db.flush().await?;
 
     Ok(send_state_event::Response { event_id }.into())
 }
@@ -259,15 +259,15 @@ pub async fn send_state_event_for_key_helper(
         }
     }
 
-    let mutex_state = Arc::clone(
+    let mutex = Arc::clone(
         db.globals
-            .roomid_mutex_state
+            .roomid_mutex
             .write()
             .unwrap()
             .entry(room_id.clone())
             .or_default(),
     );
-    let state_lock = mutex_state.lock().await;
+    let mutex_lock = mutex.lock().await;
 
     let event_id = db.rooms.build_and_append_pdu(
         PduBuilder {
@@ -280,7 +280,7 @@ pub async fn send_state_event_for_key_helper(
         &sender_user,
         &room_id,
         &db,
-        &state_lock,
+        &mutex_lock,
     )?;
 
     Ok(event_id)

src/client_server/sync.rs

@@ -1,4 +1,5 @@
 use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Result, Ruma, RumaResponse};
+use log::error;
 use ruma::{
     api::client::r0::{sync::sync_events, uiaa::UiaaResponse},
     events::{room::member::MembershipState, AnySyncEphemeralRoomEvent, EventType},
@@ -6,13 +7,12 @@ use ruma::{
     DeviceId, RoomId, UserId,
 };
 use std::{
-    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
+    collections::{btree_map::Entry, hash_map, BTreeMap, HashMap, HashSet},
     convert::{TryFrom, TryInto},
     sync::Arc,
     time::Duration,
 };
 use tokio::sync::watch::Sender;
-use tracing::error;
 
 #[cfg(feature = "conduit_bin")]
 use rocket::{get, tokio};
@@ -186,26 +186,24 @@ async fn sync_helper(
             .filter_map(|r| r.ok()),
     );
 
-    let all_joined_rooms = db.rooms.rooms_joined(&sender_user).collect::<Vec<_>>();
+    for room_id in db.rooms.rooms_joined(&sender_user) {
-    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 = Arc::clone(
-        let mutex_insert = Arc::clone(
             db.globals
-                .roomid_mutex_insert
+                .roomid_mutex
                 .write()
                 .unwrap()
                 .entry(room_id.clone())
                 .or_default(),
         );
-        let insert_lock = mutex_insert.lock().unwrap();
+        let mutex_lock = mutex.lock().await;
-        drop(insert_lock);
+        drop(mutex_lock);
 
         let mut non_timeline_pdus = db
             .rooms
-            .pdus_until(&sender_user, &room_id, u64::MAX)?
+            .pdus_until(&sender_user, &room_id, u64::MAX)
             .filter_map(|r| {
                 // Filter out buggy events
                 if r.is_err() {
@@ -246,18 +244,32 @@ async fn sync_helper(
             .current_shortstatehash(&room_id)?
             .expect("All rooms have state");
 
+        let first_pdu_before_since = db
+            .rooms
+            .pdus_until(&sender_user, &room_id, since)
+            .next()
+            .transpose()?;
+
         let pdus_after_since = db
             .rooms
-            .pdus_after(&sender_user, &room_id, since)?
+            .pdus_after(&sender_user, &room_id, since)
             .next()
             .is_some();
 
-        let since_shortstatehash = db.rooms.get_token_shortstatehash(&room_id, since)?;
+        let since_shortstatehash = first_pdu_before_since
+            .as_ref()
+            .map(|pdu| {
+                db.rooms
+                    .pdu_shortstatehash(&pdu.1.event_id)
+                    .transpose()
+                    .expect("all pdus have state")
+            })
+            .transpose()?;
 
         // Calculates joined_member_count, invited_member_count and heroes
         let calculate_counts = || {
-            let joined_member_count = db.rooms.room_joined_count(&room_id)?.unwrap_or(0);
+            let joined_member_count = db.rooms.room_members(&room_id).count();
-            let invited_member_count = db.rooms.room_invited_count(&room_id)?.unwrap_or(0);
+            let invited_member_count = db.rooms.room_members_invited(&room_id).count();
 
             // Recalculate heroes (first 5 members)
             let mut heroes = Vec::new();
@@ -268,7 +280,7 @@ async fn sync_helper(
 
                 for hero in db
                     .rooms
-                    .all_pdus(&sender_user, &room_id)?
+                    .all_pdus(&sender_user, &room_id)
                     .filter_map(|pdu| pdu.ok()) // Ignore all broken pdus
                     .filter(|(_, pdu)| pdu.kind == EventType::RoomMember)
                     .map(|(_, pdu)| {
@@ -310,11 +322,11 @@ async fn sync_helper(
                 }
             }
 
-            Ok::<_, Error>((
+            (
                 Some(joined_member_count),
                 Some(invited_member_count),
                 heroes,
-            ))
+            )
         };
 
         let (
@@ -325,12 +337,12 @@ async fn sync_helper(
             state_events,
         ) = if since_shortstatehash.is_none() {
             // Probably since = 0, we will do an initial sync
-            let (joined_member_count, invited_member_count, heroes) = calculate_counts()?;
+            let (joined_member_count, invited_member_count, heroes) = calculate_counts();
 
             let current_state_ids = db.rooms.state_full_ids(current_shortstatehash)?;
             let state_events = current_state_ids
                 .iter()
-                .map(|(_, id)| db.rooms.get_pdu(id))
+                .map(|id| db.rooms.get_pdu(id))
                 .filter_map(|r| r.ok().flatten())
                 .collect::<Vec<_>>();
 
@@ -341,7 +353,7 @@ async fn sync_helper(
                 true,
                 state_events,
             )
-        } else if !pdus_after_since && since_shortstatehash == Some(current_shortstatehash) {
+        } else if !pdus_after_since || since_shortstatehash == Some(current_shortstatehash) {
             // No state changes
             (Vec::new(), None, None, false, Vec::new())
         } else {
@@ -375,14 +387,18 @@ async fn sync_helper(
             let state_events = if joined_since_last_sync {
                 current_state_ids
                     .iter()
-                    .map(|(_, id)| db.rooms.get_pdu(id))
+                    .map(|id| db.rooms.get_pdu(id))
                     .filter_map(|r| r.ok().flatten())
                     .collect::<Vec<_>>()
             } else {
                 current_state_ids
+                    .difference(&since_state_ids)
+                    .filter(|id| {
+                        !timeline_pdus
                             .iter()
-                    .filter(|(key, id)| since_state_ids.get(key) != Some(id))
+                            .any(|(_, timeline_pdu)| timeline_pdu.event_id == **id)
-                    .map(|(_, id)| db.rooms.get_pdu(id))
+                    })
+                    .map(|id| db.rooms.get_pdu(id))
                     .filter_map(|r| r.ok().flatten())
                     .collect()
             };
@@ -401,41 +417,63 @@ async fn sync_helper(
 
             let send_member_count = state_events
                 .iter()
-                .any(|event| event.kind == EventType::RoomMember)
+                .any(|event| event.kind == EventType::RoomMember);
-                || timeline_pdus.iter().any(|(_, event)| {
-                    event.state_key.is_some() && event.kind == EventType::RoomMember
-                });
 
             if encrypted_room {
-                for state_event in &state_events {
+                for (user_id, current_member) in db
-                    if state_event.kind != EventType::RoomMember {
+                    .rooms
-                        continue;
+                    .room_members(&room_id)
-                    }
+                    .filter_map(|r| r.ok())
-
+                    .filter_map(|user_id| {
-                    if let Some(state_key) = &state_event.state_key {
+                        db.rooms
-                        let user_id = UserId::try_from(state_key.clone())
+                            .state_get(
-                            .map_err(|_| Error::bad_database("Invalid UserId in member PDU."))?;
+                                current_shortstatehash,
-
+                                &EventType::RoomMember,
-                        if user_id == sender_user {
+                                user_id.as_str(),
-                            continue;
+                            )
-                        }
+                            .ok()
-
+                            .flatten()
-                        let new_membership = serde_json::from_value::<
+                            .map(|current_member| (user_id, current_member))
+                    })
+                {
+                    let current_membership = serde_json::from_value::<
                         Raw<ruma::events::room::member::MemberEventContent>,
-                        >(state_event.content.clone())
+                    >(current_member.content.clone())
                     .expect("Raw::from_value always works")
                     .deserialize()
                     .map_err(|_| Error::bad_database("Invalid PDU in database."))?
                     .membership;
 
-                        match new_membership {
+                    let since_membership = db
-                            MembershipState::Join => {
+                        .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."))?;
+
+                    match (since_membership, current_membership) {
+                        (MembershipState::Leave, MembershipState::Join) => {
                             // A new user joined an encrypted room
                             if !share_encrypted_room(&db, &sender_user, &user_id, &room_id)? {
                                 device_list_updates.insert(user_id);
                             }
                         }
-                            MembershipState::Leave => {
+                        // TODO: Remove, this should never happen here, right?
+                        (MembershipState::Join, MembershipState::Leave) => {
                             // Write down users that have left encrypted rooms we are in
                             left_encrypted_users.insert(user_id);
                         }
@@ -443,7 +481,6 @@ async fn sync_helper(
                     }
                 }
             }
-            }
 
             if joined_since_last_sync && encrypted_room || new_encrypted_room {
                 // If the user is in a new encrypted room, give them all joined users
@@ -464,7 +501,7 @@ async fn sync_helper(
             }
 
             let (joined_member_count, invited_member_count, heroes) = if send_member_count {
-                calculate_counts()?
+                calculate_counts()
             } else {
                 (None, None, Vec::new())
             };
@@ -538,10 +575,6 @@ async fn sync_helper(
             );
         }
 
-        // Save the state after this sync so we can send the correct state diff next sync
-        db.rooms
-            .associate_token_shortstatehash(&room_id, next_batch, current_shortstatehash)?;
-
         let joined_room = sync_events::JoinedRoom {
             account_data: sync_events::RoomAccountData {
                 events: db
@@ -589,10 +622,10 @@ async fn sync_helper(
                 .presence_since(&room_id, since, &db.rooms, &db.globals)?
         {
             match presence_updates.entry(user_id) {
-                Entry::Vacant(v) => {
+                hash_map::Entry::Vacant(v) => {
                     v.insert(presence);
                 }
-                Entry::Occupied(mut o) => {
+                hash_map::Entry::Occupied(mut o) => {
                     let p = o.get_mut();
 
                     // Update existing presence event with more info
@@ -618,21 +651,20 @@ async fn sync_helper(
     }
 
     let mut left_rooms = BTreeMap::new();
-    let all_left_rooms = db.rooms.rooms_left(&sender_user).collect::<Vec<_>>();
+    for result in db.rooms.rooms_left(&sender_user) {
-    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(
+        let mutex = Arc::clone(
             db.globals
-                .roomid_mutex_insert
+                .roomid_mutex
                 .write()
                 .unwrap()
                 .entry(room_id.clone())
                 .or_default(),
         );
-        let insert_lock = mutex_insert.lock().unwrap();
+        let mutex_lock = mutex.lock().await;
-        drop(insert_lock);
+        drop(mutex_lock);
 
         let left_count = db.rooms.get_left_count(&room_id, &sender_user)?;
 
@@ -658,21 +690,20 @@ async fn sync_helper(
     }
 
     let mut invited_rooms = BTreeMap::new();
-    let all_invited_rooms = db.rooms.rooms_invited(&sender_user).collect::<Vec<_>>();
+    for result in db.rooms.rooms_invited(&sender_user) {
-    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(
+        let mutex = Arc::clone(
             db.globals
-                .roomid_mutex_insert
+                .roomid_mutex
                 .write()
                 .unwrap()
                 .entry(room_id.clone())
                 .or_default(),
         );
-        let insert_lock = mutex_insert.lock().unwrap();
+        let mutex_lock = mutex.lock().await;
-        drop(insert_lock);
+        drop(mutex_lock);
 
         let invite_count = db.rooms.get_invite_count(&room_id, &sender_user)?;
 
@@ -722,7 +753,6 @@ async fn sync_helper(
             leave: left_rooms,
             join: joined_rooms,
             invite: invited_rooms,
-            knock: BTreeMap::new(), // TODO
         },
         presence: sync_events::Presence {
             events: presence_updates

src/client_server/tag.rs

@@ -40,9 +40,9 @@ pub async fn update_tag_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(create_tag::Response {}.into())
+    Ok(create_tag::Response.into())
 }
 
 #[cfg_attr(
@@ -74,9 +74,9 @@ pub async fn delete_tag_route(
         &db.globals,
     )?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(delete_tag::Response {}.into())
+    Ok(delete_tag::Response.into())
 }
 
 #[cfg_attr(

src/client_server/to_device.rs

@@ -1,12 +1,6 @@
-use std::collections::BTreeMap;
-
 use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
 use ruma::{
-    api::{
+    api::client::{error::ErrorKind, r0::to_device::send_event_to_device},
-        client::{error::ErrorKind, r0::to_device::send_event_to_device},
-        federation::{self, transactions::edu::DirectDeviceContent},
-    },
-    events::EventType,
     to_device::DeviceIdOrAllDevices,
 };
 
@@ -39,29 +33,6 @@ pub async fn send_event_to_device_route(
 
     for (target_user_id, map) in &body.messages {
         for (target_device_id_maybe, event) in map {
-            if target_user_id.server_name() != db.globals.server_name() {
-                let mut map = BTreeMap::new();
-                map.insert(target_device_id_maybe.clone(), event.clone());
-                let mut messages = BTreeMap::new();
-                messages.insert(target_user_id.clone(), map);
-
-                db.sending.send_reliable_edu(
-                    target_user_id.server_name(),
-                    serde_json::to_vec(&federation::transactions::edu::Edu::DirectToDevice(
-                        DirectDeviceContent {
-                            sender: sender_user.clone(),
-                            ev_type: EventType::from(&body.event_type),
-                            message_id: body.txn_id.clone(),
-                            messages,
-                        },
-                    ))
-                    .expect("DirectToDevice EDU can be serialized"),
-                    db.globals.next_count()?,
-                )?;
-
-                continue;
-            }
-
             match target_device_id_maybe {
                 DeviceIdOrAllDevices::DeviceId(target_device_id) => db.users.add_to_device_event(
                     sender_user,
@@ -96,7 +67,7 @@ pub async fn send_event_to_device_route(
     db.transaction_ids
         .add_txnid(sender_user, sender_device, &body.txn_id, &[])?;
 
-    db.flush()?;
+    db.flush().await?;
 
-    Ok(send_event_to_device::Response {}.into())
+    Ok(send_event_to_device::Response.into())
 }

src/client_server/typing.rs

@@ -29,5 +29,5 @@ pub fn create_typing_event_route(
             .typing_remove(&sender_user, &body.room_id, &db.globals)?;
     }
 
-    Ok(create_typing_event::Response {}.into())
+    Ok(create_typing_event::Response.into())
 }

src/client_server/user_directory.rs

@@ -25,22 +25,20 @@ pub async fn search_users_route(
             avatar_url: db.users.avatar_url(&user_id).ok()?,
         };
 
-        let user_id_matches = user
+        if !user
             .user_id
             .to_string()
             .to_lowercase()
-            .contains(&body.search_term.to_lowercase());
+            .contains(&body.search_term.to_lowercase())
-
+            && user
-        let user_displayname_matches = user
                 .display_name
                 .as_ref()
                 .filter(|name| {
                     name.to_lowercase()
                         .contains(&body.search_term.to_lowercase())
                 })
-            .is_some();
+                .is_none()
-
+        {
-        if !user_id_matches && !user_displayname_matches {
             return None;
         }
 

src/database.rs

@@ -17,27 +17,24 @@ pub mod users;
 use crate::{utils, Error, Result};
 use abstraction::DatabaseEngine;
 use directories::ProjectDirs;
+use log::error;
 use lru_cache::LruCache;
 use rocket::{
     futures::{channel::mpsc, stream::FuturesUnordered, StreamExt},
-    outcome::{try_outcome, IntoOutcome},
+    outcome::IntoOutcome,
     request::{FromRequest, Request},
-    Shutdown, State,
+    try_outcome, State,
 };
-use ruma::{DeviceId, EventId, RoomId, ServerName, UserId};
+use ruma::{DeviceId, ServerName, UserId};
 use serde::{de::IgnoredAny, Deserialize};
 use std::{
-    collections::{BTreeMap, HashMap, HashSet},
+    collections::{BTreeMap, HashMap},
-    convert::{TryFrom, TryInto},
     fs::{self, remove_dir_all},
     io::Write,
-    mem::size_of,
     ops::Deref,
-    path::Path,
+    sync::{Arc, RwLock},
-    sync::{Arc, Mutex, RwLock},
 };
 use tokio::sync::{OwnedRwLockReadGuard, RwLock as TokioRwLock, Semaphore};
-use tracing::{debug, error, warn};
 
 use self::proxy::ProxyConfig;
 
@@ -45,10 +42,16 @@ use self::proxy::ProxyConfig;
 pub struct Config {
     server_name: Box<ServerName>,
     database_path: String,
-    #[serde(default = "default_db_cache_capacity_mb")]
+    #[serde(default = "default_db_cache_capacity")]
-    db_cache_capacity_mb: f64,
+    db_cache_capacity: u32,
+    #[serde(default = "default_sqlite_read_pool_size")]
+    sqlite_read_pool_size: usize,
+    #[serde(default = "false_fn")]
+    sqlite_wal_clean_timer: bool,
     #[serde(default = "default_sqlite_wal_clean_second_interval")]
     sqlite_wal_clean_second_interval: u32,
+    #[serde(default = "default_sqlite_wal_clean_second_timeout")]
+    sqlite_wal_clean_second_timeout: u32,
     #[serde(default = "default_max_request_size")]
     max_request_size: u32,
     #[serde(default = "default_max_concurrent_requests")]
@@ -61,8 +64,6 @@ pub struct Config {
     allow_federation: bool,
     #[serde(default = "false_fn")]
     pub allow_jaeger: bool,
-    #[serde(default = "false_fn")]
-    pub tracing_flame: bool,
     #[serde(default)]
     proxy: ProxyConfig,
     jwt_secret: Option<String>,
@@ -85,12 +86,12 @@ impl Config {
             .keys()
             .filter(|key| DEPRECATED_KEYS.iter().any(|s| s == key))
         {
-            warn!("Config parameter {} is deprecated", key);
+            log::warn!("Config parameter {} is deprecated", key);
             was_deprecated = true;
         }
 
         if was_deprecated {
-            warn!("Read conduit documentation and check your configuration if any new configuration parameters should be adjusted");
+            log::warn!("Read conduit documentation and check your configuration if any new configuration parameters should be adjusted");
         }
     }
 }
@@ -103,12 +104,20 @@ fn true_fn() -> bool {
     true
 }
 
-fn default_db_cache_capacity_mb() -> f64 {
+fn default_db_cache_capacity() -> u32 {
-    200.0
+    1024 * 1024 * 1024
+}
+
+fn default_sqlite_read_pool_size() -> usize {
+    num_cpus::get().max(1)
 }
 
 fn default_sqlite_wal_clean_second_interval() -> u32 {
-    1 * 60 // every minute
+    60
+}
+
+fn default_sqlite_wal_clean_second_timeout() -> u32 {
+    2
 }
 
 fn default_max_request_size() -> u32 {
@@ -126,12 +135,12 @@ fn default_log() -> String {
 #[cfg(feature = "sled")]
 pub type Engine = abstraction::sled::Engine;
 
+#[cfg(feature = "rocksdb")]
+pub type Engine = abstraction::rocksdb::Engine;
+
 #[cfg(feature = "sqlite")]
 pub type Engine = abstraction::sqlite::Engine;
 
-#[cfg(feature = "heed")]
-pub type Engine = abstraction::heed::Engine;
-
 pub struct Database {
     _db: Arc<Engine>,
     pub globals: globals::Globals,
@@ -161,37 +170,8 @@ impl Database {
         Ok(())
     }
 
-    fn check_sled_or_sqlite_db(config: &Config) -> Result<()> {
-        #[cfg(feature = "backend_sqlite")]
-        {
-            let path = Path::new(&config.database_path);
-
-            let sled_exists = path.join("db").exists();
-            let sqlite_exists = path.join("conduit.db").exists();
-            if sled_exists {
-                if sqlite_exists {
-                    // most likely an in-place directory, only warn
-                    warn!("Both sled and sqlite databases are detected in database directory");
-                    warn!("Currently running from the sqlite database, but consider removing sled database files to free up space")
-                } else {
-                    error!(
-                        "Sled database detected, conduit now uses sqlite for database operations"
-                    );
-                    error!("This database must be converted to sqlite, go to https://github.com/ShadowJonathan/conduit_toolbox#conduit_sled_to_sqlite");
-                    return Err(Error::bad_config(
-                        "sled database detected, migrate to sqlite",
-                    ));
-                }
-            }
-        }
-
-        Ok(())
-    }
-
     /// Load an existing database or create a new one.
-    pub async fn load_or_create(config: &Config) -> Result<Arc<TokioRwLock<Self>>> {
+    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 {
@@ -207,7 +187,6 @@ impl Database {
                 userid_password: builder.open_tree("userid_password")?,
                 userid_displayname: builder.open_tree("userid_displayname")?,
                 userid_avatarurl: builder.open_tree("userid_avatarurl")?,
-                userid_blurhash: builder.open_tree("userid_blurhash")?,
                 userdeviceid_token: builder.open_tree("userdeviceid_token")?,
                 userdeviceid_metadata: builder.open_tree("userdeviceid_metadata")?,
                 userid_devicelistversion: builder.open_tree("userid_devicelistversion")?,
@@ -251,8 +230,6 @@ impl Database {
                 serverroomids: builder.open_tree("serverroomids")?,
                 userroomid_joined: builder.open_tree("userroomid_joined")?,
                 roomuserid_joined: builder.open_tree("roomuserid_joined")?,
-                roomid_joinedcount: builder.open_tree("roomid_joinedcount")?,
-                roomid_invitedcount: builder.open_tree("roomid_invitedcount")?,
                 roomuseroncejoinedids: builder.open_tree("roomuseroncejoinedids")?,
                 userroomid_invitestate: builder.open_tree("userroomid_invitestate")?,
                 roomuserid_invitecount: builder.open_tree("roomuserid_invitecount")?,
@@ -263,36 +240,19 @@ impl Database {
                 userroomid_highlightcount: builder.open_tree("userroomid_highlightcount")?,
 
                 statekey_shortstatekey: builder.open_tree("statekey_shortstatekey")?,
-                shortstatekey_statekey: builder.open_tree("shortstatekey_statekey")?,
+                stateid_shorteventid: builder.open_tree("stateid_shorteventid")?,
-
-                shorteventid_authchain: builder.open_tree("shorteventid_authchain")?,
-
-                roomid_shortroomid: builder.open_tree("roomid_shortroomid")?,
-
-                shortstatehash_statediff: builder.open_tree("shortstatehash_statediff")?,
                 eventid_shorteventid: builder.open_tree("eventid_shorteventid")?,
                 shorteventid_eventid: builder.open_tree("shorteventid_eventid")?,
                 shorteventid_shortstatehash: builder.open_tree("shorteventid_shortstatehash")?,
                 roomid_shortstatehash: builder.open_tree("roomid_shortstatehash")?,
-                roomsynctoken_shortstatehash: builder.open_tree("roomsynctoken_shortstatehash")?,
                 statehash_shortstatehash: builder.open_tree("statehash_shortstatehash")?,
 
                 eventid_outlierpdu: builder.open_tree("eventid_outlierpdu")?,
-                softfailedeventids: builder.open_tree("softfailedeventids")?,
+                prevevent_parent: builder.open_tree("prevevent_parent")?,
-
+                pdu_cache: RwLock::new(LruCache::new(10_000)),
-                referencedevents: builder.open_tree("referencedevents")?,
-                pdu_cache: Mutex::new(LruCache::new(100_000)),
-                auth_chain_cache: Mutex::new(LruCache::new(1_000_000)),
-                shorteventid_cache: Mutex::new(LruCache::new(1_000_000)),
-                eventidshort_cache: Mutex::new(LruCache::new(1_000_000)),
-                shortstatekey_cache: Mutex::new(LruCache::new(1_000_000)),
-                statekeyshort_cache: Mutex::new(LruCache::new(1_000_000)),
-                stateinfo_cache: Mutex::new(LruCache::new(1000)),
-                our_real_users_cache: RwLock::new(HashMap::new()),
             },
             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")?,
@@ -307,8 +267,8 @@ impl Database {
             },
             sending: sending::Sending {
                 servername_educount: builder.open_tree("servername_educount")?,
-                servernameevent_data: builder.open_tree("servernameevent_data")?,
+                servernamepduids: builder.open_tree("servernamepduids")?,
-                servercurrentevent_data: builder.open_tree("servercurrentevent_data")?,
+                servercurrentevents: builder.open_tree("servercurrentevents")?,
                 maximum_requests: Arc::new(Semaphore::new(config.max_concurrent_requests as usize)),
                 sender: sending_sender,
             },
@@ -378,7 +338,7 @@ impl Database {
             if db.globals.database_version()? < 3 {
                 // Move media to filesystem
                 for (key, content) in db.media.mediaid_file.iter() {
-                    if content.is_empty() {
+                    if content.len() == 0 {
                         continue;
                     }
 
@@ -415,317 +375,6 @@ impl Database {
 
                 println!("Migration: 3 -> 4 finished");
             }
-
-            if db.globals.database_version()? < 5 {
-                // Upgrade user data store
-                for (roomuserdataid, _) in db.account_data.roomuserdataid_accountdata.iter() {
-                    let mut parts = roomuserdataid.split(|&b| b == 0xff);
-                    let room_id = parts.next().unwrap();
-                    let user_id = parts.next().unwrap();
-                    let event_type = roomuserdataid.rsplit(|&b| b == 0xff).next().unwrap();
-
-                    let mut key = room_id.to_vec();
-                    key.push(0xff);
-                    key.extend_from_slice(user_id);
-                    key.push(0xff);
-                    key.extend_from_slice(event_type);
-
-                    db.account_data
-                        .roomusertype_roomuserdataid
-                        .insert(&key, &roomuserdataid)?;
-                }
-
-                db.globals.bump_database_version(5)?;
-
-                println!("Migration: 4 -> 5 finished");
-            }
-
-            if db.globals.database_version()? < 6 {
-                // 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)?;
-                }
-
-                db.globals.bump_database_version(6)?;
-
-                println!("Migration: 5 -> 6 finished");
-            }
-
-            if db.globals.database_version()? < 7 {
-                // Upgrade state store
-                let mut last_roomstates: HashMap<RoomId, u64> = HashMap::new();
-                let mut current_sstatehash: Option<u64> = None;
-                let mut current_room = None;
-                let mut current_state = HashSet::new();
-                let mut counter = 0;
-
-                let mut handle_state =
-                    |current_sstatehash: u64,
-                     current_room: &RoomId,
-                     current_state: HashSet<_>,
-                     last_roomstates: &mut HashMap<_, _>| {
-                        counter += 1;
-                        println!("counter: {}", counter);
-                        let last_roomsstatehash = last_roomstates.get(current_room);
-
-                        let states_parents = last_roomsstatehash.map_or_else(
-                            || Ok(Vec::new()),
-                            |&last_roomsstatehash| {
-                                db.rooms.load_shortstatehash_info(dbg!(last_roomsstatehash))
-                            },
-                        )?;
-
-                        let (statediffnew, statediffremoved) =
-                            if let Some(parent_stateinfo) = states_parents.last() {
-                                let statediffnew = current_state
-                                    .difference(&parent_stateinfo.1)
-                                    .cloned()
-                                    .collect::<HashSet<_>>();
-
-                                let statediffremoved = parent_stateinfo
-                                    .1
-                                    .difference(&current_state)
-                                    .cloned()
-                                    .collect::<HashSet<_>>();
-
-                                (statediffnew, statediffremoved)
-                            } else {
-                                (current_state, HashSet::new())
-                            };
-
-                        db.rooms.save_state_from_diff(
-                            dbg!(current_sstatehash),
-                            statediffnew,
-                            statediffremoved,
-                            2, // every state change is 2 event changes on average
-                            states_parents,
-                        )?;
-
-                        /*
-                        let mut tmp = db.rooms.load_shortstatehash_info(&current_sstatehash, &db)?;
-                        let state = tmp.pop().unwrap();
-                        println!(
-                            "{}\t{}{:?}: {:?} + {:?} - {:?}",
-                            current_room,
-                            "  ".repeat(tmp.len()),
-                            utils::u64_from_bytes(&current_sstatehash).unwrap(),
-                            tmp.last().map(|b| utils::u64_from_bytes(&b.0).unwrap()),
-                            state
-                                .2
-                                .iter()
-                                .map(|b| utils::u64_from_bytes(&b[size_of::<u64>()..]).unwrap())
-                                .collect::<Vec<_>>(),
-                            state
-                                .3
-                                .iter()
-                                .map(|b| utils::u64_from_bytes(&b[size_of::<u64>()..]).unwrap())
-                                .collect::<Vec<_>>()
-                        );
-                        */
-
-                        Ok::<_, Error>(())
-                    };
-
-                for (k, seventid) in db._db.open_tree("stateid_shorteventid")?.iter() {
-                    let sstatehash = utils::u64_from_bytes(&k[0..size_of::<u64>()])
-                        .expect("number of bytes is correct");
-                    let sstatekey = k[size_of::<u64>()..].to_vec();
-                    if Some(sstatehash) != current_sstatehash {
-                        if let Some(current_sstatehash) = current_sstatehash {
-                            handle_state(
-                                current_sstatehash,
-                                current_room.as_ref().unwrap(),
-                                current_state,
-                                &mut last_roomstates,
-                            )?;
-                            last_roomstates
-                                .insert(current_room.clone().unwrap(), current_sstatehash);
-                        }
-                        current_state = HashSet::new();
-                        current_sstatehash = Some(sstatehash);
-
-                        let event_id = db
-                            .rooms
-                            .shorteventid_eventid
-                            .get(&seventid)
-                            .unwrap()
-                            .unwrap();
-                        let event_id =
-                            EventId::try_from(utils::string_from_bytes(&event_id).unwrap())
-                                .unwrap();
-                        let pdu = db.rooms.get_pdu(&event_id).unwrap().unwrap();
-
-                        if Some(&pdu.room_id) != current_room.as_ref() {
-                            current_room = Some(pdu.room_id.clone());
-                        }
-                    }
-
-                    let mut val = sstatekey;
-                    val.extend_from_slice(&seventid);
-                    current_state.insert(val.try_into().expect("size is correct"));
-                }
-
-                if let Some(current_sstatehash) = current_sstatehash {
-                    handle_state(
-                        current_sstatehash,
-                        current_room.as_ref().unwrap(),
-                        current_state,
-                        &mut last_roomstates,
-                    )?;
-                }
-
-                db.globals.bump_database_version(7)?;
-
-                println!("Migration: 6 -> 7 finished");
-            }
-
-            if db.globals.database_version()? < 8 {
-                // Generate short room ids for all rooms
-                for (room_id, _) in db.rooms.roomid_shortstatehash.iter() {
-                    let shortroomid = db.globals.next_count()?.to_be_bytes();
-                    db.rooms.roomid_shortroomid.insert(&room_id, &shortroomid)?;
-                    println!("Migration: 8");
-                }
-                // Update pduids db layout
-                let mut batch = db.rooms.pduid_pdu.iter().filter_map(|(key, v)| {
-                    if !key.starts_with(b"!") {
-                        return None;
-                    }
-                    let mut parts = key.splitn(2, |&b| b == 0xff);
-                    let room_id = parts.next().unwrap();
-                    let count = parts.next().unwrap();
-
-                    let short_room_id = db
-                        .rooms
-                        .roomid_shortroomid
-                        .get(&room_id)
-                        .unwrap()
-                        .expect("shortroomid should exist");
-
-                    let mut new_key = short_room_id;
-                    new_key.extend_from_slice(count);
-
-                    Some((new_key, v))
-                });
-
-                db.rooms.pduid_pdu.insert_batch(&mut batch)?;
-
-                let mut batch2 = db.rooms.eventid_pduid.iter().filter_map(|(k, value)| {
-                    if !value.starts_with(b"!") {
-                        return None;
-                    }
-                    let mut parts = value.splitn(2, |&b| b == 0xff);
-                    let room_id = parts.next().unwrap();
-                    let count = parts.next().unwrap();
-
-                    let short_room_id = db
-                        .rooms
-                        .roomid_shortroomid
-                        .get(&room_id)
-                        .unwrap()
-                        .expect("shortroomid should exist");
-
-                    let mut new_value = short_room_id;
-                    new_value.extend_from_slice(count);
-
-                    Some((k, new_value))
-                });
-
-                db.rooms.eventid_pduid.insert_batch(&mut batch2)?;
-
-                db.globals.bump_database_version(8)?;
-
-                println!("Migration: 7 -> 8 finished");
-            }
-
-            if db.globals.database_version()? < 9 {
-                // Update tokenids db layout
-                let batch = db
-                    .rooms
-                    .tokenids
-                    .iter()
-                    .filter_map(|(key, _)| {
-                        if !key.starts_with(b"!") {
-                            return None;
-                        }
-                        let mut parts = key.splitn(4, |&b| b == 0xff);
-                        let room_id = parts.next().unwrap();
-                        let word = parts.next().unwrap();
-                        let _pdu_id_room = parts.next().unwrap();
-                        let pdu_id_count = parts.next().unwrap();
-
-                        let short_room_id = db
-                            .rooms
-                            .roomid_shortroomid
-                            .get(&room_id)
-                            .unwrap()
-                            .expect("shortroomid should exist");
-                        let mut new_key = short_room_id;
-                        new_key.extend_from_slice(word);
-                        new_key.push(0xff);
-                        new_key.extend_from_slice(pdu_id_count);
-                        println!("old {:?}", key);
-                        println!("new {:?}", new_key);
-                        Some((new_key, Vec::new()))
-                    })
-                    .collect::<Vec<_>>();
-
-                let mut iter = batch.into_iter().peekable();
-
-                while iter.peek().is_some() {
-                    db.rooms
-                        .tokenids
-                        .insert_batch(&mut iter.by_ref().take(1000))?;
-                    println!("smaller batch done");
-                }
-
-                println!("Deleting starts");
-
-                let batch2 = db
-                    .rooms
-                    .tokenids
-                    .iter()
-                    .filter_map(|(key, _)| {
-                        if key.starts_with(b"!") {
-                            println!("del {:?}", key);
-                            Some(key)
-                        } else {
-                            None
-                        }
-                    })
-                    .collect::<Vec<_>>();
-
-                for key in batch2 {
-                    println!("del");
-                    db.rooms.tokenids.remove(&key)?;
-                }
-
-                db.globals.bump_database_version(9)?;
-
-                println!("Migration: 8 -> 9 finished");
-            }
-
-            if db.globals.database_version()? < 10 {
-                // Add other direction for shortstatekeys
-                for (statekey, shortstatekey) in db.rooms.statekey_shortstatekey.iter() {
-                    db.rooms
-                        .shortstatekey_statekey
-                        .insert(&shortstatekey, &statekey)?;
-                }
-
-                // Force E2EE device list updates so we can send them over federation
-                for user_id in db.users.iter().filter_map(|r| r.ok()) {
-                    db.users
-                        .mark_device_key_update(&user_id, &db.rooms, &db.globals)?;
-                }
-
-                db.globals.bump_database_version(10)?;
-
-                println!("Migration: 9 -> 10 finished");
-            }
         }
 
         let guard = db.read().await;
@@ -741,26 +390,11 @@ impl Database {
         drop(guard);
 
         #[cfg(feature = "sqlite")]
-        {
+        Self::start_wal_clean_task(&db, &config).await;
-            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();
@@ -787,16 +421,6 @@ impl Database {
                 .watch_prefix(&userid_prefix),
         );
         futures.push(self.rooms.userroomid_leftstate.watch_prefix(&userid_prefix));
-        futures.push(
-            self.rooms
-                .userroomid_notificationcount
-                .watch_prefix(&userid_prefix),
-        );
-        futures.push(
-            self.rooms
-                .userroomid_highlightcount
-                .watch_prefix(&userid_prefix),
-        );
 
         // Events for rooms we are in
         for room_id in self.rooms.rooms_joined(user_id).filter_map(|r| r.ok()) {
@@ -831,7 +455,7 @@ impl Database {
 
             futures.push(
                 self.account_data
-                    .roomusertype_roomuserdataid
+                    .roomuserdataid_accountdata
                     .watch_prefix(&roomuser_prefix),
             );
         }
@@ -841,7 +465,7 @@ impl Database {
 
         futures.push(
             self.account_data
-                .roomusertype_roomuserdataid
+                .roomuserdataid_accountdata
                 .watch_prefix(&globaluserdata_prefix),
         );
 
@@ -861,62 +485,78 @@ impl Database {
         futures.next().await;
     }
 
-    #[tracing::instrument(skip(self))]
+    pub async fn flush(&self) -> Result<()> {
-    pub fn flush(&self) -> Result<()> {
         let start = std::time::Instant::now();
 
         let res = self._db.flush();
 
-        debug!("flush: took {:?}", start.elapsed());
+        log::debug!("flush: took {:?}", start.elapsed());
 
         res
     }
 
     #[cfg(feature = "sqlite")]
-    #[tracing::instrument(skip(self))]
     pub fn flush_wal(&self) -> Result<()> {
         self._db.flush_wal()
     }
 
     #[cfg(feature = "sqlite")]
-    #[tracing::instrument(skip(db, config))]
+    pub async fn start_wal_clean_task(lock: &Arc<TokioRwLock<Self>>, config: &Config) {
-    pub async fn start_wal_clean_task(db: Arc<TokioRwLock<Self>>, config: &Config) {
+        use tokio::{
-        use tokio::time::interval;
+            select,
+            signal::unix::{signal, SignalKind},
+            time::{interval, timeout},
+        };
 
-        #[cfg(unix)]
+        use std::{
-        use tokio::signal::unix::{signal, SignalKind};
+            sync::Weak,
-        use tracing::info;
+            time::{Duration, Instant},
+        };
 
-        use std::time::{Duration, Instant};
+        let weak: Weak<TokioRwLock<Database>> = Arc::downgrade(&lock);
 
+        let lock_timeout = Duration::from_secs(config.sqlite_wal_clean_second_timeout as u64);
         let timer_interval = Duration::from_secs(config.sqlite_wal_clean_second_interval as u64);
+        let do_timer = config.sqlite_wal_clean_timer;
 
         tokio::spawn(async move {
             let mut i = interval(timer_interval);
-            #[cfg(unix)]
             let mut s = signal(SignalKind::hangup()).unwrap();
 
             loop {
-                #[cfg(unix)]
+                select! {
-                tokio::select! {
+                    _ = i.tick(), if do_timer => {
-                    _ = i.tick() => {
+                        log::info!(target: "wal-trunc", "Timer ticked")
-                        info!("wal-trunc: Timer ticked");
                     }
                     _ = s.recv() => {
-                        info!("wal-trunc: Received SIGHUP");
+                        log::info!(target: "wal-trunc", "Received SIGHUP")
                     }
                 };
-                #[cfg(not(unix))]
-                {
-                    i.tick().await;
-                    info!("wal-trunc: Timer ticked")
-                }
 
-                let start = Instant::now();
+                if let Some(arc) = Weak::upgrade(&weak) {
-                if let Err(e) = db.read().await.flush_wal() {
+                    log::info!(target: "wal-trunc", "Rotating sync helpers...");
-                    error!("wal-trunc: Errored: {}", e);
+                    // This actually creates a very small race condition between firing this and trying to acquire the subsequent write lock.
+                    // Though it is not a huge deal if the write lock doesn't "catch", as it'll harmlessly time out.
+                    arc.read().await.globals.rotate.fire();
+
+                    log::info!(target: "wal-trunc", "Locking...");
+                    let guard = {
+                        if let Ok(guard) = timeout(lock_timeout, arc.write()).await {
+                            guard
                         } else {
-                    info!("wal-trunc: Flushed in {:?}", start.elapsed());
+                            log::info!(target: "wal-trunc", "Lock failed in timeout, canceled.");
+                            continue;
+                        }
+                    };
+                    log::info!(target: "wal-trunc", "Locked, flushing...");
+                    let start = Instant::now();
+                    if let Err(e) = guard.flush_wal() {
+                        log::error!(target: "wal-trunc", "Errored: {}", e);
+                    } else {
+                        log::info!(target: "wal-trunc", "Flushed in {:?}", start.elapsed());
+                    }
+                } else {
+                    break;
                 }
             }
         });
@@ -938,14 +578,14 @@ impl<'r> FromRequest<'r> for DatabaseGuard {
     type Error = ();
 
     async fn from_request(req: &'r Request<'_>) -> rocket::request::Outcome<Self, ()> {
-        let db = try_outcome!(req.guard::<&State<Arc<TokioRwLock<Database>>>>().await);
+        let db = try_outcome!(req.guard::<State<'_, Arc<TokioRwLock<Database>>>>().await);
 
         Ok(DatabaseGuard(Arc::clone(&db).read_owned().await)).or_forward(())
     }
 }
 
-impl From<OwnedRwLockReadGuard<Database>> for DatabaseGuard {
+impl Into<DatabaseGuard> for OwnedRwLockReadGuard<Database> {
-    fn from(val: OwnedRwLockReadGuard<Database>) -> Self {
+    fn into(self) -> DatabaseGuard {
-        Self(val)
+        DatabaseGuard(self)
     }
 }

src/database/abstraction.rs

@@ -3,15 +3,15 @@ use crate::Result;
 
 use std::{future::Future, pin::Pin, sync::Arc};
 
+#[cfg(feature = "rocksdb")]
+pub mod rocksdb;
+
 #[cfg(feature = "sled")]
 pub mod sled;
 
 #[cfg(feature = "sqlite")]
 pub mod sqlite;
 
-#[cfg(feature = "heed")]
-pub mod heed;
-
 pub trait DatabaseEngine: Sized {
     fn open(config: &Config) -> Result<Arc<Self>>;
     fn open_tree(self: &Arc<Self>, name: &'static str) -> Result<Arc<dyn Tree>>;
@@ -22,25 +22,23 @@ pub trait Tree: Send + Sync {
     fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>>;
 
     fn insert(&self, key: &[u8], value: &[u8]) -> Result<()>;
-    fn insert_batch<'a>(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()>;
 
     fn remove(&self, key: &[u8]) -> Result<()>;
 
-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a>;
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a>;
 
     fn iter_from<'a>(
         &'a self,
         from: &[u8],
         backwards: bool,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a>;
+    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a>;
 
     fn increment(&self, key: &[u8]) -> Result<Vec<u8>>;
-    fn increment_batch<'a>(&self, iter: &mut dyn Iterator<Item = Vec<u8>>) -> Result<()>;
 
     fn scan_prefix<'a>(
         &'a self,
         prefix: Vec<u8>,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a>;
+    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a>;
 
     fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>>;
 

src/database/abstraction/heed.rs

@@ -1,240 +0,0 @@
-use super::super::Config;
-use crossbeam::channel::{bounded, Sender as ChannelSender};
-use threadpool::ThreadPool;
-
-use crate::{Error, Result};
-use std::{
-    collections::HashMap,
-    future::Future,
-    pin::Pin,
-    sync::{Arc, Mutex, RwLock},
-};
-use tokio::sync::oneshot::Sender;
-
-use super::{DatabaseEngine, Tree};
-
-type TupleOfBytes = (Vec<u8>, Vec<u8>);
-
-pub struct Engine {
-    env: heed::Env,
-    iter_pool: Mutex<ThreadPool>,
-}
-
-pub struct EngineTree {
-    engine: Arc<Engine>,
-    tree: Arc<heed::UntypedDatabase>,
-    watchers: RwLock<HashMap<Vec<u8>, Vec<Sender<()>>>>,
-}
-
-fn convert_error(error: heed::Error) -> Error {
-    Error::HeedError {
-        error: error.to_string(),
-    }
-}
-
-impl DatabaseEngine for Engine {
-    fn open(config: &Config) -> Result<Arc<Self>> {
-        let mut env_builder = heed::EnvOpenOptions::new();
-        env_builder.map_size(1024 * 1024 * 1024 * 1024); // 1 Terabyte
-        env_builder.max_readers(126);
-        env_builder.max_dbs(128);
-        unsafe {
-            env_builder.flag(heed::flags::Flags::MdbWriteMap);
-            env_builder.flag(heed::flags::Flags::MdbMapAsync);
-        }
-
-        Ok(Arc::new(Engine {
-            env: env_builder
-                .open(&config.database_path)
-                .map_err(convert_error)?,
-            iter_pool: Mutex::new(ThreadPool::new(10)),
-        }))
-    }
-
-    fn open_tree(self: &Arc<Self>, name: &'static str) -> Result<Arc<dyn Tree>> {
-        // Creates the db if it doesn't exist already
-        Ok(Arc::new(EngineTree {
-            engine: Arc::clone(self),
-            tree: Arc::new(
-                self.env
-                    .create_database(Some(name))
-                    .map_err(convert_error)?,
-            ),
-            watchers: RwLock::new(HashMap::new()),
-        }))
-    }
-
-    fn flush(self: &Arc<Self>) -> Result<()> {
-        self.env.force_sync().map_err(convert_error)?;
-        Ok(())
-    }
-}
-
-impl EngineTree {
-    #[tracing::instrument(skip(self, tree, from, backwards))]
-    fn iter_from_thread(
-        &self,
-        tree: Arc<heed::UntypedDatabase>,
-        from: Vec<u8>,
-        backwards: bool,
-    ) -> Box<dyn Iterator<Item = TupleOfBytes> + Send + Sync> {
-        let (s, r) = bounded::<TupleOfBytes>(100);
-        let engine = Arc::clone(&self.engine);
-
-        let lock = self.engine.iter_pool.lock().await;
-        if lock.active_count() < lock.max_count() {
-            lock.execute(move || {
-                iter_from_thread_work(tree, &engine.env.read_txn().unwrap(), from, backwards, &s);
-            });
-        } else {
-            std::thread::spawn(move || {
-                iter_from_thread_work(tree, &engine.env.read_txn().unwrap(), from, backwards, &s);
-            });
-        }
-
-        Box::new(r.into_iter())
-    }
-}
-
-#[tracing::instrument(skip(tree, txn, from, backwards))]
-fn iter_from_thread_work(
-    tree: Arc<heed::UntypedDatabase>,
-    txn: &heed::RoTxn<'_>,
-    from: Vec<u8>,
-    backwards: bool,
-    s: &ChannelSender<(Vec<u8>, Vec<u8>)>,
-) {
-    if backwards {
-        for (k, v) in tree.rev_range(txn, ..=&*from).unwrap().map(|r| r.unwrap()) {
-            if s.send((k.to_vec(), v.to_vec())).is_err() {
-                return;
-            }
-        }
-    } else {
-        if from.is_empty() {
-            for (k, v) in tree.iter(txn).unwrap().map(|r| r.unwrap()) {
-                if s.send((k.to_vec(), v.to_vec())).is_err() {
-                    return;
-                }
-            }
-        } else {
-            for (k, v) in tree.range(txn, &*from..).unwrap().map(|r| r.unwrap()) {
-                if s.send((k.to_vec(), v.to_vec())).is_err() {
-                    return;
-                }
-            }
-        }
-    }
-}
-
-impl Tree for EngineTree {
-    #[tracing::instrument(skip(self, key))]
-    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
-        let txn = self.engine.env.read_txn().map_err(convert_error)?;
-        Ok(self
-            .tree
-            .get(&txn, &key)
-            .map_err(convert_error)?
-            .map(|s| s.to_vec()))
-    }
-
-    #[tracing::instrument(skip(self, key, value))]
-    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()> {
-        let mut txn = self.engine.env.write_txn().map_err(convert_error)?;
-        self.tree
-            .put(&mut txn, &key, &value)
-            .map_err(convert_error)?;
-        txn.commit().map_err(convert_error)?;
-
-        let watchers = self.watchers.read().unwrap();
-        let mut triggered = Vec::new();
-
-        for length in 0..=key.len() {
-            if watchers.contains_key(&key[..length]) {
-                triggered.push(&key[..length]);
-            }
-        }
-
-        drop(watchers);
-
-        if !triggered.is_empty() {
-            let mut watchers = self.watchers.write().unwrap();
-            for prefix in triggered {
-                if let Some(txs) = watchers.remove(prefix) {
-                    for tx in txs {
-                        let _ = tx.send(());
-                    }
-                }
-            }
-        };
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, key))]
-    fn remove(&self, key: &[u8]) -> Result<()> {
-        let mut txn = self.engine.env.write_txn().map_err(convert_error)?;
-        self.tree.delete(&mut txn, &key).map_err(convert_error)?;
-        txn.commit().map_err(convert_error)?;
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self))]
-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> {
-        self.iter_from(&[], false)
-    }
-
-    #[tracing::instrument(skip(self, from, backwards))]
-    fn iter_from(
-        &self,
-        from: &[u8],
-        backwards: bool,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send> {
-        self.iter_from_thread(Arc::clone(&self.tree), from.to_vec(), backwards)
-    }
-
-    #[tracing::instrument(skip(self, key))]
-    fn increment(&self, key: &[u8]) -> Result<Vec<u8>> {
-        let mut txn = self.engine.env.write_txn().map_err(convert_error)?;
-
-        let old = self.tree.get(&txn, &key).map_err(convert_error)?;
-        let new =
-            crate::utils::increment(old.as_deref()).expect("utils::increment always returns Some");
-
-        self.tree
-            .put(&mut txn, &key, &&*new)
-            .map_err(convert_error)?;
-
-        txn.commit().map_err(convert_error)?;
-
-        Ok(new)
-    }
-
-    #[tracing::instrument(skip(self, prefix))]
-    fn scan_prefix<'a>(
-        &'a self,
-        prefix: Vec<u8>,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> {
-        Box::new(
-            self.iter_from(&prefix, false)
-                .take_while(move |(key, _)| key.starts_with(&prefix)),
-        )
-    }
-
-    #[tracing::instrument(skip(self, prefix))]
-    fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
-        let (tx, rx) = tokio::sync::oneshot::channel();
-
-        self.watchers
-            .write()
-            .unwrap()
-            .entry(prefix.to_vec())
-            .or_default()
-            .push(tx);
-
-        Box::pin(async move {
-            // Tx is never destroyed
-            rx.await.unwrap();
-        })
-    }
-}

src/database/abstraction/rocksdb.rs

@@ -0,0 +1,176 @@
+use super::super::Config;
+use crate::{utils, Result};
+
+use std::{future::Future, pin::Pin, sync::Arc};
+
+use super::{DatabaseEngine, Tree};
+
+use std::{collections::BTreeMap, sync::RwLock};
+
+pub struct Engine(rocksdb::DBWithThreadMode<rocksdb::MultiThreaded>);
+
+pub struct RocksDbEngineTree<'a> {
+    db: Arc<Engine>,
+    name: &'a str,
+    watchers: RwLock<BTreeMap<Vec<u8>, Vec<tokio::sync::oneshot::Sender<()>>>>,
+}
+
+impl DatabaseEngine for Engine {
+    fn open(config: &Config) -> Result<Arc<Self>> {
+        let mut db_opts = rocksdb::Options::default();
+        db_opts.create_if_missing(true);
+        db_opts.set_max_open_files(16);
+        db_opts.set_compaction_style(rocksdb::DBCompactionStyle::Level);
+        db_opts.set_compression_type(rocksdb::DBCompressionType::Snappy);
+        db_opts.set_target_file_size_base(256 << 20);
+        db_opts.set_write_buffer_size(256 << 20);
+
+        let mut block_based_options = rocksdb::BlockBasedOptions::default();
+        block_based_options.set_block_size(512 << 10);
+        db_opts.set_block_based_table_factory(&block_based_options);
+
+        let cfs = rocksdb::DBWithThreadMode::<rocksdb::MultiThreaded>::list_cf(
+            &db_opts,
+            &config.database_path,
+        )
+        .unwrap_or_default();
+
+        let mut options = rocksdb::Options::default();
+        options.set_merge_operator_associative("increment", utils::increment_rocksdb);
+
+        let db = rocksdb::DBWithThreadMode::<rocksdb::MultiThreaded>::open_cf_descriptors(
+            &db_opts,
+            &config.database_path,
+            cfs.iter()
+                .map(|name| rocksdb::ColumnFamilyDescriptor::new(name, options.clone())),
+        )?;
+
+        Ok(Arc::new(Engine(db)))
+    }
+
+    fn open_tree(self: &Arc<Self>, name: &'static str) -> Result<Arc<dyn Tree>> {
+        let mut options = rocksdb::Options::default();
+        options.set_merge_operator_associative("increment", utils::increment_rocksdb);
+
+        // Create if it doesn't exist
+        let _ = self.0.create_cf(name, &options);
+
+        Ok(Arc::new(RocksDbEngineTree {
+            name,
+            db: Arc::clone(self),
+            watchers: RwLock::new(BTreeMap::new()),
+        }))
+    }
+}
+
+impl RocksDbEngineTree<'_> {
+    fn cf(&self) -> rocksdb::BoundColumnFamily<'_> {
+        self.db.0.cf_handle(self.name).unwrap()
+    }
+}
+
+impl Tree for RocksDbEngineTree<'_> {
+    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
+        Ok(self.db.0.get_cf(self.cf(), key)?)
+    }
+
+    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()> {
+        let watchers = self.watchers.read().unwrap();
+        let mut triggered = Vec::new();
+
+        for length in 0..=key.len() {
+            if watchers.contains_key(&key[..length]) {
+                triggered.push(&key[..length]);
+            }
+        }
+
+        drop(watchers);
+
+        if !triggered.is_empty() {
+            let mut watchers = self.watchers.write().unwrap();
+            for prefix in triggered {
+                if let Some(txs) = watchers.remove(prefix) {
+                    for tx in txs {
+                        let _ = tx.send(());
+                    }
+                }
+            }
+        }
+
+        Ok(self.db.0.put_cf(self.cf(), key, value)?)
+    }
+
+    fn remove(&self, key: &[u8]) -> Result<()> {
+        Ok(self.db.0.delete_cf(self.cf(), key)?)
+    }
+
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + Sync + 'a> {
+        Box::new(
+            self.db
+                .0
+                .iterator_cf(self.cf(), rocksdb::IteratorMode::Start),
+        )
+    }
+
+    fn iter_from<'a>(
+        &'a self,
+        from: &[u8],
+        backwards: bool,
+    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> {
+        Box::new(self.db.0.iterator_cf(
+            self.cf(),
+            rocksdb::IteratorMode::From(
+                from,
+                if backwards {
+                    rocksdb::Direction::Reverse
+                } else {
+                    rocksdb::Direction::Forward
+                },
+            ),
+        ))
+    }
+
+    fn increment(&self, key: &[u8]) -> Result<Vec<u8>> {
+        let stats = rocksdb::perf::get_memory_usage_stats(Some(&[&self.db.0]), None).unwrap();
+        dbg!(stats.mem_table_total);
+        dbg!(stats.mem_table_unflushed);
+        dbg!(stats.mem_table_readers_total);
+        dbg!(stats.cache_total);
+        // TODO: atomic?
+        let old = self.get(key)?;
+        let new = utils::increment(old.as_deref()).unwrap();
+        self.insert(key, &new)?;
+        Ok(new)
+    }
+
+    fn scan_prefix<'a>(
+        &'a self,
+        prefix: Vec<u8>,
+    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> {
+        Box::new(
+            self.db
+                .0
+                .iterator_cf(
+                    self.cf(),
+                    rocksdb::IteratorMode::From(&prefix, rocksdb::Direction::Forward),
+                )
+                .take_while(move |(k, _)| k.starts_with(&prefix)),
+        )
+    }
+
+    fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
+        let (tx, rx) = tokio::sync::oneshot::channel();
+
+        self.watchers
+            .write()
+            .unwrap()
+            .entry(prefix.to_vec())
+            .or_default()
+            .push(tx);
+
+        Box::pin(async move {
+            // Tx is never destroyed
+            rx.await.unwrap();
+        })
+    }
+}

src/database/abstraction/sled.rs

@@ -1,7 +1,7 @@
 use super::super::Config;
 use crate::{utils, Result};
+use log::warn;
 use std::{future::Future, pin::Pin, sync::Arc};
-use tracing::warn;
 
 use super::{DatabaseEngine, Tree};
 
@@ -14,7 +14,7 @@ impl DatabaseEngine for Engine {
         Ok(Arc::new(Engine(
             sled::Config::default()
                 .path(&config.database_path)
-                .cache_capacity((config.db_cache_capacity_mb * 1024.0 * 1024.0) as u64)
+                .cache_capacity(config.db_cache_capacity as u64)
                 .use_compression(true)
                 .open()?,
         )))
@@ -39,21 +39,12 @@ impl Tree for SledEngineTree {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, iter))]
-    fn insert_batch<'a>(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()> {
-        for (key, value) in iter {
-            self.0.insert(key, value)?;
-        }
-
-        Ok(())
-    }
-
     fn remove(&self, key: &[u8]) -> Result<()> {
         self.0.remove(key)?;
         Ok(())
     }
 
-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> {
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> {
         Box::new(
             self.0
                 .iter()
@@ -71,7 +62,7 @@ impl Tree for SledEngineTree {
         &self,
         from: &[u8],
         backwards: bool,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)>> {
+    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send> {
         let iter = if backwards {
             self.0.range(..=from)
         } else {
@@ -104,7 +95,7 @@ impl Tree for SledEngineTree {
     fn scan_prefix<'a>(
         &'a self,
         prefix: Vec<u8>,
-    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> {
+    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + Send + 'a> {
         let iter = self
             .0
             .scan_prefix(prefix)

src/database/abstraction/sqlite.rs

@@ -1,59 +1,94 @@
-use super::{DatabaseEngine, Tree};
-use crate::{database::Config, Result};
-use parking_lot::{Mutex, MutexGuard, RwLock};
-use rusqlite::{Connection, DatabaseName::Main, OptionalExtension};
 use std::{
-    cell::RefCell,
+    collections::BTreeMap,
-    collections::HashMap,
     future::Future,
+    ops::Deref,
     path::{Path, PathBuf},
     pin::Pin,
     sync::Arc,
+    thread,
+    time::{Duration, Instant},
 };
+
+use crate::{database::Config, Result};
+
+use super::{DatabaseEngine, Tree};
+
+use log::debug;
+
+use crossbeam::channel::{bounded, Sender as ChannelSender};
+use parking_lot::{Mutex, MutexGuard, RwLock};
+use rusqlite::{params, Connection, DatabaseName::Main, OptionalExtension};
+
 use tokio::sync::oneshot::Sender;
-use tracing::debug;
 
-thread_local! {
+// const SQL_CREATE_TABLE: &str =
-    static READ_CONNECTION: RefCell<Option<&'static Connection>> = RefCell::new(None);
+//     "CREATE TABLE IF NOT EXISTS {} {{ \"key\" BLOB PRIMARY KEY, \"value\" BLOB NOT NULL }}";
-    static READ_CONNECTION_ITERATOR: RefCell<Option<&'static Connection>> = RefCell::new(None);
+// const SQL_SELECT: &str = "SELECT value FROM {} WHERE key = ?";
-}
+// const SQL_INSERT: &str = "INSERT OR REPLACE INTO {} (key, value) VALUES (?, ?)";
+// const SQL_DELETE: &str = "DELETE FROM {} WHERE key = ?";
+// const SQL_SELECT_ITER: &str = "SELECT key, value FROM {}";
+// const SQL_SELECT_PREFIX: &str = "SELECT key, value FROM {} WHERE key LIKE ?||'%' ORDER BY key ASC";
+// const SQL_SELECT_ITER_FROM_FORWARDS: &str = "SELECT key, value FROM {} WHERE key >= ? ORDER BY ASC";
+// const SQL_SELECT_ITER_FROM_BACKWARDS: &str =
+//     "SELECT key, value FROM {} WHERE key <= ? ORDER BY DESC";
 
-struct PreparedStatementIterator<'a> {
+struct Pool {
-    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>,
-
+    readers: Vec<Mutex<Connection>>,
+    spill_tracker: Arc<()>,
     path: PathBuf,
-    cache_size_per_thread: u32,
 }
 
-impl Engine {
+pub const MILLI: Duration = Duration::from_millis(1);
-    fn prepare_conn(path: &Path, cache_size_kb: u32) -> Result<Connection> {
-        let conn = Connection::open(&path)?;
 
-        conn.pragma_update(Some(Main), "page_size", &2048)?;
+enum HoldingConn<'a> {
-        conn.pragma_update(Some(Main), "journal_mode", &"WAL")?;
+    FromGuard(MutexGuard<'a, Connection>),
-        conn.pragma_update(Some(Main), "synchronous", &"NORMAL")?;
+    FromOwned(Connection, Arc<()>),
-        conn.pragma_update(Some(Main), "cache_size", &(-i64::from(cache_size_kb)))?;
+}
-        conn.pragma_update(Some(Main), "wal_autocheckpoint", &2000)?;
+
+impl<'a> Deref for HoldingConn<'a> {
+    type Target = Connection;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            HoldingConn::FromGuard(guard) => guard.deref(),
+            HoldingConn::FromOwned(conn, _) => conn,
+        }
+    }
+}
+
+impl Pool {
+    fn new<P: AsRef<Path>>(path: P, num_readers: usize, cache_size: u32) -> Result<Self> {
+        let writer = Mutex::new(Self::prepare_conn(&path, Some(cache_size))?);
+
+        let mut readers = Vec::new();
+
+        for _ in 0..num_readers {
+            readers.push(Mutex::new(Self::prepare_conn(&path, Some(cache_size))?))
+        }
+
+        Ok(Self {
+            writer,
+            readers,
+            spill_tracker: Arc::new(()),
+            path: path.as_ref().to_path_buf(),
+        })
+    }
+
+    fn prepare_conn<P: AsRef<Path>>(path: P, cache_size: Option<u32>) -> Result<Connection> {
+        let conn = Connection::open(path)?;
+
+        conn.pragma_update(Some(Main), "journal_mode", &"WAL".to_owned())?;
+
+        // conn.pragma_update(Some(Main), "wal_autocheckpoint", &250)?;
+
+        // conn.pragma_update(Some(Main), "wal_checkpoint", &"FULL".to_owned())?;
+
+        conn.pragma_update(Some(Main), "synchronous", &"OFF".to_owned())?;
+
+        if let Some(cache_kib) = cache_size {
+            conn.pragma_update(Some(Main), "cache_size", &(-Into::<i64>::into(cache_kib)))?;
+        }
 
         Ok(conn)
     }
@@ -62,91 +97,102 @@ impl Engine {
         self.writer.lock()
     }
 
-    fn read_lock(&self) -> &'static Connection {
+    fn read_lock(&self) -> HoldingConn<'_> {
-        READ_CONNECTION.with(|cell| {
+        for r in &self.readers {
-            let connection = &mut cell.borrow_mut();
+            if let Some(reader) = r.try_lock() {
-
+                return HoldingConn::FromGuard(reader);
-            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()
+        let spill_arc = self.spill_tracker.clone();
-        })
+        let now_count = Arc::strong_count(&spill_arc) - 1 /* because one is held by the pool */;
+
+        log::warn!("read_lock: all readers locked, creating spillover reader...");
+
+        if now_count > 1 {
+            log::warn!("read_lock: now {} spillover readers exist", now_count);
         }
 
-    fn read_lock_iterator(&self) -> &'static Connection {
+        let spilled = Self::prepare_conn(&self.path, None).unwrap();
-        READ_CONNECTION_ITERATOR.with(|cell| {
-            let connection = &mut cell.borrow_mut();
 
-            if (*connection).is_none() {
+        return HoldingConn::FromOwned(spilled, spill_arc);
-                let c = Box::leak(Box::new(
+    }
-                    Self::prepare_conn(&self.path, self.cache_size_per_thread).unwrap(),
-                ));
-                **connection = Some(c);
 }
 
-            connection.unwrap()
+pub struct Engine {
-        })
+    pool: Pool,
-    }
-
-    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");
+        let pool = Pool::new(
+            Path::new(&config.database_path).join("conduit.db"),
+            config.sqlite_read_pool_size,
+            config.db_cache_capacity / 1024, // bytes -> kb
+        )?;
 
-        // calculates cache-size per permanent connection
+        pool.write_lock()
-        // 1. convert MB to KiB
+            .execute("CREATE TABLE IF NOT EXISTS _noop (\"key\" INT)", params![])?;
-        // 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 { pool });
-
-        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), [])?;
+        self.pool.write_lock().execute(format!("CREATE TABLE IF NOT EXISTS {} ( \"key\" BLOB PRIMARY KEY, \"value\" BLOB NOT NULL )", name).as_str(), [])?;
 
         Ok(Arc::new(SqliteTable {
             engine: Arc::clone(self),
             name: name.to_owned(),
-            watchers: RwLock::new(HashMap::new()),
+            watchers: RwLock::new(BTreeMap::new()),
         }))
     }
 
     fn flush(self: &Arc<Self>) -> Result<()> {
-        // we enabled PRAGMA synchronous=normal, so this should not be necessary
+        self.pool
-        Ok(())
+            .write_lock()
+            .execute_batch(
+                "
+            PRAGMA synchronous=FULL;
+            BEGIN;
+                DELETE FROM _noop;
+                INSERT INTO _noop VALUES (1);
+            COMMIT;
+            PRAGMA synchronous=OFF;
+            ",
+            )
+            .map_err(Into::into)
+    }
+}
+
+impl Engine {
+    pub fn flush_wal(self: &Arc<Self>) -> Result<()> {
+        self.pool
+            .write_lock()
+            .execute_batch(
+                "
+            PRAGMA synchronous=FULL; PRAGMA wal_checkpoint=TRUNCATE;
+            BEGIN;
+                DELETE FROM _noop;
+                INSERT INTO _noop VALUES (1);
+            COMMIT;
+            PRAGMA wal_checkpoint=PASSIVE; PRAGMA synchronous=OFF;
+            ",
+            )
+            .map_err(Into::into)
     }
 }
 
 pub struct SqliteTable {
     engine: Arc<Engine>,
     name: String,
-    watchers: RwLock<HashMap<Vec<u8>, Vec<Sender<()>>>>,
+    watchers: RwLock<BTreeMap<Vec<u8>, Vec<Sender<()>>>>,
 }
 
 type TupleOfBytes = (Vec<u8>, Vec<u8>);
 
 impl SqliteTable {
-    #[tracing::instrument(skip(self, guard, key))]
     fn get_with_guard(&self, guard: &Connection, key: &[u8]) -> Result<Option<Vec<u8>>> {
         Ok(guard
             .prepare(format!("SELECT value FROM {} WHERE key = ?", self.name).as_str())?
@@ -154,11 +200,10 @@ impl SqliteTable {
             .optional()?)
     }
 
-    #[tracing::instrument(skip(self, guard, key, value))]
     fn insert_with_guard(&self, guard: &Connection, key: &[u8], value: &[u8]) -> Result<()> {
         guard.execute(
             format!(
-                "INSERT OR REPLACE INTO {} (key, value) VALUES (?, ?)",
+                "INSERT INTO {} (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
                 self.name
             )
             .as_str(),
@@ -167,45 +212,62 @@ impl SqliteTable {
         Ok(())
     }
 
-    pub fn iter_with_guard<'a>(
+    fn _iter_from_thread<F>(&self, f: F) -> Box<dyn Iterator<Item = TupleOfBytes> + Send>
-        &'a self,
+    where
-        guard: &'a Connection,
+        F: (for<'a> FnOnce(&'a Connection, ChannelSender<TupleOfBytes>)) + Send + 'static,
-    ) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
+    {
-        let statement = Box::leak(Box::new(
+        let (s, r) = bounded::<TupleOfBytes>(5);
-            guard
-                .prepare(&format!(
-                    "SELECT key, value FROM {} ORDER BY key ASC",
-                    &self.name
-                ))
-                .unwrap(),
-        ));
 
-        let statement_ref = NonAliasingBox(statement);
+        let engine = self.engine.clone();
 
-        let iterator = Box::new(
+        thread::spawn(move || {
-            statement
+            let _ = f(&engine.pool.read_lock(), s);
-                .query_map([], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
+        });
-                .unwrap()
-                .map(|r| r.unwrap()),
-        );
 
-        Box::new(PreparedStatementIterator {
+        Box::new(r.into_iter())
-            iterator,
-            statement_ref,
-        })
     }
 }
 
+macro_rules! iter_from_thread {
+    ($self:expr, $sql:expr, $param:expr) => {
+        $self._iter_from_thread(move |guard, s| {
+            let _ = guard
+                .prepare($sql)
+                .unwrap()
+                .query_map($param, |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
+                .unwrap()
+                .map(|r| r.unwrap())
+                .try_for_each(|bob| s.send(bob));
+        })
+    };
+}
+
 impl Tree for SqliteTable {
-    #[tracing::instrument(skip(self, key))]
     fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
-        self.get_with_guard(&self.engine.read_lock(), key)
+        let guard = self.engine.pool.read_lock();
+
+        // let start = Instant::now();
+
+        let val = self.get_with_guard(&guard, key);
+
+        // debug!("get:       took {:?}", start.elapsed());
+        // debug!("get key: {:?}", &key)
+
+        val
     }
 
-    #[tracing::instrument(skip(self, key, value))]
     fn insert(&self, key: &[u8], value: &[u8]) -> Result<()> {
-        let guard = self.engine.write_lock();
+        let guard = self.engine.pool.write_lock();
+
+        let start = Instant::now();
+
         self.insert_with_guard(&guard, key, value)?;
+
+        let elapsed = start.elapsed();
+        if elapsed > MILLI {
+            debug!("insert:    took {:012?} : {}", elapsed, &self.name);
+        }
+
         drop(guard);
 
         let watchers = self.watchers.read();
@@ -233,118 +295,69 @@ impl Tree for SqliteTable {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, iter))]
-    fn insert_batch<'a>(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()> {
-        let guard = self.engine.write_lock();
-
-        guard.execute("BEGIN", [])?;
-        for (key, value) in iter {
-            self.insert_with_guard(&guard, &key, &value)?;
-        }
-        guard.execute("COMMIT", [])?;
-
-        drop(guard);
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, iter))]
-    fn increment_batch<'a>(&self, iter: &mut dyn Iterator<Item = Vec<u8>>) -> Result<()> {
-        let guard = self.engine.write_lock();
-
-        guard.execute("BEGIN", [])?;
-        for key in iter {
-            let old = self.get_with_guard(&guard, &key)?;
-            let new = crate::utils::increment(old.as_deref())
-                .expect("utils::increment always returns Some");
-            self.insert_with_guard(&guard, &key, &new)?;
-        }
-        guard.execute("COMMIT", [])?;
-
-        drop(guard);
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, key))]
     fn remove(&self, key: &[u8]) -> Result<()> {
-        let guard = self.engine.write_lock();
+        let guard = self.engine.pool.write_lock();
+
+        let start = Instant::now();
 
         guard.execute(
             format!("DELETE FROM {} WHERE key = ?", self.name).as_str(),
             [key],
         )?;
 
+        let elapsed = start.elapsed();
+
+        if elapsed > MILLI {
+            debug!("remove:    took {:012?} : {}", elapsed, &self.name);
+        }
+        // debug!("remove key: {:?}", &key);
+
         Ok(())
     }
 
-    #[tracing::instrument(skip(self))]
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = TupleOfBytes> + Send + 'a> {
-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
+        let name = self.name.clone();
-        let guard = self.engine.read_lock_iterator();
+        iter_from_thread!(
-
+            self,
-        self.iter_with_guard(&guard)
+            format!("SELECT key, value FROM {}", name).as_str(),
+            params![]
+        )
     }
 
-    #[tracing::instrument(skip(self, from, backwards))]
     fn iter_from<'a>(
         &'a self,
         from: &[u8],
         backwards: bool,
-    ) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
+    ) -> Box<dyn Iterator<Item = TupleOfBytes> + Send + 'a> {
-        let guard = self.engine.read_lock_iterator();
+        let name = self.name.clone();
         let from = from.to_vec(); // TODO change interface?
-
         if backwards {
-            let statement = Box::leak(Box::new(
+            iter_from_thread!(
-                guard
+                self,
-                    .prepare(&format!(
+                format!(
                     "SELECT key, value FROM {} WHERE key <= ? ORDER BY key DESC",
-                        &self.name
+                    name
-                    ))
+                )
-                    .unwrap(),
+                .as_str(),
-            ));
+                [from]
-
+            )
-            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(
+            iter_from_thread!(
-                guard
+                self,
-                    .prepare(&format!(
+                format!(
                     "SELECT key, value FROM {} WHERE key >= ? ORDER BY key ASC",
-                        &self.name
+                    name
-                    ))
+                )
-                    .unwrap(),
+                .as_str(),
-            ));
+                [from]
-
+            )
-            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 guard = self.engine.pool.write_lock();
+
+        let start = Instant::now();
 
         let old = self.get_with_guard(&guard, key)?;
 
@@ -353,18 +366,36 @@ impl Tree for SqliteTable {
 
         self.insert_with_guard(&guard, key, &new)?;
 
+        let elapsed = start.elapsed();
+
+        if elapsed > MILLI {
+            debug!("increment: took {:012?} : {}", elapsed, &self.name);
+        }
+        // debug!("increment key: {:?}", &key);
+
         Ok(new)
     }
 
-    #[tracing::instrument(skip(self, prefix))]
+    fn scan_prefix<'a>(
-    fn scan_prefix<'a>(&'a self, prefix: Vec<u8>) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
+        &'a self,
+        prefix: Vec<u8>,
+    ) -> Box<dyn Iterator<Item = TupleOfBytes> + Send + 'a> {
+        // let name = self.name.clone();
+        // iter_from_thread!(
+        //     self,
+        //     format!(
+        //         "SELECT key, value FROM {} WHERE key BETWEEN ?1 AND ?1 || X'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' ORDER BY key ASC",
+        //         name
+        //     )
+        //     .as_str(),
+        //     [prefix]
+        // )
         Box::new(
             self.iter_from(&prefix, false)
                 .take_while(move |(key, _)| key.starts_with(&prefix)),
         )
     }
 
-    #[tracing::instrument(skip(self, prefix))]
     fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
         let (tx, rx) = tokio::sync::oneshot::channel();
 
@@ -380,13 +411,28 @@ impl Tree for SqliteTable {
         })
     }
 
-    #[tracing::instrument(skip(self))]
     fn clear(&self) -> Result<()> {
         debug!("clear: running");
         self.engine
+            .pool
             .write_lock()
             .execute(format!("DELETE FROM {}", self.name).as_str(), [])?;
         debug!("clear: ran");
         Ok(())
     }
 }
+
+// TODO
+// struct Pool<const NUM_READERS: usize> {
+//     writer: Mutex<Connection>,
+//     readers: [Mutex<Connection>; NUM_READERS],
+// }
+
+// // then, to pick a reader:
+// for r in &pool.readers {
+//     if let Ok(reader) = r.try_lock() {
+//         // use reader
+//     }
+// }
+// // none unlocked, pick the next reader
+// pool.readers[pool.counter.fetch_add(1, Relaxed) % NUM_READERS].lock()

src/database/account_data.rs

@@ -12,12 +12,10 @@ use super::abstraction::Tree;
 
 pub struct AccountData {
     pub(super) roomuserdataid_accountdata: Arc<dyn Tree>, // RoomUserDataId = Room + User + Count + Type
-    pub(super) roomusertype_roomuserdataid: Arc<dyn Tree>, // RoomUserType = Room + User + Type
 }
 
 impl AccountData {
     /// Places one event in the account data of the user and removes the previous entry.
-    #[tracing::instrument(skip(self, room_id, user_id, event_type, data, globals))]
     pub fn update<T: Serialize>(
         &self,
         room_id: Option<&RoomId>,
@@ -35,13 +33,15 @@ impl AccountData {
         prefix.extend_from_slice(&user_id.as_bytes());
         prefix.push(0xff);
 
-        let mut roomuserdataid = prefix.clone();
+        // Remove old entry
-        roomuserdataid.extend_from_slice(&globals.next_count()?.to_be_bytes());
+        if let Some((old_key, _)) = self.find_event(room_id, user_id, &event_type)? {
-        roomuserdataid.push(0xff);
+            self.roomuserdataid_accountdata.remove(&old_key)?;
-        roomuserdataid.extend_from_slice(&event_type.as_bytes());
+        }
 
-        let mut key = prefix.clone();
+        let mut key = prefix;
-        key.extend_from_slice(event_type.as_bytes());
+        key.extend_from_slice(&globals.next_count()?.to_be_bytes());
+        key.push(0xff);
+        key.extend_from_slice(event_type.as_ref().as_bytes());
 
         let json = serde_json::to_value(data).expect("all types here can be serialized"); // TODO: maybe add error handling
         if json.get("type").is_none() || json.get("content").is_none() {
@@ -52,58 +52,29 @@ impl AccountData {
         }
 
         self.roomuserdataid_accountdata.insert(
-            &roomuserdataid,
+            &key,
             &serde_json::to_vec(&json).expect("to_vec always works on json values"),
         )?;
 
-        let prev = self.roomusertype_roomuserdataid.get(&key)?;
-
-        self.roomusertype_roomuserdataid
-            .insert(&key, &roomuserdataid)?;
-
-        // Remove old entry
-        if let Some(prev) = prev {
-            self.roomuserdataid_accountdata.remove(&prev)?;
-        }
-
         Ok(())
     }
 
     /// Searches the account data for a specific kind.
-    #[tracing::instrument(skip(self, room_id, user_id, kind))]
     pub fn get<T: DeserializeOwned>(
         &self,
         room_id: Option<&RoomId>,
         user_id: &UserId,
         kind: EventType,
     ) -> Result<Option<T>> {
-        let mut key = room_id
+        self.find_event(room_id, user_id, &kind)?
-            .map(|r| r.to_string())
+            .map(|(_, v)| {
-            .unwrap_or_default()
+                serde_json::from_slice(&v).map_err(|_| Error::bad_database("could not deserialize"))
-            .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, room_id, user_id, since))]
+    #[tracing::instrument(skip(self))]
     pub fn changes_since(
         &self,
         room_id: Option<&RoomId>,
@@ -150,4 +121,36 @@ impl AccountData {
 
         Ok(userdata)
     }
+
+    fn find_event(
+        &self,
+        room_id: Option<&RoomId>,
+        user_id: &UserId,
+        kind: &EventType,
+    ) -> Result<Option<(Vec<u8>, Vec<u8>)>> {
+        let mut prefix = room_id
+            .map(|r| r.to_string())
+            .unwrap_or_default()
+            .as_bytes()
+            .to_vec();
+        prefix.push(0xff);
+        prefix.extend_from_slice(&user_id.as_bytes());
+        prefix.push(0xff);
+
+        let mut last_possible_key = prefix.clone();
+        last_possible_key.extend_from_slice(&u64::MAX.to_be_bytes());
+
+        let kind = kind.clone();
+
+        Ok(self
+            .roomuserdataid_accountdata
+            .iter_from(&last_possible_key, true)
+            .take_while(move |(k, _)| k.starts_with(&prefix))
+            .find(move |(k, _)| {
+                k.rsplit(|&b| b == 0xff)
+                    .next()
+                    .map(|current_event_type| current_event_type == kind.as_ref().as_bytes())
+                    .unwrap_or(false)
+            }))
+    }
 }

src/database/admin.rs

@@ -4,13 +4,13 @@ use std::{
 };
 
 use crate::{pdu::PduBuilder, Database};
+use log::warn;
 use rocket::futures::{channel::mpsc, stream::StreamExt};
 use ruma::{
     events::{room::message, EventType},
     UserId,
 };
 use tokio::sync::{MutexGuard, RwLock, RwLockReadGuard};
-use tracing::warn;
 
 pub enum AdminCommand {
     RegisterAppservice(serde_yaml::Value),
@@ -84,15 +84,15 @@ impl Admin {
                 tokio::select! {
                     Some(event) = receiver.next() => {
                         let guard = db.read().await;
-                        let mutex_state = Arc::clone(
+                        let mutex = Arc::clone(
                             guard.globals
-                                .roomid_mutex_state
+                                .roomid_mutex
                                 .write()
                                 .unwrap()
                                 .entry(conduit_room.clone())
                                 .or_default(),
                         );
-                        let state_lock = mutex_state.lock().await;
+                        let mutex_lock = mutex.lock().await;
 
                         match event {
                             AdminCommand::RegisterAppservice(yaml) => {
@@ -106,17 +106,17 @@ impl Admin {
                                         count,
                                         appservices.into_iter().filter_map(|r| r.ok()).collect::<Vec<_>>().join(", ")
                                     );
-                                    send_message(message::MessageEventContent::text_plain(output), guard, &state_lock);
+                                    send_message(message::MessageEventContent::text_plain(output), guard, &mutex_lock);
                                 } else {
-                                    send_message(message::MessageEventContent::text_plain("Failed to get appservices."), guard, &state_lock);
+                                    send_message(message::MessageEventContent::text_plain("Failed to get appservices."), guard, &mutex_lock);
                                 }
                             }
                             AdminCommand::SendMessage(message) => {
-                                send_message(message, guard, &state_lock);
+                                send_message(message, guard, &mutex_lock);
                             }
                         }
 
-                        drop(state_lock);
+                        drop(mutex_lock);
                     }
                 }
             }

src/database/appservice.rs

@@ -49,23 +49,22 @@ impl Appservice {
             )
     }
 
-    pub fn iter_ids(&self) -> Result<impl Iterator<Item = Result<String>> + '_> {
+    pub fn iter_ids(&self) -> Result<impl Iterator<Item = Result<String>> + Send + '_> {
         Ok(self.id_appserviceregistrations.iter().map(|(id, _)| {
             utils::string_from_bytes(&id)
                 .map_err(|_| Error::bad_database("Invalid id bytes in id_appserviceregistrations."))
         }))
     }
 
-    pub fn all(&self) -> Result<Vec<(String, serde_yaml::Value)>> {
+    pub fn iter_all(
-        self.iter_ids()?
+        &self,
-            .filter_map(|id| id.ok())
+    ) -> Result<impl Iterator<Item = Result<(String, serde_yaml::Value)>> + '_ + Send> {
-            .map(move |id| {
+        Ok(self.iter_ids()?.filter_map(|id| id.ok()).map(move |id| {
             Ok((
                 id.clone(),
                 self.get_registration(&id)?
                     .expect("iter_ids only returns appservices that exist"),
             ))
-            })
+        }))
-            .collect()
     }
 }

src/database/globals.rs

@@ -1,4 +1,5 @@
-use crate::{database::Config, server_server::FedDest, utils, ConduitResult, Error, Result};
+use crate::{database::Config, utils, ConduitResult, Error, Result};
+use log::{error, info};
 use ruma::{
     api::{
         client::r0::sync::sync_events,
@@ -6,53 +7,85 @@ use ruma::{
     },
     DeviceId, EventId, MilliSecondsSinceUnixEpoch, RoomId, ServerName, ServerSigningKeyId, UserId,
 };
+use rustls::{ServerCertVerifier, WebPKIVerifier};
 use std::{
     collections::{BTreeMap, HashMap},
     fs,
     future::Future,
-    net::IpAddr,
     path::PathBuf,
-    sync::{Arc, Mutex, RwLock},
+    sync::{Arc, RwLock},
     time::{Duration, Instant},
 };
-use tokio::sync::{broadcast, watch::Receiver, Mutex as TokioMutex, Semaphore};
+use tokio::sync::{broadcast, Mutex, Semaphore};
-use tracing::error;
 use trust_dns_resolver::TokioAsyncResolver;
 
 use super::abstraction::Tree;
 
 pub const COUNTER: &[u8] = b"c";
 
-type WellKnownMap = HashMap<Box<ServerName>, (FedDest, String)>;
+type WellKnownMap = HashMap<Box<ServerName>, (String, String)>;
-type TlsNameMap = HashMap<String, (Vec<IpAddr>, u16)>;
+type TlsNameMap = HashMap<String, webpki::DNSName>;
 type RateLimitState = (Instant, u32); // Time if last failed try, number of failed tries
-type SyncHandle = (
-    Option<String>,                                         // since
-    Receiver<Option<ConduitResult<sync_events::Response>>>, // rx
-);
-
 pub struct Globals {
     pub actual_destination_cache: Arc<RwLock<WellKnownMap>>, // actual_destination, host
     pub tls_name_override: Arc<RwLock<TlsNameMap>>,
     pub(super) globals: Arc<dyn Tree>,
     config: Config,
     keypair: Arc<ruma::signatures::Ed25519KeyPair>,
+    reqwest_client: reqwest::Client,
     dns_resolver: TokioAsyncResolver,
     jwt_decoding_key: Option<jsonwebtoken::DecodingKey<'static>>,
     pub(super) server_signingkeys: Arc<dyn Tree>,
-    pub bad_event_ratelimiter: Arc<RwLock<HashMap<EventId, RateLimitState>>>,
+    pub bad_event_ratelimiter: Arc<RwLock<BTreeMap<EventId, RateLimitState>>>,
-    pub bad_signature_ratelimiter: Arc<RwLock<HashMap<Vec<String>, RateLimitState>>>,
+    pub bad_signature_ratelimiter: Arc<RwLock<BTreeMap<Vec<String>, RateLimitState>>>,
-    pub servername_ratelimiter: Arc<RwLock<HashMap<Box<ServerName>, Arc<Semaphore>>>>,
+    pub servername_ratelimiter: Arc<RwLock<BTreeMap<Box<ServerName>, Arc<Semaphore>>>>,
-    pub sync_receivers: RwLock<HashMap<(UserId, Box<DeviceId>), SyncHandle>>,
+    pub roomid_mutex: RwLock<BTreeMap<RoomId, Arc<Mutex<()>>>>,
-    pub roomid_mutex_insert: RwLock<HashMap<RoomId, Arc<Mutex<()>>>>,
+    pub roomid_mutex_federation: RwLock<BTreeMap<RoomId, Arc<Mutex<()>>>>, // this lock will be held longer
-    pub roomid_mutex_state: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>,
+    pub sync_receivers: RwLock<
-    pub roomid_mutex_federation: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>, // this lock will be held longer
+        BTreeMap<
+            (UserId, Box<DeviceId>),
+            (
+                Option<String>,
+                tokio::sync::watch::Receiver<Option<ConduitResult<sync_events::Response>>>,
+            ), // since, rx
+        >,
+    >,
     pub rotate: RotationHandler,
 }
 
-/// Handles "rotation" of long-polling requests. "Rotation" in this context is similar to "rotation" of log files and the like.
+struct MatrixServerVerifier {
-///
+    inner: WebPKIVerifier,
-/// This is utilized to have sync workers return early and release read locks on the database.
+    tls_name_override: Arc<RwLock<TlsNameMap>>,
+}
+
+impl ServerCertVerifier for MatrixServerVerifier {
+    fn verify_server_cert(
+        &self,
+        roots: &rustls::RootCertStore,
+        presented_certs: &[rustls::Certificate],
+        dns_name: webpki::DNSNameRef<'_>,
+        ocsp_response: &[u8],
+    ) -> std::result::Result<rustls::ServerCertVerified, rustls::TLSError> {
+        if let Some(override_name) = self.tls_name_override.read().unwrap().get(dns_name.into()) {
+            let result = self.inner.verify_server_cert(
+                roots,
+                presented_certs,
+                override_name.as_ref(),
+                ocsp_response,
+            );
+            if result.is_ok() {
+                return result;
+            }
+            info!(
+                "Server {:?} is non-compliant, retrying TLS verification with original name",
+                dns_name
+            );
+        }
+        self.inner
+            .verify_server_cert(roots, presented_certs, dns_name, ocsp_response)
+    }
+}
+
 pub struct RotationHandler(broadcast::Sender<()>, broadcast::Receiver<()>);
 
 impl RotationHandler {
@@ -75,12 +108,6 @@ impl RotationHandler {
     }
 }
 
-impl Default for RotationHandler {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Globals {
     pub fn load(
         globals: Arc<dyn Tree>,
@@ -127,6 +154,24 @@ impl Globals {
         };
 
         let tls_name_override = Arc::new(RwLock::new(TlsNameMap::new()));
+        let verifier = Arc::new(MatrixServerVerifier {
+            inner: WebPKIVerifier::new(),
+            tls_name_override: tls_name_override.clone(),
+        });
+        let mut tlsconfig = rustls::ClientConfig::new();
+        tlsconfig.dangerous().set_certificate_verifier(verifier);
+        tlsconfig.root_store =
+            rustls_native_certs::load_native_certs().expect("Error loading system certificates");
+
+        let mut reqwest_client_builder = reqwest::Client::builder()
+            .connect_timeout(Duration::from_secs(30))
+            .timeout(Duration::from_secs(60 * 3))
+            .pool_max_idle_per_host(1)
+            .use_preconfigured_tls(tlsconfig);
+        if let Some(proxy) = config.proxy.to_proxy()? {
+            reqwest_client_builder = reqwest_client_builder.proxy(proxy);
+        }
+        let reqwest_client = reqwest_client_builder.build().unwrap();
 
         let jwt_decoding_key = config
             .jwt_secret
@@ -137,6 +182,7 @@ impl Globals {
             globals,
             config,
             keypair: Arc::new(keypair),
+            reqwest_client,
             dns_resolver: TokioAsyncResolver::tokio_from_system_conf().map_err(|_| {
                 Error::bad_config("Failed to set up trust dns resolver with system config.")
             })?,
@@ -144,13 +190,12 @@ impl Globals {
             tls_name_override,
             server_signingkeys,
             jwt_decoding_key,
-            bad_event_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
+            bad_event_ratelimiter: Arc::new(RwLock::new(BTreeMap::new())),
-            bad_signature_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
+            bad_signature_ratelimiter: Arc::new(RwLock::new(BTreeMap::new())),
-            servername_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
+            servername_ratelimiter: Arc::new(RwLock::new(BTreeMap::new())),
-            roomid_mutex_state: RwLock::new(HashMap::new()),
+            roomid_mutex: RwLock::new(BTreeMap::new()),
-            roomid_mutex_insert: RwLock::new(HashMap::new()),
+            roomid_mutex_federation: RwLock::new(BTreeMap::new()),
-            roomid_mutex_federation: RwLock::new(HashMap::new()),
+            sync_receivers: RwLock::new(BTreeMap::new()),
-            sync_receivers: RwLock::new(HashMap::new()),
             rotate: RotationHandler::new(),
         };
 
@@ -165,25 +210,15 @@ impl Globals {
     }
 
     /// Returns a reqwest client which can be used to send requests.
-    pub fn reqwest_client(&self) -> Result<reqwest::ClientBuilder> {
+    pub fn reqwest_client(&self) -> &reqwest::Client {
-        let mut reqwest_client_builder = reqwest::Client::builder()
+        &self.reqwest_client
-            .connect_timeout(Duration::from_secs(30))
-            .timeout(Duration::from_secs(60 * 3))
-            .pool_max_idle_per_host(1);
-        if let Some(proxy) = self.config.proxy.to_proxy()? {
-            reqwest_client_builder = reqwest_client_builder.proxy(proxy);
     }
 
-        Ok(reqwest_client_builder)
-    }
-
-    #[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)

src/database/media.rs

@@ -54,7 +54,6 @@ impl Media {
     }
 
     /// Uploads or replaces a file thumbnail.
-    #[allow(clippy::too_many_arguments)]
     pub async fn upload_thumbnail(
         &self,
         mxc: String,
@@ -101,8 +100,8 @@ impl Media {
         prefix.extend_from_slice(&0_u32.to_be_bytes()); // Height = 0 if it's not a thumbnail
         prefix.push(0xff);
 
-        let first = self.mediaid_file.scan_prefix(prefix).next();
+        let mut iter = self.mediaid_file.scan_prefix(prefix);
-        if let Some((key, _)) = first {
+        if let Some((key, _)) = iter.next() {
             let path = globals.get_media_file(&key);
             let mut file = Vec::new();
             File::open(path).await?.read_to_end(&mut file).await?;
@@ -190,9 +189,7 @@ impl Media {
         original_prefix.extend_from_slice(&0_u32.to_be_bytes()); // Height = 0 if it's not a thumbnail
         original_prefix.push(0xff);
 
-        let first_thumbnailprefix = self.mediaid_file.scan_prefix(thumbnail_prefix).next();
+        if let Some((key, _)) = 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();
@@ -227,7 +224,7 @@ impl Media {
                 content_type,
                 file: file.to_vec(),
             }))
-        } else if let Some((key, _)) = first_originalprefix {
+        } else if let Some((key, _)) = self.mediaid_file.scan_prefix(original_prefix).next() {
             // Generate a thumbnail
             let path = globals.get_media_file(&key);
             let mut file = Vec::new();

src/database/pusher.rs

@@ -1,5 +1,6 @@
 use crate::{Database, Error, PduEvent, Result};
 use bytes::BytesMut;
+use log::{error, info, warn};
 use ruma::{
     api::{
         client::r0::push::{get_pushers, set_pusher, PusherKind},
@@ -9,13 +10,10 @@ use ruma::{
         },
         IncomingResponse, OutgoingRequest, SendAccessToken,
     },
-    events::{room::power_levels::PowerLevelsEventContent, AnySyncRoomEvent, EventType},
+    events::{room::power_levels::PowerLevelsEventContent, EventType},
-    identifiers::RoomName,
     push::{Action, PushConditionRoomCtx, PushFormat, Ruleset, Tweak},
-    serde::Raw,
+    uint, UInt, UserId,
-    uint, RoomId, UInt, UserId,
 };
-use tracing::{error, info, warn};
 
 use std::{convert::TryFrom, fmt::Debug, mem, sync::Arc};
 
@@ -27,7 +25,6 @@ pub struct PushData {
 }
 
 impl PushData {
-    #[tracing::instrument(skip(self, sender, pusher))]
     pub fn set_pusher(&self, sender: &UserId, pusher: set_pusher::Pusher) -> Result<()> {
         let mut key = sender.as_bytes().to_vec();
         key.push(0xff);
@@ -50,7 +47,6 @@ impl PushData {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, senderkey))]
     pub fn get_pusher(&self, senderkey: &[u8]) -> Result<Option<get_pushers::Pusher>> {
         self.senderkey_pusher
             .get(senderkey)?
@@ -61,7 +57,6 @@ impl PushData {
             .transpose()
     }
 
-    #[tracing::instrument(skip(self, sender))]
     pub fn get_pushers(&self, sender: &UserId) -> Result<Vec<get_pushers::Pusher>> {
         let mut prefix = sender.as_bytes().to_vec();
         prefix.push(0xff);
@@ -75,7 +70,6 @@ impl PushData {
             .collect()
     }
 
-    #[tracing::instrument(skip(self, sender))]
     pub fn get_pusher_senderkeys<'a>(
         &'a self,
         sender: &UserId,
@@ -87,7 +81,6 @@ impl PushData {
     }
 }
 
-#[tracing::instrument(skip(globals, destination, request))]
 pub async fn send_request<T: OutgoingRequest>(
     globals: &crate::database::globals::Globals,
     destination: &str,
@@ -113,11 +106,7 @@ where
     //*reqwest_request.timeout_mut() = Some(Duration::from_secs(5));
 
     let url = reqwest_request.url().clone();
-    let response = globals
+    let response = globals.reqwest_client().execute(reqwest_request).await;
-        .reqwest_client()?
-        .build()?
-        .execute(reqwest_request)
-        .await;
 
     match response {
         Ok(mut response) => {
@@ -165,7 +154,6 @@ where
     }
 }
 
-#[tracing::instrument(skip(user, unread, pusher, ruleset, pdu, db))]
 pub async fn send_push_notice(
     user: &UserId,
     unread: UInt,
@@ -177,24 +165,7 @@ pub async fn send_push_notice(
     let mut notify = None;
     let mut tweaks = Vec::new();
 
-    let power_levels: PowerLevelsEventContent = db
+    for action in get_actions(user, &ruleset, pdu, 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
@@ -222,31 +193,37 @@ pub async fn send_push_notice(
     Ok(())
 }
 
-#[tracing::instrument(skip(user, ruleset, pdu, db))]
 pub fn get_actions<'a>(
     user: &UserId,
     ruleset: &'a Ruleset,
-    power_levels: &PowerLevelsEventContent,
+    pdu: &PduEvent,
-    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: room_id.clone(),
+        room_id: pdu.room_id.clone(),
         member_count: 10_u32.into(), // TODO: get member count efficiently
         user_display_name: db
             .users
             .displayname(&user)?
             .unwrap_or_else(|| user.localpart().to_owned()),
-        users_power_levels: power_levels.users.clone(),
+        users_power_levels: power_levels.users,
         default_power_level: power_levels.users_default,
-        notification_power_levels: power_levels.notifications.clone(),
+        notification_power_levels: power_levels.notifications,
     };
 
-    Ok(ruleset.get_actions(pdu, &ctx))
+    Ok(ruleset.get_actions(&pdu.to_sync_room_event(), &ctx))
 }
 
-#[tracing::instrument(skip(unread, pusher, tweaks, event, db))]
 async fn send_notice(
     unread: UInt,
     pusher: &get_pushers::Pusher,
@@ -322,9 +299,7 @@ async fn send_notice(
             .rooms
             .room_state_get(&event.room_id, &EventType::RoomName, "")?
             .map(|pdu| match pdu.content.get("name") {
-                Some(serde_json::Value::String(s)) => {
+                Some(serde_json::Value::String(s)) => Some(s.to_string()),
-                    Some(Box::<RoomName>::try_from(&**s).expect("room name is valid"))
-                }
                 _ => None,
             })
             .flatten();

src/database/rooms/edus.rs

@@ -116,7 +116,6 @@ impl RoomEdus {
     }
 
     /// Sets a private read marker at `count`.
-    #[tracing::instrument(skip(self, globals))]
     pub fn private_read_set(
         &self,
         room_id: &RoomId,
@@ -422,7 +421,7 @@ impl RoomEdus {
     }
 
     /// Sets all users to offline who have been quiet for too long.
-    fn presence_maintain(
+    pub fn presence_maintain(
         &self,
         rooms: &super::Rooms,
         globals: &super::super::globals::Globals,
@@ -497,7 +496,7 @@ impl RoomEdus {
         rooms: &super::Rooms,
         globals: &super::super::globals::Globals,
     ) -> Result<HashMap<UserId, PresenceEvent>> {
-        //self.presence_maintain(rooms, globals)?;
+        self.presence_maintain(rooms, globals)?;
 
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);

src/database/sending.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::{BTreeMap, HashMap, HashSet},
+    collections::{BTreeMap, HashMap},
     convert::{TryFrom, TryInto},
     fmt::Debug,
     sync::Arc,
@@ -10,6 +10,7 @@ use crate::{
     appservice_server, database::pusher, server_server, utils, Database, Error, PduEvent, Result,
 };
 use federation::transactions::send_transaction_message;
+use log::{error, warn};
 use ring::digest;
 use rocket::futures::{
     channel::mpsc,
@@ -20,23 +21,19 @@ use ruma::{
         appservice,
         federation::{
             self,
-            transactions::edu::{
+            transactions::edu::{Edu, ReceiptContent, ReceiptData, ReceiptMap},
-                DeviceListUpdateContent, Edu, ReceiptContent, ReceiptData, ReceiptMap,
-            },
         },
         OutgoingRequest,
     },
-    device_id,
     events::{push_rules, AnySyncEphemeralRoomEvent, EventType},
     push,
     receipt::ReceiptType,
-    uint, MilliSecondsSinceUnixEpoch, ServerName, UInt, UserId,
+    MilliSecondsSinceUnixEpoch, ServerName, UInt, UserId,
 };
 use tokio::{
     select,
     sync::{RwLock, Semaphore},
 };
-use tracing::{error, warn};
 
 use super::abstraction::Tree;
 
@@ -48,7 +45,6 @@ pub enum OutgoingKind {
 }
 
 impl OutgoingKind {
-    #[tracing::instrument(skip(self))]
     pub fn get_prefix(&self) -> Vec<u8> {
         let mut prefix = match self {
             OutgoingKind::Appservice(server) => {
@@ -84,10 +80,10 @@ pub enum SendingEventType {
 pub struct Sending {
     /// The state for a given state hash.
     pub(super) servername_educount: Arc<dyn Tree>, // EduCount: Count of last EDU sync
-    pub(super) servernameevent_data: Arc<dyn Tree>, // ServernamEvent = (+ / $)SenderKey / ServerName / UserId + PduId / Id (for edus), Data = EDU content
+    pub(super) servernamepduids: Arc<dyn Tree>, // ServernamePduId = (+ / $)SenderKey / ServerName / UserId + PduId
-    pub(super) servercurrentevent_data: Arc<dyn Tree>, // ServerCurrentEvents = (+ / $)ServerName / UserId + PduId / Id (for edus), Data = EDU content
+    pub(super) servercurrentevents: Arc<dyn Tree>, // ServerCurrentEvents = (+ / $)ServerName / UserId + PduId / (*)EduEvent
     pub(super) maximum_requests: Arc<Semaphore>,
-    pub sender: mpsc::UnboundedSender<(Vec<u8>, Vec<u8>)>,
+    pub sender: mpsc::UnboundedSender<Vec<u8>>,
 }
 
 enum TransactionStatus {
@@ -100,7 +96,7 @@ impl Sending {
     pub fn start_handler(
         &self,
         db: Arc<RwLock<Database>>,
-        mut receiver: mpsc::UnboundedReceiver<(Vec<u8>, Vec<u8>)>,
+        mut receiver: mpsc::UnboundedReceiver<Vec<u8>>,
     ) {
         tokio::spawn(async move {
             let mut futures = FuturesUnordered::new();
@@ -112,12 +108,13 @@ impl Sending {
 
             let guard = db.read().await;
 
-            for (key, outgoing_kind, event) in guard
+            for (key, outgoing_kind, event) in
+                guard
                     .sending
-                .servercurrentevent_data
+                    .servercurrentevents
                     .iter()
-                .filter_map(|(key, v)| {
+                    .filter_map(|(key, _)| {
-                    Self::parse_servercurrentevent(&key, v)
+                        Self::parse_servercurrentevent(&key)
                             .ok()
                             .map(|(k, e)| (key, k, e))
                     })
@@ -131,7 +128,7 @@ impl Sending {
                         "Dropping some current events: {:?} {:?} {:?}",
                         key, outgoing_kind, event
                     );
-                    guard.sending.servercurrentevent_data.remove(&key).unwrap();
+                    guard.sending.servercurrentevents.remove(&key).unwrap();
                     continue;
                 }
 
@@ -158,17 +155,17 @@ impl Sending {
                                 let guard = db.read().await;
 
                                 let prefix = outgoing_kind.get_prefix();
-                                for (key, _) in guard.sending.servercurrentevent_data
+                                for (key, _) in guard.sending.servercurrentevents
                                     .scan_prefix(prefix.clone())
                                 {
-                                    guard.sending.servercurrentevent_data.remove(&key).unwrap();
+                                    guard.sending.servercurrentevents.remove(&key).unwrap();
                                 }
 
                                 // Find events that have been added since starting the last request
-                                let new_events = guard.sending.servernameevent_data
+                                let new_events = guard.sending.servernamepduids
                                     .scan_prefix(prefix.clone())
-                                    .filter_map(|(k, v)| {
+                                    .map(|(k, _)| {
-                                        Self::parse_servercurrentevent(&k, v).ok().map(|ev| (ev, k))
+                                        SendingEventType::Pdu(k[prefix.len()..].to_vec())
                                     })
                                     .take(30)
                                     .collect::<Vec<_>>();
@@ -177,10 +174,16 @@ impl Sending {
 
                                 if !new_events.is_empty() {
                                     // Insert pdus we found
-                                    for (e, key) in &new_events {
+                                    for event in &new_events {
-                                        let value = if let SendingEventType::Edu(value) = &e.1 { &**value } else { &[] };
+                                        let mut current_key = prefix.clone();
-                                        guard.sending.servercurrentevent_data.insert(&key, value).unwrap();
+                                        match event {
-                                        guard.sending.servernameevent_data.remove(&key).unwrap();
+                                            SendingEventType::Pdu(b) |
+                                            SendingEventType::Edu(b) => {
+                                                current_key.extend_from_slice(&b);
+                                                guard.sending.servercurrentevents.insert(&current_key, &[]).unwrap();
+                                                guard.sending.servernamepduids.remove(&current_key).unwrap();
+                                             }
+                                        }
                                     }
 
                                     drop(guard);
@@ -188,7 +191,7 @@ impl Sending {
                                     futures.push(
                                         Self::handle_events(
                                             outgoing_kind.clone(),
-                                            new_events.into_iter().map(|(event, _)| event.1).collect(),
+                                            new_events,
                                             Arc::clone(&db),
                                         )
                                     );
@@ -208,8 +211,8 @@ impl Sending {
                             }
                         };
                     },
-                    Some((key, value)) = receiver.next() => {
+                    Some(key) = receiver.next() => {
-                        if let Ok((outgoing_kind, event)) = Self::parse_servercurrentevent(&key, value) {
+                        if let Ok((outgoing_kind, event)) = Self::parse_servercurrentevent(&key) {
                             let guard = db.read().await;
 
                             if let Ok(Some(events)) = Self::select_events(
@@ -227,7 +230,6 @@ impl Sending {
         });
     }
 
-    #[tracing::instrument(skip(outgoing_kind, new_events, current_transaction_status, db))]
     fn select_events(
         outgoing_kind: &OutgoingKind,
         new_events: Vec<(SendingEventType, Vec<u8>)>, // Events we want to send: event and full key
@@ -270,33 +272,25 @@ impl Sending {
 
         if retry {
             // We retry the previous transaction
-            for (key, value) in db.sending.servercurrentevent_data.scan_prefix(prefix) {
+            for (key, _) in db.sending.servercurrentevents.scan_prefix(prefix) {
-                if let Ok((_, e)) = Self::parse_servercurrentevent(&key, value) {
+                if let Ok((_, e)) = Self::parse_servercurrentevent(&key) {
                     events.push(e);
                 }
             }
         } else {
             for (e, full_key) in new_events {
-                let value = if let SendingEventType::Edu(value) = &e {
+                db.sending.servercurrentevents.insert(&full_key, &[])?;
-                    &**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.servernameevent_data.remove(&full_key)?;
+                db.sending.servernamepduids.remove(&full_key)?;
 
                 events.push(e);
             }
 
             if let OutgoingKind::Normal(server_name) = outgoing_kind {
                 if let Ok((select_edus, last_count)) = Self::select_edus(db, server_name) {
-                    events.extend(select_edus.into_iter().map(SendingEventType::Edu));
+                    events.extend_from_slice(&select_edus);
-
                     db.sending
                         .servername_educount
                         .insert(server_name.as_bytes(), &last_count.to_be_bytes())?;
@@ -307,8 +301,7 @@ impl Sending {
         Ok(Some(events))
     }
 
-    #[tracing::instrument(skip(db, server))]
+    pub fn select_edus(db: &Database, server: &ServerName) -> Result<(Vec<SendingEventType>, u64)> {
-    pub fn select_edus(db: &Database, server: &ServerName) -> Result<(Vec<Vec<u8>>, u64)> {
         // u64: count of last edu
         let since = db
             .sending
@@ -320,19 +313,8 @@ impl Sending {
             })?;
         let mut events = Vec::new();
         let mut max_edu_count = since;
-        let mut device_list_changes = HashSet::new();
-
         'outer: for room_id in db.rooms.server_rooms(server) {
             let room_id = room_id?;
-            // Look for device list updates in this room
-            device_list_changes.extend(
-                db.users
-                    .keys_changed(&room_id.to_string(), since, None)
-                    .filter_map(|r| r.ok())
-                    .filter(|user_id| user_id.server_name() == db.globals.server_name()),
-            );
-
-            // Look for read receipts in this room
             for r in db.rooms.edus.readreceipts_since(&room_id, since) {
                 let (user_id, count, read_receipt) = r?;
 
@@ -384,7 +366,9 @@ impl Sending {
                     }
                 };
 
-                events.push(serde_json::to_vec(&federation_event).expect("json can be serialized"));
+                events.push(SendingEventType::Edu(
+                    serde_json::to_vec(&federation_event).expect("json can be serialized"),
+                ));
 
                 if events.len() >= 20 {
                     break 'outer;
@@ -392,60 +376,28 @@ impl Sending {
             }
         }
 
-        for user_id in device_list_changes {
-            // Empty prev id forces synapse to resync: https://github.com/matrix-org/synapse/blob/98aec1cc9da2bd6b8e34ffb282c85abf9b8b42ca/synapse/handlers/device.py#L767
-            // Because synapse resyncs, we can just insert dummy data
-            let edu = Edu::DeviceListUpdate(DeviceListUpdateContent {
-                user_id,
-                device_id: device_id!("dummy"),
-                device_display_name: "Dummy".to_owned(),
-                stream_id: uint!(1),
-                prev_id: Vec::new(),
-                deleted: None,
-                keys: None,
-            });
-
-            events.push(serde_json::to_vec(&edu).expect("json can be serialized"));
-        }
-
         Ok((events, max_edu_count))
     }
 
-    #[tracing::instrument(skip(self, pdu_id, senderkey))]
+    #[tracing::instrument(skip(self))]
     pub fn send_push_pdu(&self, pdu_id: &[u8], senderkey: Vec<u8>) -> Result<()> {
         let mut key = b"$".to_vec();
         key.extend_from_slice(&senderkey);
         key.push(0xff);
         key.extend_from_slice(pdu_id);
-        self.servernameevent_data.insert(&key, &[])?;
+        self.servernamepduids.insert(&key, b"")?;
-        self.sender.unbounded_send((key, vec![])).unwrap();
+        self.sender.unbounded_send(key).unwrap();
 
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, server, pdu_id))]
+    #[tracing::instrument(skip(self))]
     pub fn send_pdu(&self, server: &ServerName, pdu_id: &[u8]) -> Result<()> {
         let mut key = server.as_bytes().to_vec();
         key.push(0xff);
         key.extend_from_slice(pdu_id);
-        self.servernameevent_data.insert(&key, &[])?;
+        self.servernamepduids.insert(&key, b"")?;
-        self.sender.unbounded_send((key, vec![])).unwrap();
+        self.sender.unbounded_send(key).unwrap();
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self, server, serialized))]
-    pub fn send_reliable_edu(
-        &self,
-        server: &ServerName,
-        serialized: Vec<u8>,
-        id: u64,
-    ) -> Result<()> {
-        let mut key = server.as_bytes().to_vec();
-        key.push(0xff);
-        key.extend_from_slice(&id.to_be_bytes());
-        self.servernameevent_data.insert(&key, &serialized)?;
-        self.sender.unbounded_send((key, serialized)).unwrap();
 
         Ok(())
     }
@@ -456,13 +408,13 @@ impl Sending {
         key.extend_from_slice(appservice_id.as_bytes());
         key.push(0xff);
         key.extend_from_slice(pdu_id);
-        self.servernameevent_data.insert(&key, &[])?;
+        self.servernamepduids.insert(&key, b"")?;
-        self.sender.unbounded_send((key, vec![])).unwrap();
+        self.sender.unbounded_send(key).unwrap();
 
         Ok(())
     }
 
-    #[tracing::instrument(skip(keys))]
+    #[tracing::instrument]
     fn calculate_hash(keys: &[&[u8]]) -> Vec<u8> {
         // We only hash the pdu's event ids, not the whole pdu
         let bytes = keys.join(&0xff);
@@ -470,7 +422,7 @@ impl Sending {
         hash.as_ref().to_owned()
     }
 
-    #[tracing::instrument(skip(db, events, kind))]
+    #[tracing::instrument(skip(db))]
     async fn handle_events(
         kind: OutgoingKind,
         events: Vec<SendingEventType>,
@@ -492,7 +444,7 @@ impl Sending {
                                     (
                                         kind.clone(),
                                         Error::bad_database(
-                                            "[Appservice] Event in servernameevent_data not found in db.",
+                                            "[Appservice] Event in servernamepduids not found in db.",
                                         ),
                                     )
                                 })?
@@ -549,7 +501,7 @@ impl Sending {
                                         (
                                             kind.clone(),
                                             Error::bad_database(
-                                                "[Push] Event in servernamevent_datas not found in db.",
+                                                "[Push] Event in servernamepduids not found in db.",
                                             ),
                                         )
                                     })?,
@@ -634,7 +586,8 @@ impl Sending {
                     match event {
                         SendingEventType::Pdu(pdu_id) => {
                             // TODO: check room version and remove event_id if needed
-                            let raw = PduEvent::convert_to_outgoing_federation_event(
+                            pdu_jsons.push(serde_json::from_str(
+                                PduEvent::convert_to_outgoing_federation_event(
                                     db.rooms
                                         .get_pdu_json_from_id(&pdu_id)
                                         .map_err(|e| (OutgoingKind::Normal(server.clone()), e))?
@@ -642,17 +595,20 @@ impl Sending {
                                             (
                                                 OutgoingKind::Normal(server.clone()),
                                                 Error::bad_database(
-                                                "[Normal] Event in servernamevent_datas not found in db.",
+                                                    "[Normal] Event in servernamepduids not found in db.",
                                                 ),
                                             )
                                         })?,
-                            );
+                                )
-                            pdu_jsons.push(raw);
+                                .json()
+                                .get(),
+                            )
+                            .expect("Raw<..> is always valid"));
                         }
                         SendingEventType::Edu(edu) => {
-                            if let Ok(raw) = serde_json::from_slice(edu) {
+                            edu_jsons.push(
-                                edu_jsons.push(raw);
+                                serde_json::from_slice(edu).expect("Raw<..> is always valid"),
-                            }
+                            );
                         }
                     }
                 }
@@ -698,11 +654,7 @@ impl Sending {
         }
     }
 
-    #[tracing::instrument(skip(key))]
+    fn parse_servercurrentevent(key: &[u8]) -> Result<(OutgoingKind, SendingEventType)> {
-    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);
@@ -719,10 +671,10 @@ impl Sending {
                 OutgoingKind::Appservice(Box::<ServerName>::try_from(server).map_err(|_| {
                     Error::bad_database("Invalid server string in server_currenttransaction")
                 })?),
-                if value.is_empty() {
+                if event.starts_with(b"*") {
-                    SendingEventType::Pdu(event.to_vec())
+                    SendingEventType::Edu(event[1..].to_vec())
                 } else {
-                    SendingEventType::Edu(value)
+                    SendingEventType::Pdu(event.to_vec())
                 },
             )
         } else if key.starts_with(b"$") {
@@ -737,10 +689,10 @@ impl Sending {
                 .ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
             (
                 OutgoingKind::Push(user.to_vec(), pushkey.to_vec()),
-                if value.is_empty() {
+                if event.starts_with(b"*") {
-                    SendingEventType::Pdu(event.to_vec())
+                    SendingEventType::Edu(event[1..].to_vec())
                 } else {
-                    SendingEventType::Edu(value)
+                    SendingEventType::Pdu(event.to_vec())
                 },
             )
         } else {
@@ -758,16 +710,16 @@ impl Sending {
                 OutgoingKind::Normal(Box::<ServerName>::try_from(server).map_err(|_| {
                     Error::bad_database("Invalid server string in server_currenttransaction")
                 })?),
-                if value.is_empty() {
+                if event.starts_with(b"*") {
-                    SendingEventType::Pdu(event.to_vec())
+                    SendingEventType::Edu(event[1..].to_vec())
                 } else {
-                    SendingEventType::Edu(value)
+                    SendingEventType::Pdu(event.to_vec())
                 },
             )
         })
     }
 
-    #[tracing::instrument(skip(self, globals, destination, request))]
+    #[tracing::instrument(skip(self, globals))]
     pub async fn send_federation_request<T: OutgoingRequest>(
         &self,
         globals: &crate::database::globals::Globals,
@@ -784,7 +736,7 @@ impl Sending {
         response
     }
 
-    #[tracing::instrument(skip(self, globals, registration, request))]
+    #[tracing::instrument(skip(self, globals))]
     pub async fn send_appservice_request<T: OutgoingRequest>(
         &self,
         globals: &crate::database::globals::Globals,

src/database/uiaa.rs

@@ -4,14 +4,11 @@ use crate::{client_server::SESSION_ID_LENGTH, utils, Error, Result};
 use ruma::{
     api::client::{
         error::ErrorKind,
-        r0::uiaa::{
+        r0::uiaa::{IncomingAuthData, UiaaInfo},
-            IncomingAuthData, IncomingPassword, IncomingUserIdentifier::MatrixId, UiaaInfo,
-        },
     },
     signatures::CanonicalJsonValue,
     DeviceId, UserId,
 };
-use tracing::error;
 
 use super::abstraction::Tree;
 
@@ -52,8 +49,14 @@ impl Uiaa {
         users: &super::users::Users,
         globals: &super::globals::Globals,
     ) -> Result<(bool, UiaaInfo)> {
-        let mut uiaainfo = auth
+        if let IncomingAuthData::DirectRequest {
-            .session()
+            kind,
+            session,
+            auth_parameters,
+        } = &auth
+        {
+            let mut uiaainfo = session
+                .as_ref()
                 .map(|session| self.get_uiaa_session(&user_id, &device_id, session))
                 .unwrap_or_else(|| Ok(uiaainfo.clone()))?;
 
@@ -61,29 +64,55 @@ impl Uiaa {
                 uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
             }
 
-        match auth {
             // Find out what the user completed
-            IncomingAuthData::Password(IncomingPassword {
+            match &**kind {
-                identifier,
+                "m.login.password" => {
-                password,
+                    let identifier = auth_parameters.get("identifier").ok_or(Error::BadRequest(
-                ..
+                        ErrorKind::MissingParam,
-            }) => {
+                        "m.login.password needs identifier.",
-                let username = match identifier {
+                    ))?;
-                    MatrixId(username) => username,
+
-                    _ => {
+                    let identifier_type = identifier.get("type").ok_or(Error::BadRequest(
+                        ErrorKind::MissingParam,
+                        "Identifier needs a type.",
+                    ))?;
+
+                    if identifier_type != "m.id.user" {
                         return Err(Error::BadRequest(
                             ErrorKind::Unrecognized,
                             "Identifier type not recognized.",
-                        ))
+                        ));
                     }
-                };
 
-                let user_id =
+                    let username = identifier
-                    UserId::parse_with_server_name(username.clone(), globals.server_name())
+                        .get("user")
+                        .ok_or(Error::BadRequest(
+                            ErrorKind::MissingParam,
+                            "Identifier needs user field.",
+                        ))?
+                        .as_str()
+                        .ok_or(Error::BadRequest(
+                            ErrorKind::BadJson,
+                            "User is not a string.",
+                        ))?;
+
+                    let user_id = UserId::parse_with_server_name(username, globals.server_name())
                         .map_err(|_| {
                         Error::BadRequest(ErrorKind::InvalidParam, "User ID is invalid.")
                     })?;
 
+                    let password = auth_parameters
+                        .get("password")
+                        .ok_or(Error::BadRequest(
+                            ErrorKind::MissingParam,
+                            "Password is missing.",
+                        ))?
+                        .as_str()
+                        .ok_or(Error::BadRequest(
+                            ErrorKind::BadJson,
+                            "Password is not a string.",
+                        ))?;
+
                     // Check if password is correct
                     if let Some(hash) = users.password_hash(&user_id)? {
                         let hash_matches =
@@ -101,10 +130,10 @@ impl Uiaa {
                     // Password was correct! Let's add it to `completed`
                     uiaainfo.completed.push("m.login.password".to_owned());
                 }
-            IncomingAuthData::Dummy(_) => {
+                "m.login.dummy" => {
                     uiaainfo.completed.push("m.login.dummy".to_owned());
                 }
-            k => error!("type not supported: {:?}", k),
+                k => panic!("type not supported: {}", k),
             }
 
             // Check if a flow now succeeds
@@ -137,6 +166,9 @@ impl Uiaa {
                 None,
             )?;
             Ok((true, uiaainfo))
+        } else {
+            panic!("FallbackAcknowledgement is not supported yet");
+        }
     }
 
     fn set_uiaa_request(

src/database/users.rs

@@ -8,7 +8,6 @@ use ruma::{
     DeviceId, DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, UInt, UserId,
 };
 use std::{collections::BTreeMap, convert::TryFrom, mem, sync::Arc};
-use tracing::warn;
 
 use super::abstraction::Tree;
 
@@ -16,7 +15,6 @@ pub struct Users {
     pub(super) userid_password: Arc<dyn Tree>,
     pub(super) userid_displayname: Arc<dyn Tree>,
     pub(super) userid_avatarurl: Arc<dyn Tree>,
-    pub(super) userid_blurhash: Arc<dyn Tree>,
     pub(super) userdeviceid_token: Arc<dyn Tree>,
     pub(super) userdeviceid_metadata: Arc<dyn Tree>, // This is also used to check if a device exists
     pub(super) userid_devicelistversion: Arc<dyn Tree>, // DevicelistVersion = u64
@@ -35,13 +33,11 @@ pub struct Users {
 
 impl Users {
     /// Check if a user has an account on this homeserver.
-    #[tracing::instrument(skip(self, user_id))]
     pub fn exists(&self, user_id: &UserId) -> Result<bool> {
         Ok(self.userid_password.get(user_id.as_bytes())?.is_some())
     }
 
     /// Check if account is deactivated
-    #[tracing::instrument(skip(self, user_id))]
     pub fn is_deactivated(&self, user_id: &UserId) -> Result<bool> {
         Ok(self
             .userid_password
@@ -54,20 +50,17 @@ impl Users {
     }
 
     /// Create a new user account on this homeserver.
-    #[tracing::instrument(skip(self, user_id, password))]
     pub fn create(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
         self.set_password(user_id, password)?;
         Ok(())
     }
 
     /// Returns the number of users registered on this server.
-    #[tracing::instrument(skip(self))]
     pub fn count(&self) -> Result<usize> {
         Ok(self.userid_password.iter().count())
     }
 
     /// Find out which user an access token belongs to.
-    #[tracing::instrument(skip(self, token))]
     pub fn find_from_token(&self, token: &str) -> Result<Option<(UserId, String)>> {
         self.token_userdeviceid
             .get(token.as_bytes())?
@@ -95,7 +88,6 @@ impl Users {
     }
 
     /// Returns an iterator over all users on this homeserver.
-    #[tracing::instrument(skip(self))]
     pub fn iter(&self) -> impl Iterator<Item = Result<UserId>> + '_ {
         self.userid_password.iter().map(|(bytes, _)| {
             UserId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
@@ -106,7 +98,6 @@ impl Users {
     }
 
     /// Returns the password hash for the given user.
-    #[tracing::instrument(skip(self, user_id))]
     pub fn password_hash(&self, user_id: &UserId) -> Result<Option<String>> {
         self.userid_password
             .get(user_id.as_bytes())?
@@ -118,7 +109,6 @@ impl Users {
     }
 
     /// Hash and set the user's password to the Argon2 hash
-    #[tracing::instrument(skip(self, user_id, password))]
     pub fn set_password(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
         if let Some(password) = password {
             if let Ok(hash) = utils::calculate_hash(&password) {
@@ -138,7 +128,6 @@ impl Users {
     }
 
     /// Returns the displayname of a user on this homeserver.
-    #[tracing::instrument(skip(self, user_id))]
     pub fn displayname(&self, user_id: &UserId) -> Result<Option<String>> {
         self.userid_displayname
             .get(user_id.as_bytes())?
@@ -150,7 +139,6 @@ impl Users {
     }
 
     /// Sets a new displayname or removes it if displayname is None. You still need to nofify all rooms of this change.
-    #[tracing::instrument(skip(self, user_id, displayname))]
     pub fn set_displayname(&self, user_id: &UserId, displayname: Option<String>) -> Result<()> {
         if let Some(displayname) = displayname {
             self.userid_displayname
@@ -162,8 +150,7 @@ impl Users {
         Ok(())
     }
 
-    /// Get the avatar_url of a user.
+    /// Get a 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())?
@@ -176,7 +163,6 @@ impl Users {
     }
 
     /// Sets a new avatar_url or removes it if avatar_url is None.
-    #[tracing::instrument(skip(self, user_id, avatar_url))]
     pub fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<MxcUri>) -> Result<()> {
         if let Some(avatar_url) = avatar_url {
             self.userid_avatarurl
@@ -188,35 +174,7 @@ impl Users {
         Ok(())
     }
 
-    /// Get the blurhash of a user.
-    #[tracing::instrument(skip(self, user_id))]
-    pub fn blurhash(&self, user_id: &UserId) -> Result<Option<String>> {
-        self.userid_blurhash
-            .get(user_id.as_bytes())?
-            .map(|bytes| {
-                let s = utils::string_from_bytes(&bytes)
-                    .map_err(|_| Error::bad_database("Avatar URL in db is invalid."))?;
-
-                Ok(s)
-            })
-            .transpose()
-    }
-
-    /// Sets a new avatar_url or removes it if avatar_url is None.
-    #[tracing::instrument(skip(self, user_id, blurhash))]
-    pub fn set_blurhash(&self, user_id: &UserId, blurhash: Option<String>) -> Result<()> {
-        if let Some(blurhash) = blurhash {
-            self.userid_blurhash
-                .insert(user_id.as_bytes(), blurhash.as_bytes())?;
-        } else {
-            self.userid_blurhash.remove(user_id.as_bytes())?;
-        }
-
-        Ok(())
-    }
-
     /// Adds a new device to a user.
-    #[tracing::instrument(skip(self, user_id, device_id, token, initial_device_display_name))]
     pub fn create_device(
         &self,
         user_id: &UserId,
@@ -251,7 +209,6 @@ impl Users {
     }
 
     /// Removes a device from a user.
-    #[tracing::instrument(skip(self, user_id, device_id))]
     pub fn remove_device(&self, user_id: &UserId, device_id: &DeviceId) -> Result<()> {
         let mut userdeviceid = user_id.as_bytes().to_vec();
         userdeviceid.push(0xff);
@@ -282,7 +239,6 @@ impl Users {
     }
 
     /// Returns an iterator over all device ids of this user.
-    #[tracing::instrument(skip(self, user_id))]
     pub fn all_device_ids<'a>(
         &'a self,
         user_id: &UserId,
@@ -305,7 +261,6 @@ impl Users {
     }
 
     /// Replaces the access token of one device.
-    #[tracing::instrument(skip(self, user_id, device_id, token))]
     pub fn set_token(&self, user_id: &UserId, device_id: &DeviceId, token: &str) -> Result<()> {
         let mut userdeviceid = user_id.as_bytes().to_vec();
         userdeviceid.push(0xff);
@@ -329,14 +284,6 @@ impl Users {
         Ok(())
     }
 
-    #[tracing::instrument(skip(
-        self,
-        user_id,
-        device_id,
-        one_time_key_key,
-        one_time_key_value,
-        globals
-    ))]
     pub fn add_one_time_key(
         &self,
         user_id: &UserId,
@@ -373,7 +320,7 @@ impl Users {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, user_id))]
+    #[tracing::instrument(skip(self))]
     pub fn last_one_time_keys_update(&self, user_id: &UserId) -> Result<u64> {
         self.userid_lastonetimekeyupdate
             .get(&user_id.as_bytes())?
@@ -385,7 +332,6 @@ impl Users {
             .unwrap_or(Ok(0))
     }
 
-    #[tracing::instrument(skip(self, user_id, device_id, key_algorithm, globals))]
     pub fn take_one_time_key(
         &self,
         user_id: &UserId,
@@ -425,7 +371,7 @@ impl Users {
             .transpose()
     }
 
-    #[tracing::instrument(skip(self, user_id, device_id))]
+    #[tracing::instrument(skip(self))]
     pub fn count_one_time_keys(
         &self,
         user_id: &UserId,
@@ -458,7 +404,6 @@ impl Users {
         Ok(counts)
     }
 
-    #[tracing::instrument(skip(self, user_id, device_id, device_keys, rooms, globals))]
     pub fn add_device_keys(
         &self,
         user_id: &UserId,
@@ -481,14 +426,6 @@ impl Users {
         Ok(())
     }
 
-    #[tracing::instrument(skip(
-        self,
-        master_key,
-        self_signing_key,
-        user_signing_key,
-        rooms,
-        globals
-    ))]
     pub fn add_cross_signing_keys(
         &self,
         user_id: &UserId,
@@ -589,7 +526,6 @@ impl Users {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, target_id, key_id, signature, sender_id, rooms, globals))]
     pub fn sign_key(
         &self,
         target_id: &UserId,
@@ -633,7 +569,7 @@ impl Users {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, user_or_room_id, from, to))]
+    #[tracing::instrument(skip(self))]
     pub fn keys_changed<'a>(
         &'a self,
         user_or_room_id: &str,
@@ -646,24 +582,9 @@ impl Users {
         let mut start = prefix.clone();
         start.extend_from_slice(&(from + 1).to_be_bytes());
 
-        let to = to.unwrap_or(u64::MAX);
-
         self.keychangeid_userid
             .iter_from(&start, false)
-            .take_while(move |(k, _)| {
+            .take_while(move |(k, _)| k.starts_with(&prefix))
-                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.")
@@ -672,8 +593,7 @@ impl Users {
             })
     }
 
-    #[tracing::instrument(skip(self, user_id, rooms, globals))]
+    fn mark_device_key_update(
-    pub fn mark_device_key_update(
         &self,
         user_id: &UserId,
         rooms: &super::rooms::Rooms,
@@ -704,7 +624,6 @@ impl Users {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, user_id, device_id))]
     pub fn get_device_keys(
         &self,
         user_id: &UserId,
@@ -721,7 +640,6 @@ impl Users {
         })
     }
 
-    #[tracing::instrument(skip(self, user_id, allowed_signatures))]
     pub fn get_master_key<F: Fn(&UserId) -> bool>(
         &self,
         user_id: &UserId,
@@ -749,7 +667,6 @@ impl Users {
             })
     }
 
-    #[tracing::instrument(skip(self, user_id, allowed_signatures))]
     pub fn get_self_signing_key<F: Fn(&UserId) -> bool>(
         &self,
         user_id: &UserId,
@@ -777,7 +694,6 @@ impl Users {
             })
     }
 
-    #[tracing::instrument(skip(self, user_id))]
     pub fn get_user_signing_key(&self, user_id: &UserId) -> Result<Option<CrossSigningKey>> {
         self.userid_usersigningkeyid
             .get(user_id.as_bytes())?
@@ -790,15 +706,6 @@ impl Users {
             })
     }
 
-    #[tracing::instrument(skip(
-        self,
-        sender,
-        target_user_id,
-        target_device_id,
-        event_type,
-        content,
-        globals
-    ))]
     pub fn add_to_device_event(
         &self,
         sender: &UserId,
@@ -826,7 +733,7 @@ impl Users {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, user_id, device_id))]
+    #[tracing::instrument(skip(self))]
     pub fn get_to_device_events(
         &self,
         user_id: &UserId,
@@ -849,7 +756,7 @@ impl Users {
         Ok(events)
     }
 
-    #[tracing::instrument(skip(self, user_id, device_id, until))]
+    #[tracing::instrument(skip(self))]
     pub fn remove_to_device_events(
         &self,
         user_id: &UserId,
@@ -884,7 +791,6 @@ impl Users {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self, user_id, device_id, device))]
     pub fn update_device_metadata(
         &self,
         user_id: &UserId,
@@ -910,7 +816,6 @@ impl Users {
     }
 
     /// Get device metadata.
-    #[tracing::instrument(skip(self, user_id, device_id))]
     pub fn get_device_metadata(
         &self,
         user_id: &UserId,
@@ -929,7 +834,6 @@ impl Users {
             })
     }
 
-    #[tracing::instrument(skip(self, user_id))]
     pub fn get_devicelist_version(&self, user_id: &UserId) -> Result<Option<u64>> {
         self.userid_devicelistversion
             .get(user_id.as_bytes())?
@@ -940,7 +844,6 @@ impl Users {
             })
     }
 
-    #[tracing::instrument(skip(self, user_id))]
     pub fn all_devices_metadata<'a>(
         &'a self,
         user_id: &UserId,
@@ -957,7 +860,6 @@ impl Users {
     }
 
     /// Deactivate account
-    #[tracing::instrument(skip(self, user_id))]
     pub fn deactivate_account(&self, user_id: &UserId) -> Result<()> {
         // Remove all associated devices
         for device_id in self.all_device_ids(user_id) {

src/error.rs

@@ -1,3 +1,4 @@
+use log::{error, warn};
 use ruma::{
     api::client::{
         error::{Error as RumaError, ErrorKind},
@@ -6,7 +7,6 @@ use ruma::{
     ServerName,
 };
 use thiserror::Error;
-use tracing::warn;
 
 #[cfg(feature = "conduit_bin")]
 use {
@@ -17,7 +17,6 @@ use {
         Request,
     },
     ruma::api::client::r0::uiaa::UiaaResponse,
-    tracing::error,
 };
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -30,15 +29,18 @@ pub enum Error {
         #[from]
         source: sled::Error,
     },
+    #[cfg(feature = "rocksdb")]
+    #[error("There was a problem with the connection to the rocksdb database: {source}")]
+    RocksDbError {
+        #[from]
+        source: rocksdb::Error,
+    },
     #[cfg(feature = "sqlite")]
     #[error("There was a problem with the connection to the sqlite database: {source}")]
     SqliteError {
         #[from]
         source: rusqlite::Error,
     },
-    #[cfg(feature = "heed")]
-    #[error("There was a problem with the connection to the heed database: {error}")]
-    HeedError { error: String },
     #[error("Could not generate an image.")]
     ImageError {
         #[from]

src/lib.rs

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

src/main.rs

@@ -17,7 +17,6 @@ use std::sync::Arc;
 use database::Config;
 pub use database::Database;
 pub use error::{Error, Result};
-use opentelemetry::trace::{FutureExt, Tracer};
 pub use pdu::PduEvent;
 pub use rocket::State;
 use ruma::api::client::error::ErrorKind;
@@ -32,7 +31,8 @@ use rocket::{
     routes, Request,
 };
 use tokio::sync::RwLock;
-use tracing_subscriber::{prelude::*, EnvFilter};
+use tracing::span;
+use tracing_subscriber::{prelude::*, Registry};
 
 fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<rocket::Build> {
     rocket::custom(config)
@@ -50,7 +50,6 @@ fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<
                 client_server::logout_all_route,
                 client_server::change_password_route,
                 client_server::deactivate_route,
-                client_server::third_party_route,
                 client_server::get_capabilities_route,
                 client_server::get_pushrules_all_route,
                 client_server::set_pushrule_route,
@@ -61,7 +60,6 @@ fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<
                 client_server::set_pushrule_actions_route,
                 client_server::delete_pushrule_route,
                 client_server::get_room_event_route,
-                client_server::get_room_aliases_route,
                 client_server::get_filter_route,
                 client_server::create_filter_route,
                 client_server::set_global_account_data_route,
@@ -160,8 +158,7 @@ fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<
                 server_server::get_room_state_route,
                 server_server::get_room_state_ids_route,
                 server_server::create_join_event_template_route,
-                server_server::create_join_event_v1_route,
+                server_server::create_join_event_route,
-                server_server::create_join_event_v2_route,
                 server_server::create_invite_route,
                 server_server::get_devices_route,
                 server_server::get_room_information_route,
@@ -188,7 +185,7 @@ async fn main() {
     std::env::set_var("CONDUIT_LOG_LEVEL", "off");
 
     let raw_config =
-        Figment::from(default_config())
+        Figment::from(rocket::Config::release_default())
             .merge(
                 Toml::file(Env::var("CONDUIT_CONFIG").expect(
                     "The CONDUIT_CONFIG env var needs to be set. Example: /etc/conduit.toml",
@@ -203,60 +200,32 @@ async fn main() {
         .extract::<Config>()
         .expect("It looks like your config is invalid. Please take a look at the error");
 
-    let start = async {
+    let mut _span: Option<span::Span> = None;
+    let mut _enter: Option<span::Entered<'_>> = None;
+
+    if config.allow_jaeger {
+        let (tracer, _uninstall) = opentelemetry_jaeger::new_pipeline()
+            .with_service_name("conduit")
+            .install()
+            .unwrap();
+        let telemetry = tracing_opentelemetry::layer().with_tracer(tracer);
+        Registry::default().with(telemetry).try_init().unwrap();
+
+        _span = Some(span!(tracing::Level::INFO, "app_start", work_units = 2));
+        _enter = Some(_span.as_ref().unwrap().enter());
+    } else {
+        std::env::set_var("RUST_LOG", &config.log);
+        tracing_subscriber::fmt::init();
+    }
+
     config.warn_deprecated();
 
-        let db = Database::load_or_create(&config)
+    let db = Database::load_or_create(config)
         .await
         .expect("config is valid");
 
-        let rocket = setup_rocket(raw_config, Arc::clone(&db))
+    let rocket = setup_rocket(raw_config, db);
-            .ignite()
-            .await
-            .unwrap();
-
-        Database::start_on_shutdown_tasks(db, rocket.shutdown()).await;
-
     rocket.launch().await.unwrap();
-    };
-
-    if config.allow_jaeger {
-        opentelemetry::global::set_text_map_propagator(opentelemetry_jaeger::Propagator::new());
-        let tracer = opentelemetry_jaeger::new_pipeline()
-            .install_batch(opentelemetry::runtime::Tokio)
-            .unwrap();
-
-        let span = tracer.start("conduit");
-        start.with_current_context().await;
-        drop(span);
-
-        println!("exporting");
-        opentelemetry::global::shutdown_tracer_provider();
-    } else {
-        std::env::set_var("RUST_LOG", &config.log);
-
-        let registry = tracing_subscriber::Registry::default();
-        if config.tracing_flame {
-            let (flame_layer, _guard) =
-                tracing_flame::FlameLayer::with_file("./tracing.folded").unwrap();
-            let flame_layer = flame_layer.with_empty_samples(false);
-
-            let filter_layer = EnvFilter::new("trace,h2=off");
-
-            let subscriber = registry.with(filter_layer).with(flame_layer);
-            tracing::subscriber::set_global_default(subscriber).unwrap();
-            start.await;
-        } else {
-            let fmt_layer = tracing_subscriber::fmt::Layer::new();
-            let filter_layer = EnvFilter::try_from_default_env()
-                .or_else(|_| EnvFilter::try_new("info"))
-                .unwrap();
-
-            let subscriber = registry.with(filter_layer).with(fmt_layer);
-            tracing::subscriber::set_global_default(subscriber).unwrap();
-            start.await;
-        }
-    }
 }
 
 #[catch(404)]
@@ -286,30 +255,3 @@ fn missing_token_catcher() -> Result<()> {
 fn bad_json_catcher() -> Result<()> {
     Err(Error::BadRequest(ErrorKind::BadJson, "Bad json."))
 }
-
-fn default_config() -> rocket::Config {
-    let mut config = rocket::Config::release_default();
-
-    {
-        let mut shutdown = &mut config.shutdown;
-
-        #[cfg(unix)]
-        {
-            use rocket::config::Sig;
-
-            shutdown.signals.insert(Sig::Term);
-            shutdown.signals.insert(Sig::Int);
-        }
-
-        // Once shutdown is triggered, this is the amount of seconds before rocket
-        // will forcefully start shutting down connections, this gives enough time to /sync
-        // requests and the like (which havent gotten the memo, somehow) to still complete gracefully.
-        shutdown.grace = 35;
-
-        // After the grace period, rocket starts shutting down connections, and waits at least this
-        // many seconds before forcefully shutting all of them down.
-        shutdown.mercy = 10;
-    }
-
-    config
-}

src/pdu.rs

@@ -1,9 +1,10 @@
 use crate::Error;
+use log::error;
 use ruma::{
     events::{
-        pdu::EventHash, room::member::MemberEventContent, AnyEphemeralRoomEvent,
+        pdu::EventHash, room::member::MemberEventContent, AnyEphemeralRoomEvent, AnyRoomEvent,
-        AnyInitialStateEvent, AnyRoomEvent, AnyStateEvent, AnyStrippedStateEvent, AnySyncRoomEvent,
+        AnyStateEvent, AnyStrippedStateEvent, AnySyncRoomEvent, AnySyncStateEvent, EventType,
-        AnySyncStateEvent, EventType, StateEvent,
+        StateEvent,
     },
     serde::{CanonicalJsonObject, CanonicalJsonValue, Raw},
     state_res, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, ServerName,
@@ -12,7 +13,6 @@ use ruma::{
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use std::{cmp::Ordering, collections::BTreeMap, convert::TryFrom};
-use tracing::warn;
 
 #[derive(Clone, Deserialize, Serialize, Debug)]
 pub struct PduEvent {
@@ -322,13 +322,12 @@ pub(crate) fn gen_event_id_canonical_json(
     pdu: &Raw<ruma::events::pdu::Pdu>,
 ) -> crate::Result<(EventId, CanonicalJsonObject)> {
     let value = serde_json::from_str(pdu.json().get()).map_err(|e| {
-        warn!("Error parsing incoming event {:?}: {:?}", pdu, e);
+        error!("{:?}: {:?}", pdu, e);
         Error::BadServerResponse("Invalid PDU in server response")
     })?;
 
     let event_id = EventId::try_from(&*format!(
         "${}",
-        // Anything higher than version3 behaves the same
         ruma::signatures::reference_hash(&value, &RoomVersionId::Version6)
             .expect("ruma can calculate reference hashes")
     ))
@@ -347,17 +346,3 @@ pub struct PduBuilder {
     pub state_key: Option<String>,
     pub redacts: Option<EventId>,
 }
-
-/// Direct conversion prevents loss of the empty `state_key` that ruma requires.
-impl From<AnyInitialStateEvent> for PduBuilder {
-    fn from(event: AnyInitialStateEvent) -> Self {
-        Self {
-            event_type: EventType::from(event.event_type()),
-            content: serde_json::value::to_value(event.content())
-                .expect("AnyStateEventContent came from JSON and can thus turn back into JSON."),
-            unsigned: None,
-            state_key: Some(event.state_key().to_owned()),
-            redacts: None,
-        }
-    }
-}

src/ruma_wrapper.rs

@@ -10,6 +10,7 @@ use std::ops::Deref;
 #[cfg(feature = "conduit_bin")]
 use {
     crate::server_server,
+    log::{debug, warn},
     rocket::{
         data::{self, ByteUnit, Data, FromData},
         http::Status,
@@ -22,7 +23,6 @@ use {
     std::collections::BTreeMap,
     std::convert::TryFrom,
     std::io::Cursor,
-    tracing::{debug, warn},
 };
 
 /// This struct converts rocket requests into ruma structs by converting them into http requests
@@ -45,11 +45,7 @@ where
 {
     type Error = ();
 
-    #[tracing::instrument(skip(request, data))]
+    async fn from_data(request: &'a Request<'_>, data: Data) -> data::Outcome<Self, Self::Error> {
-    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::<DatabaseGuard>()
@@ -75,9 +71,9 @@ where
             registration,
         )) = db
             .appservice
-            .all()
+            .iter_all()
             .unwrap()
-            .iter()
+            .filter_map(|r| r.ok())
             .find(|(_id, registration)| {
                 registration
                     .get("as_token")
@@ -106,7 +102,7 @@ where
 
                     if !db.users.exists(&user_id).unwrap() {
                         // Forbidden
-                        return Failure((Status::new(580), ()));
+                        return Failure((Status::raw(580), ()));
                     }
 
                     // TODO: Check if appservice is allowed to be that user
@@ -121,7 +117,7 @@ where
                     if let Some(token) = token {
                         match db.users.find_from_token(&token).unwrap() {
                             // Unknown Token
-                            None => return Failure((Status::new(581), ())),
+                            None => return Failure((Status::raw(581), ())),
                             Some((user_id, device_id)) => (
                                 Some(user_id),
                                 Some(Box::<DeviceId>::from(device_id)),
@@ -131,7 +127,7 @@ where
                         }
                     } else {
                         // Missing Token
-                        return Failure((Status::new(582), ()));
+                        return Failure((Status::raw(582), ()));
                     }
                 }
                 AuthScheme::ServerSignatures => {
@@ -153,7 +149,7 @@ where
                             warn!("No Authorization header");
 
                             // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                         }
                     };
 
@@ -163,7 +159,7 @@ where
                             warn!("Invalid X-Matrix header origin field: {:?}", x_matrix);
 
                             // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                         }
                     };
 
@@ -176,7 +172,7 @@ where
                             );
 
                             // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                         }
                     };
 
@@ -186,7 +182,7 @@ where
                             warn!("Invalid X-Matrix header key field: {:?}", x_matrix);
 
                             // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                         }
                     };
 
@@ -196,7 +192,7 @@ where
                             warn!("Invalid X-Matrix header sig field: {:?}", x_matrix);
 
                             // Forbidden
-                            return Failure((Status::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                         }
                     };
 
@@ -247,7 +243,7 @@ where
                                 warn!("Failed to fetch signing keys: {}", e);
 
                                 // Forbidden
-                                return Failure((Status::new(580), ()));
+                                return Failure((Status::raw(580), ()));
                             }
                         };
 
@@ -257,17 +253,14 @@ where
                     match ruma::signatures::verify_json(&pub_key_map, &request_map) {
                         Ok(()) => (None, None, Some(origin), false),
                         Err(e) => {
-                            warn!(
+                            warn!("Failed to verify json request from {}: {}", origin, e);
-                                "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::new(580), ()));
+                            return Failure((Status::raw(580), ()));
                         }
                     }
                 }
@@ -325,7 +318,7 @@ where
             Err(e) => {
                 warn!("{:?}", e);
                 // Bad Json
-                Failure((Status::new(583), ()))
+                Failure((Status::raw(583), ()))
             }
         }
     }
@@ -351,7 +344,7 @@ pub fn response<T: OutgoingResponse>(response: RumaResponse<T>) -> response::Res
     let mut response = rocket::response::Response::build();
 
     let status = http_response.status();
-    response.status(Status::new(status.as_u16()));
+    response.raw_status(status.into(), "");
 
     for header in http_response.headers() {
         response.raw_header(header.0.to_string(), header.1.to_str().unwrap().to_owned());

src/utils.rs

@@ -9,7 +9,6 @@ use std::{
     time::{SystemTime, UNIX_EPOCH},
 };
 
-#[tracing::instrument]
 pub fn millis_since_unix_epoch() -> u64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -17,6 +16,15 @@ pub fn millis_since_unix_epoch() -> u64 {
         .as_millis() as u64
 }
 
+#[cfg(feature = "rocksdb")]
+pub fn increment_rocksdb(
+    _new_key: &[u8],
+    old: Option<&[u8]>,
+    _operands: &mut rocksdb::MergeOperands,
+) -> Option<Vec<u8>> {
+    increment(old)
+}
+
 pub fn increment(old: Option<&[u8]>) -> Option<Vec<u8>> {
     let number = match old.map(|bytes| bytes.try_into()) {
         Some(Ok(bytes)) => {
@@ -40,19 +48,16 @@ pub fn generate_keypair() -> Vec<u8> {
 }
 
 /// Parses the bytes into an u64.
-#[tracing::instrument(skip(bytes))]
 pub fn u64_from_bytes(bytes: &[u8]) -> Result<u64, std::array::TryFromSliceError> {
     let array: [u8; 8] = bytes.try_into()?;
     Ok(u64::from_be_bytes(array))
 }
 
 /// Parses the bytes into a string.
-#[tracing::instrument(skip(bytes))]
 pub fn string_from_bytes(bytes: &[u8]) -> Result<String, std::string::FromUtf8Error> {
     String::from_utf8(bytes.to_vec())
 }
 
-#[tracing::instrument(skip(length))]
 pub fn random_string(length: usize) -> String {
     thread_rng()
         .sample_iter(&rand::distributions::Alphanumeric)
@@ -62,7 +67,6 @@ pub fn random_string(length: usize) -> String {
 }
 
 /// Calculate a new hash for the given password
-#[tracing::instrument(skip(password))]
 pub fn calculate_hash(password: &str) -> Result<String, argon2::Error> {
     let hashing_config = Config {
         variant: Variant::Argon2id,
@@ -73,7 +77,6 @@ pub fn calculate_hash(password: &str) -> Result<String, argon2::Error> {
     argon2::hash_encoded(password.as_bytes(), salt.as_bytes(), &hashing_config)
 }
 
-#[tracing::instrument(skip(iterators, check_order))]
 pub fn common_elements(
     mut iterators: impl Iterator<Item = impl Iterator<Item = Vec<u8>>>,
     check_order: impl Fn(&[u8], &[u8]) -> Ordering,
@@ -101,7 +104,6 @@ pub fn common_elements(
 /// Fallible conversion from any value that implements `Serialize` to a `CanonicalJsonObject`.
 ///
 /// `value` must serialize to an `serde_json::Value::Object`.
-#[tracing::instrument(skip(value))]
 pub fn to_canonical_object<T: serde::Serialize>(
     value: T,
 ) -> Result<CanonicalJsonObject, CanonicalJsonError> {
@@ -115,7 +117,6 @@ pub fn to_canonical_object<T: serde::Serialize>(
     }
 }
 
-#[tracing::instrument(skip(deserializer))]
 pub fn deserialize_from_str<
     'de,
     D: serde::de::Deserializer<'de>,
@@ -136,7 +137,7 @@ pub fn deserialize_from_str<
         where
             E: serde::de::Error,
         {
-            v.parse().map_err(serde::de::Error::custom)
+            v.parse().map_err(|e| serde::de::Error::custom(e))
         }
     }
     deserializer.deserialize_str(Visitor(std::marker::PhantomData))

tests/client-element-web/test-element-web-registration.js

@@ -1,101 +0,0 @@
-const puppeteer = require('puppeteer');
-
-run().then(() => console.log('Done')).catch(error => {
-    console.error("Registration test failed.");
-    console.error("There might be a screenshot of the failure in the artifacts.\n");
-    console.error(error);
-    process.exit(111);
-});
-
-async function run() {
-
-    const elementUrl = process.argv[process.argv.length - 2];
-    console.debug("Testing registration with ElementWeb hosted at "+ elementUrl);
-
-    const homeserverUrl = process.argv[process.argv.length - 1];
-    console.debug("Homeserver url: "+ homeserverUrl);
-
-    const username = "testuser" + String(Math.floor(Math.random() * 100000));
-    const password = "testpassword" + String(Math.floor(Math.random() * 100000));
-    console.debug("Testuser for this run:\n  User: " + username + "\n  Password: " + password);
-
-    const browser = await puppeteer.launch({
-        headless: true, args: [
-            "--no-sandbox"
-        ]
-    });
-
-    const page = await browser.newPage();
-    await page.goto(elementUrl);
-
-    await page.screenshot({ path: '01-element-web-opened.png' });
-
-    console.debug("Click [Create Account] button");
-    await page.waitForSelector('a.mx_ButtonCreateAccount');
-    await page.click('a.mx_ButtonCreateAccount');
-
-    await page.screenshot({ path: '02-clicked-create-account-button.png' });
-
-    // The webapp should have loaded right now, if anything takes more than 5 seconds, something probably broke
-    page.setDefaultTimeout(5000);
-
-    console.debug("Click [Edit] to switch homeserver");
-    await page.waitForSelector('div.mx_ServerPicker_change');
-    await page.click('div.mx_ServerPicker_change');
-
-    await page.screenshot({ path: '03-clicked-edit-homeserver-button.png' });
-
-    console.debug("Type in local homeserver url");
-    await page.waitForSelector('input#mx_homeserverInput');
-    await page.click('input#mx_homeserverInput');
-    await page.click('input#mx_homeserverInput');
-    await page.keyboard.type(homeserverUrl);
-
-    await page.screenshot({ path: '04-typed-in-homeserver.png' });
-
-    console.debug("[Continue] with changed homeserver");
-    await page.waitForSelector("div.mx_ServerPickerDialog_continue");
-    await page.click('div.mx_ServerPickerDialog_continue');
-
-    await page.screenshot({ path: '05-back-to-enter-user-credentials.png' });
-
-    console.debug("Type in username");
-    await page.waitForSelector("input#mx_RegistrationForm_username");
-    await page.click('input#mx_RegistrationForm_username');
-    await page.keyboard.type(username);
-
-    await page.screenshot({ path: '06-typed-in-username.png' });
-
-    console.debug("Type in password");
-    await page.waitForSelector("input#mx_RegistrationForm_password");
-    await page.click('input#mx_RegistrationForm_password');
-    await page.keyboard.type(password);
-
-    await page.screenshot({ path: '07-typed-in-password-once.png' });
-
-    console.debug("Type in password again");
-    await page.waitForSelector("input#mx_RegistrationForm_passwordConfirm");
-    await page.click('input#mx_RegistrationForm_passwordConfirm');
-    await page.keyboard.type(password);
-
-    await page.screenshot({ path: '08-typed-in-password-twice.png' });
-
-    console.debug("Click on [Register] to finish the account creation");
-    await page.waitForSelector("input.mx_Login_submit");
-    await page.click('input.mx_Login_submit');
-
-    await page.screenshot({ path: '09-clicked-on-register-button.png' });
-
-    // Waiting for the app to login can take some time, so be patient.
-    page.setDefaultTimeout(10000);
-
-    console.debug("Wait for chat window to show up");
-    await page.waitForSelector("div.mx_HomePage_default_buttons");
-    console.debug("Apparently the registration worked.");
-
-    await page.screenshot({ path: '10-logged-in-homescreen.png' });
-
-
-    // Close the browser and exit the script
-    await browser.close();
-}

tests/test-config.toml

@@ -1,15 +0,0 @@
-[global]
-
-# Server runs in same container as tests do, so localhost is fine
-server_name = "localhost"
-
-# With a bit of luck /tmp is a RAM disk, so that the file system does not become the bottleneck while testing
-database_path = "/tmp"
-
-# All the other settings are left at their defaults:
-port = 6167
-max_request_size = 20_000_000
-allow_registration = true
-trusted_servers = ["matrix.org"]
-address = "127.0.0.1"
-proxy = "none"