WIP: First attempt at propper docker multiarch

.dockerignore

@@ -14,8 +14,6 @@ docker-compose*
 # Git folder
 .git
 .gitea
-.gitlab
-.github
 
 # Dot files
 .env

.gitlab-ci.yml

@@ -9,6 +9,7 @@ variables:
   FF_USE_FASTZIP: 1
   CACHE_COMPRESSION_LEVEL: fastest
 
+
 # --------------------------------------------------------------------- #
 #  Cargo: Compiling for different architectures                         #
 # --------------------------------------------------------------------- #
@@ -19,46 +20,48 @@ variables:
   rules:
     - if: '$CI_COMMIT_BRANCH == "master"'
     - if: '$CI_COMMIT_BRANCH == "next"'
-    - if: "$CI_COMMIT_TAG"
+    # TODO: Remove this after debugging
+    - if: '$CI_COMMIT_BRANCH == "multiarch-docker-support"'
+    - if: '$CI_COMMIT_TAG'
   interruptible: true
-  image: "rust:latest"
+  image: "rust:1.56.0"
   tags: ["docker"]
   cache:
     paths:
       - cargohome
       - target/
-    key: "build_cache--$TARGET--$CI_COMMIT_BRANCH--release"
+    key: "build_cache-$TARGET-release"
   variables:
-    CARGO_PROFILE_RELEASE_LTO: "true"
+    CARGO_PROFILE_RELEASE_LTO: "off" # TODO: change to true again
-    CARGO_PROFILE_RELEASE_CODEGEN_UNITS: "1"
+    CARGO_PROFILE_RELEASE_CODEGEN_UNITS: "256" # TODO: Change to 1 again
+    RUSTUP_HOME: "/root/.rustup"
   before_script:
+    - echo $USER
+    - export PATH="root/.cargo/bin:$PATH"
     - 'echo "Building for target $TARGET"'
     - 'mkdir -p cargohome && CARGOHOME="cargohome"'
-    - "rustc --version && cargo --version && rustup show" # Print version info for debugging
+    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
-    - "rustup target add $TARGET"
+    - 'time rustup target add "$TARGET"'
   script:
     - time cargo build --target $TARGET --release
-    - 'cp "target/$TARGET/release/conduit" "conduit-$TARGET"'
+    - 'mv "target/$TARGET/release/conduit" "conduit-$TARGET"'
   artifacts:
     expire_in: never
 
-build:release:cargo:x86_64-unknown-linux-musl-with-debug:
+
+build:release:cargo:x86_64-unknown-linux-gnu:
   extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:x86_64-musl
   variables:
-    CARGO_PROFILE_RELEASE_DEBUG: 2 # Enable debug info for flamegraph profiling
+    TARGET: "x86_64-unknown-linux-gnu"
-    TARGET: "x86_64-unknown-linux-musl"
-  after_script:
-    - "mv ./conduit-x86_64-unknown-linux-musl ./conduit-x86_64-unknown-linux-musl-with-debug"
   artifacts:
-    name: "conduit-x86_64-unknown-linux-musl-with-debug"
+    name: "conduit-x86_64-unknown-linux-gnu"
     paths:
-      - "conduit-x86_64-unknown-linux-musl-with-debug"
+      - "conduit-x86_64-unknown-linux-gnu"
-    expose_as: "Conduit for x86_64-unknown-linux-musl-with-debug"
+    expose_as: "Conduit for x86_64-unknown-linux-gnu"
 
 build:release:cargo:x86_64-unknown-linux-musl:
+  image: registry.gitlab.fachschaften.org/jfowl/cargo-cross-for-ci/cargo-cross-builder:rust1.56.0-x86_64-unknown-linux-musl
   extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:x86_64-musl
   variables:
     TARGET: "x86_64-unknown-linux-musl"
   artifacts:
@@ -67,20 +70,23 @@ build:release:cargo:x86_64-unknown-linux-musl:
       - "conduit-x86_64-unknown-linux-musl"
     expose_as: "Conduit for x86_64-unknown-linux-musl"
 
-build:release:cargo:arm-unknown-linux-musleabihf:
+
+build:release:cargo:armv7-unknown-linux-gnueabihf:
   extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:arm-musleabihf
+  image:
+    name: registry.gitlab.fachschaften.org/jfowl/cargo-cross-for-ci/cargo-cross-builder:rust1.56.0-armv7-unknown-linux-gnueabihf
   variables:
-    TARGET: "arm-unknown-linux-musleabihf"
+    TARGET: "armv7-unknown-linux-gnueabihf"
   artifacts:
-    name: "conduit-arm-unknown-linux-musleabihf"
+    name: "conduit-armv7-unknown-linux-gnueabihf"
     paths:
-      - "conduit-arm-unknown-linux-musleabihf"
+      - "conduit-armv7-unknown-linux-gnueabihf"
-    expose_as: "Conduit for arm-unknown-linux-musleabihf"
+    expose_as: "Conduit for armv7-unknown-linux-gnueabihf"
 
 build:release:cargo:armv7-unknown-linux-musleabihf:
   extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:armv7-musleabihf
+  image:
+    name: registry.gitlab.fachschaften.org/jfowl/cargo-cross-for-ci/cargo-cross-builder:rust1.56.0-armv7-unknown-linux-musleabihf
   variables:
     TARGET: "armv7-unknown-linux-musleabihf"
   artifacts:
@@ -89,9 +95,21 @@ build:release:cargo:armv7-unknown-linux-musleabihf:
       - "conduit-armv7-unknown-linux-musleabihf"
     expose_as: "Conduit for armv7-unknown-linux-musleabihf"
 
+
+build:release:cargo:aarch64-unknown-linux-gnu:
+  image: registry.gitlab.fachschaften.org/jfowl/cargo-cross-for-ci/cargo-cross-builder:rust1.56.0-aarch64-unknown-linux-gnu
+  extends: .build-cargo-shared-settings
+  variables:
+    TARGET: "aarch64-unknown-linux-gnu"
+  artifacts:
+    name: "conduit-aarch64-unknown-linux-gnu"
+    paths:
+      - "conduit-aarch64-unknown-linux-gnu"
+    expose_as: "Conduit for aarch64-unknown-linux-gnu"
+
 build:release:cargo:aarch64-unknown-linux-musl:
+  image: registry.gitlab.fachschaften.org/jfowl/cargo-cross-for-ci/cargo-cross-builder:rust1.56.0-aarch64-unknown-linux-musl
   extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:aarch64-musl
   variables:
     TARGET: "aarch64-unknown-linux-musl"
   artifacts:
@@ -100,34 +118,182 @@ build:release:cargo:aarch64-unknown-linux-musl:
       - "conduit-aarch64-unknown-linux-musl"
     expose_as: "Conduit for aarch64-unknown-linux-musl"
 
+
+
 .cargo-debug-shared-settings:
   extends: ".build-cargo-shared-settings"
   rules:
-    - if: '$CI_COMMIT_BRANCH != "master"'
+    - if: '$CI_COMMIT_BRANCH'
+    - if: '$CI_COMMIT_TAG'
   cache:
-    key: "build_cache--$TARGET--$CI_COMMIT_BRANCH--debug"
+    key: "build_cache-$TARGET-debug"
   script:
     - "time cargo build --target $TARGET"
     - 'mv "target/$TARGET/debug/conduit" "conduit-debug-$TARGET"'
   artifacts:
     expire_in: 4 weeks
 
+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: messense/rust-musl-cross:x86_64-musl
+  image: "rust:alpine"
   variables:
     TARGET: "x86_64-unknown-linux-musl"
+  before_script:
+    - 'echo "Building for target $TARGET"'
+    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
+    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
+    - "rustup target add $TARGET"
+    - "apk add libc-dev"
   artifacts:
     name: "conduit-debug-x86_64-unknown-linux-musl"
     paths:
       - "conduit-debug-x86_64-unknown-linux-musl"
     expose_as: "Conduit DEBUG for x86_64-unknown-linux-musl"
 
+
+
+# --------------------------------------------------------------------- #
+#  Cargo: Compiling deb packages for different architectures            #
+# --------------------------------------------------------------------- #
+
+
+.build-cargo-deb-shared-settings:
+  stage: "build"
+  needs: [ ]
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "master"'
+    - if: '$CI_COMMIT_BRANCH == "next"'
+    - if: '$CI_COMMIT_TAG'
+  interruptible: true
+  image: "rust:latest"
+  tags: ["docker"]
+  cache:
+    paths:
+      - cargohome
+      - target/
+    key: "build_cache-deb-$TARGET"
+  before_script:
+    - 'echo "Building debian package for target $TARGET"'
+    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
+    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
+    - 'apt-get update -yqq'
+    - 'echo "Installing packages: $NEEDED_PACKAGES"'
+    - "apt-get install -yqq --no-install-recommends $NEEDED_PACKAGES"
+    - "rustup target add $TARGET"
+    - "cargo install cargo-deb"
+  script:
+    - time cargo deb --target $TARGET
+    - 'mv target/$TARGET/debian/*.deb "conduit-$TARGET.deb"'
+
+build:cargo-deb:x86_64-unknown-linux-gnu:
+  extends: .build-cargo-deb-shared-settings
+  variables:
+    TARGET: "x86_64-unknown-linux-gnu"
+    NEEDED_PACKAGES: ""
+  artifacts:
+    name: "conduit-x86_64-unknown-linux-gnu.deb"
+    paths:
+      - "conduit-x86_64-unknown-linux-gnu.deb"
+    expose_as: "Debian Package x86_64"
+
+
 # --------------------------------------------------------------------- #
 #  Create and publish docker image                                      #
 # --------------------------------------------------------------------- #
 
+# Build a docker image by packaging up the x86_64-unknown-linux-musl binary into an alpine image
 .docker-shared-settings:
+  stage: "build docker image"
+  needs: []
+  interruptible: true
+  image:
+    name: "gcr.io/kaniko-project/executor:debug"
+    entrypoint: [""]
+  tags: ["docker"]
+  variables:
+    # Configure Kaniko Caching: https://cloud.google.com/build/docs/kaniko-cache
+    KANIKO_CACHE_ARGS: "--cache=true --cache-copy-layers=true --cache-ttl=120h --cache-repo $CI_REGISTRY_IMAGE/kaniko-ci-cache"
+  before_script:
+    - "mkdir -p /kaniko/.docker"
+    - 'echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"},\"$DOCKER_HUB\":{\"username\":\"$DOCKER_HUB_USER\",\"password\":\"$DOCKER_HUB_PASSWORD\"}}}" > /kaniko/.docker/config.json'
+
+build:docker:next:
+  extends: .docker-shared-settings
+  needs:
+    - "build:release:cargo:x86_64-unknown-linux-musl"
+  script:
+    - >
+      /kaniko/executor
+      $KANIKO_CACHE_ARGS
+      --force
+      --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_SHORT_SHA"
+      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
+      --destination "$CI_REGISTRY_IMAGE/conduit:next"
+      --destination "$CI_REGISTRY_IMAGE/conduit:next-alpine"
+      --destination "$CI_REGISTRY_IMAGE/conduit:commit-$CI_COMMIT_SHORT_SHA"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next-alpine"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:commit-$CI_COMMIT_SHORT_SHA"
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "next"'
+
+
+build:docker:master:
+  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_SHORT_SHA"
+      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
+      --destination "$CI_REGISTRY_IMAGE/conduit:latest"
+      --destination "$CI_REGISTRY_IMAGE/conduit:latest-alpine"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest-alpine"
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "master"'
+
+
+build:docker:tags:
+  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_SHORT_SHA"
+      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
+      --destination "$CI_REGISTRY_IMAGE/conduit:$CI_COMMIT_TAG"
+      --destination "$CI_REGISTRY_IMAGE/conduit:$CI_COMMIT_TAG-alpine"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:$CI_COMMIT_TAG"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:$CI_COMMIT_TAG-alpine"
+  rules:
+    - if: '$CI_COMMIT_TAG'
+
+
+build:docker:new-way-of-building:
   stage: "build docker image"
   image: jdrouet/docker-with-buildx:stable
   tags: ["docker"]
@@ -135,76 +301,32 @@ build:debug:cargo:x86_64-unknown-linux-musl:
   - docker:dind
   needs:
     - "build:release:cargo:x86_64-unknown-linux-musl"
-    - "build:release:cargo:arm-unknown-linux-musleabihf"
+  rules:
-    - "build:release:cargo:armv7-unknown-linux-musleabihf"
+    - if: '$CI_COMMIT_BRANCH == "master"'
-    - "build:release:cargo:aarch64-unknown-linux-musl"
+    - if: '$CI_COMMIT_BRANCH == "next"'
+    # TODO: Remove this after debugging
+    - if: '$CI_COMMIT_BRANCH == "multiarch-docker-support"'
   variables:
     DOCKER_HOST: tcp://docker:2375/
     DOCKER_TLS_CERTDIR: ""
     DOCKER_DRIVER: overlay2
-    PLATFORMS: "linux/arm/v6,linux/arm/v7,linux/arm64,linux/amd64"
+    # PLATFORMS: "linux/arm/v7,linux/arm64/v8,linux/amd64"
+    PLATFORMS: "linux/amd64"
+    IMAGE_TAG: "$CI_REGISTRY_IMAGE/debug-conduit:multiarch-test-dont-use-yet"
     DOCKER_FILE: "docker/ci-binaries-packaging.Dockerfile"
-  cache:
-    paths:
-      - docker_cache
-    key: "$CI_JOB_NAME"
   before_script:
     - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
-    # Only log in to Dockerhub if the credentials are given:
-    - if [ -n "${DOCKER_HUB}" ]; then docker login -u "$DOCKER_HUB_USER" -p "$DOCKER_HUB_PASSWORD" "$DOCKER_HUB"; fi
   script:
     # Prepare buildx to build multiarch stuff:
     - docker context create 'ci-context'
     - docker buildx create --name 'multiarch-builder' --use 'ci-context'
     # Copy binaries to their docker arch path
     - mkdir -p linux/ && mv ./conduit-x86_64-unknown-linux-musl linux/amd64
-    - mkdir -p linux/arm/ && mv ./conduit-arm-unknown-linux-musleabihf linux/arm/v6
+    # Actually build multiarch image:
-    - mkdir -p linux/arm/ && mv ./conduit-armv7-unknown-linux-musleabihf linux/arm/v7
+    - docker buildx build --push --platform $PLATFORMS --tag $IMAGE_TAG --file $DOCKER_FILE .
-    - mv ./conduit-aarch64-unknown-linux-musl linux/arm64
-    - 'export CREATED=$(date -u +''%Y-%m-%dT%H:%M:%SZ'') && echo "Docker image creation date: $CREATED"'
-    # Build and push image:
-    - >
-      docker buildx build
-      --pull
-      --push
-      --cache-from=type=local,src=$CI_PROJECT_DIR/docker_cache
-      --cache-to=type=local,dest=$CI_PROJECT_DIR/docker_cache
-      --build-arg CREATED=$CREATED
-      --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
-      --build-arg "GIT_REF=$CI_COMMIT_SHORT_SHA"
-      --platform "$PLATFORMS"
-      --tag "$TAG"
-      --tag "$TAG-alpine"
-      --tag "$TAG-commit-$CI_COMMIT_SHORT_SHA"
-      --file "$DOCKER_FILE" .
 
-docker:next:gitlab:
-  extends: .docker-shared-settings
-  rules:
-    - if: '$CI_COMMIT_BRANCH == "next"'
-  variables:
-    TAG: "$CI_REGISTRY_IMAGE/matrix-conduit:next"
 
-docker:next:dockerhub:
-  extends: .docker-shared-settings
-  rules:
-    - if: '$CI_COMMIT_BRANCH == "next" && $DOCKER_HUB'
-  variables:
-    TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next"
 
-docker:master:gitlab:
-  extends: .docker-shared-settings
-  rules:
-    - if: '$CI_COMMIT_BRANCH == "master"'
-  variables:
-    TAG: "$CI_REGISTRY_IMAGE/matrix-conduit:latest"
-
-docker:master:dockerhub:
-  extends: .docker-shared-settings
-  rules:
-    - if: '$CI_COMMIT_BRANCH == "master" && $DOCKER_HUB'
-  variables:
-    TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest"
 
 # --------------------------------------------------------------------- #
 #  Run tests                                                            #
@@ -226,20 +348,13 @@ test:cargo:
   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 wget
+    - apt-get install -yqq --no-install-recommends build-essential libssl-dev pkg-config
     - rustup component add clippy rustfmt
-    - wget "https://faulty-storage.de/gitlab-report"
-    - chmod +x ./gitlab-report
   script:
     - rustc --version && cargo --version  # Print version info for debugging
     - cargo fmt --all -- --check
-    - "cargo test --color always --workspace --verbose --locked --no-fail-fast -- -Z unstable-options --format json | ./gitlab-report -p test > $CI_PROJECT_DIR/report.xml"
+    - cargo test --workspace --verbose --locked
-    - "cargo clippy --color always --verbose --message-format=json | ./gitlab-report -p clippy > $CI_PROJECT_DIR/gl-code-quality-report.json"
+    - cargo clippy
-  artifacts:
-    when: always
-    reports:
-      junit: report.xml
-      codequality: gl-code-quality-report.json
 
 test:sytest:
   stage: "test"
@@ -262,7 +377,7 @@ test:sytest:
   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'
+    - "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
@@ -272,6 +387,7 @@ test:sytest:
     reports:
       junit: "$CI_PROJECT_DIR/sytest.xml"
 
+
 # --------------------------------------------------------------------- #
 #  Store binaries as package so they have download urls                 #
 # --------------------------------------------------------------------- #
@@ -279,31 +395,25 @@ test:sytest:
 publish:package:
   stage: "upload artifacts"
   needs:
+    - "build:release:cargo:x86_64-unknown-linux-gnu"
+    - "build:release:cargo:armv7-unknown-linux-gnueabihf"
+    - "build:release:cargo:aarch64-unknown-linux-gnu"
     - "build:release:cargo:x86_64-unknown-linux-musl"
-    - "build:release:cargo:arm-unknown-linux-musleabihf"
+    - "build:cargo-deb:x86_64-unknown-linux-gnu"
-    - "build:release:cargo:armv7-unknown-linux-musleabihf"
-    - "build:release:cargo:aarch64-unknown-linux-musl"
-  #    - "build:cargo-deb:x86_64-unknown-linux-gnu"
   rules:
     - if: '$CI_COMMIT_BRANCH == "master"'
     - if: '$CI_COMMIT_BRANCH == "next"'
-    - if: "$CI_COMMIT_TAG"
+    - if: '$CI_COMMIT_TAG'
   image: curlimages/curl:latest
   tags: ["docker"]
   variables:
     GIT_STRATEGY: "none" # Don't need a clean copy of the code, we just operate on artifacts
   script:
     - 'BASE_URL="${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-gnu "${BASE_URL}/conduit-x86_64-unknown-linux-gnu"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-armv7-unknown-linux-gnueabihf "${BASE_URL}/conduit-armv7-unknown-linux-gnueabihf"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-aarch64-unknown-linux-gnu "${BASE_URL}/conduit-aarch64-unknown-linux-gnu"'
     - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-musl "${BASE_URL}/conduit-x86_64-unknown-linux-musl"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-arm-unknown-linux-musleabihf "${BASE_URL}/conduit-arm-unknown-linux-musleabihf"'
+    - '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"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-armv7-unknown-linux-musleabihf "${BASE_URL}/conduit-armv7-unknown-linux-musleabihf"'
+
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-aarch64-unknown-linux-musl "${BASE_URL}/conduit-aarch64-unknown-linux-musl"'
 
-# Avoid duplicate pipelines
-# See: https://docs.gitlab.com/ee/ci/yaml/workflow.html#switch-between-branch-pipelines-and-merge-request-pipelines
-workflow:
-  rules:
-    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
-    - if: "$CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS"
-      when: never
-    - if: "$CI_COMMIT_BRANCH"

Cargo.lock

@@ -245,7 +245,6 @@ dependencies = [
  "crossbeam",
  "directories",
  "heed",
- "hmac",
  "http",
  "image",
  "jsonwebtoken",
@@ -267,7 +266,6 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_yaml",
- "sha-1",
  "sled",
  "thiserror",
  "thread_local",
@@ -430,16 +428,6 @@ dependencies = [
  "lazy_static",
 ]
 
-[[package]]
-name = "crypto-mac"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
-dependencies = [
- "generic-array",
- "subtle",
-]
-
 [[package]]
 name = "curve25519-dalek"
 version = "3.2.0"
@@ -909,16 +897,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "hmac"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b"
-dependencies = [
- "crypto-mac",
- "digest",
-]
-
 [[package]]
 name = "hostname"
 version = "0.3.1"
@@ -1516,6 +1494,12 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "paste"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acbf547ad0c65e31259204bd90935776d1c693cec2f4ff7abb7a1bbbd40dfe58"
+
 [[package]]
 name = "pear"
 version = "0.2.3"
@@ -1984,7 +1968,7 @@ dependencies = [
 [[package]]
 name = "ruma"
 version = "0.4.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "assign",
  "js_int",
@@ -2005,7 +1989,7 @@ dependencies = [
 [[package]]
 name = "ruma-api"
 version = "0.18.5"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "bytes",
  "http",
@@ -2021,7 +2005,7 @@ dependencies = [
 [[package]]
 name = "ruma-api-macros"
 version = "0.18.5"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -2032,7 +2016,7 @@ dependencies = [
 [[package]]
 name = "ruma-appservice-api"
 version = "0.4.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "ruma-api",
  "ruma-common",
@@ -2046,7 +2030,7 @@ dependencies = [
 [[package]]
 name = "ruma-client-api"
 version = "0.12.3"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "assign",
  "bytes",
@@ -2066,7 +2050,7 @@ dependencies = [
 [[package]]
 name = "ruma-common"
 version = "0.6.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "indexmap",
  "js_int",
@@ -2081,7 +2065,7 @@ dependencies = [
 [[package]]
 name = "ruma-events"
 version = "0.24.6"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "indoc",
  "js_int",
@@ -2097,7 +2081,7 @@ dependencies = [
 [[package]]
 name = "ruma-events-macros"
 version = "0.24.6"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -2108,7 +2092,7 @@ dependencies = [
 [[package]]
 name = "ruma-federation-api"
 version = "0.3.1"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "js_int",
  "ruma-api",
@@ -2123,8 +2107,9 @@ dependencies = [
 [[package]]
 name = "ruma-identifiers"
 version = "0.20.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
+ "paste",
  "percent-encoding",
  "rand 0.8.4",
  "ruma-identifiers-macros",
@@ -2137,7 +2122,7 @@ dependencies = [
 [[package]]
 name = "ruma-identifiers-macros"
 version = "0.20.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "quote",
  "ruma-identifiers-validation",
@@ -2147,7 +2132,7 @@ dependencies = [
 [[package]]
 name = "ruma-identifiers-validation"
 version = "0.5.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "thiserror",
 ]
@@ -2155,7 +2140,7 @@ dependencies = [
 [[package]]
 name = "ruma-identity-service-api"
 version = "0.3.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "js_int",
  "ruma-api",
@@ -2168,7 +2153,7 @@ dependencies = [
 [[package]]
 name = "ruma-push-gateway-api"
 version = "0.3.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "js_int",
  "ruma-api",
@@ -2183,7 +2168,7 @@ dependencies = [
 [[package]]
 name = "ruma-serde"
 version = "0.5.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "bytes",
  "form_urlencoded",
@@ -2197,7 +2182,7 @@ dependencies = [
 [[package]]
 name = "ruma-serde-macros"
 version = "0.5.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -2208,7 +2193,7 @@ dependencies = [
 [[package]]
 name = "ruma-signatures"
 version = "0.9.0"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "base64 0.13.0",
  "ed25519-dalek",
@@ -2225,7 +2210,7 @@ dependencies = [
 [[package]]
 name = "ruma-state-res"
 version = "0.4.1"
-source = "git+https://github.com/ruma/ruma?rev=16f031fabb7871fcd738b0f25391193ee4ca28a9#16f031fabb7871fcd738b0f25391193ee4ca28a9"
+source = "git+https://github.com/ruma/ruma?rev=44cfd0adbc83303c19aef590ad0d71647e19f197#44cfd0adbc83303c19aef590ad0d71647e19f197"
 dependencies = [
  "itertools 0.10.1",
  "js_int",
@@ -2437,19 +2422,6 @@ dependencies = [
  "yaml-rust",
 ]
 
-[[package]]
-name = "sha-1"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99cd6713db3cf16b6c84e06321e049a9b9f699826e16096d23bbcc44d15d51a6"
-dependencies = [
- "block-buffer",
- "cfg-if 1.0.0",
- "cpufeatures",
- "digest",
- "opaque-debug",
-]
-
 [[package]]
 name = "sha1"
 version = "0.6.0"

Cargo.toml

@@ -19,7 +19,7 @@ rocket = { version = "0.5.0-rc.1", features = ["tls"] } # Used to handle request
 
 # 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 = "16f031fabb7871fcd738b0f25391193ee4ca28a9", 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 = "58cdcae1f9a8f4824bcbec1de1bb13e659c66804", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
 #ruma = { git = "https://github.com/timokoesters/ruma", rev = "50c1db7e0a3a21fc794b0cce3b64285a4c750c71", 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"] }
 
@@ -40,7 +40,7 @@ serde_json = { version = "1.0.67", features = ["raw_value"] }
 # Used for appservice registration files
 serde_yaml = "0.8.20"
 # Used for pdu definition
-serde = { version = "1.0.130", features = ["rc"] }
+serde = "1.0.130"
 # Used for secure identifiers
 rand = "0.8.4"
 # Used to hash passwords
@@ -79,9 +79,6 @@ num_cpus = "1.13.0"
 threadpool = "1.8.1"
 heed = { git = "https://github.com/timokoesters/heed.git", rev = "f6f825da7fb2c758867e05ad973ef800a6fe1d5d", optional = true }
 thread_local = "1.1.3"
-# used for TURN server authentication
-hmac = "0.11.0"
-sha-1 = "0.9.8"
 
 [features]
 default = ["conduit_bin", "backend_sqlite"]
@@ -123,12 +120,13 @@ maintainer-scripts = "debian/"
 systemd-units = { unit-name = "matrix-conduit" }
 
 [profile.dev]
-lto = 'off'
+lto = 'thin'
 incremental = true
 
 [profile.release]
 lto = 'thin'
 incremental = true
+
 codegen-units=32
 # If you want to make flamegraphs, enable debug info:
 # debug = true

DEPLOY.md

@@ -2,27 +2,25 @@
 
 ## Getting help
 
-If you run into any problems while setting up Conduit, write an email to `timo@koesters.xyz`, ask us
+If you run into any problems while setting up Conduit, write an email to `timo@koesters.xyz`, ask us in `#conduit:matrix.org` or [open an issue on GitLab](https://gitlab.com/famedly/conduit/-/issues/new).
-in `#conduit:matrix.org` or [open an issue on GitLab](https://gitlab.com/famedly/conduit/-/issues/new).
 
 ## Installing Conduit
 
-Although you might be able to compile Conduit for Windows, we do recommend running it on a linux server. We therefore
-only offer Linux binaries.
-
 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                            | Download stable version        |
+| CPU Architecture     | GNU (Ubuntu, Debian, ArchLinux, ...)  | MUSL (Alpine, ... )     |
-| ------------------------------------------- | ------------------------------ |
+| -------------------- | ------------------------------------- | ----------------------- |
-| x84_64 / amd64 (Most servers and computers) | [Download][x84_64-musl-master] |
+| x84_64 / amd64       | [Download][x84_64-gnu]                | [Download][x84_64-musl] |
-| armv6                                       | [Download][armv6-musl-master]  |
+| armv7 (Raspberry Pi) | [Download][armv7-gnu]                 | -                       |
-| armv7 (e.g. Raspberry Pi by default)        | [Download][armv7-musl-master]  |
+| armv8 / aarch64      | [Download][armv8-gnu]                 | -                       |
-| armv8 / aarch64                             | [Download][armv8-musl-master]  |
 
-[x84_64-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-musl?job=build:release:cargo:x86_64-unknown-linux-musl
+[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
-[armv6-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-arm-unknown-linux-musleabihf?job=build:release:cargo:arm-unknown-linux-musleabihf
+
-[armv7-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-armv7-unknown-linux-musleabihf?job=build:release:cargo:armv7-unknown-linux-musleabihf
+[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
-[armv8-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-aarch64-unknown-linux-musl?job=build:release:cargo:aarch64-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>
@@ -34,15 +32,15 @@ Alternatively, you may compile the binary yourself using
 ```bash
 $ cargo build --release
 ```
-
 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. This also allows
+While Conduit can run as any user it is usually better to use dedicated users for different services.
-you to make sure that the file permissions are correctly set up.
+This also allows you to make sure that the file permissions are correctly set up.
 
 In Debian you can use this command to create a Conduit user:
 
@@ -52,8 +50,9 @@ sudo adduser --system conduit --no-create-home
 
 ## Setting up a systemd service
 
-Now we'll set up a systemd service for Conduit, so it's easy to start/stop Conduit and set it to autostart when your
+Now we'll set up a systemd service for Conduit, so it's easy to start/stop
-server reboots. Simply paste the default systemd service you can find below into
+Conduit and set it to autostart when your server reboots. Simply paste the
+default systemd service you can find below into
 `/etc/systemd/system/conduit.service`.
 
 ```systemd
@@ -78,10 +77,10 @@ Finally, run
 $ sudo systemctl daemon-reload
 ```
 
+
 ## Creating the Conduit configuration file
 
-Now we need to create the Conduit's config file in `/etc/matrix-conduit/conduit.toml`. Paste this in **and take a moment
+Now we need to create the Conduit's config file in `/etc/matrix-conduit/conduit.toml`. Paste this in **and take a moment to read it. You need to change at least the server name.**
-to read it. You need to change at least the server name.**
 
 ```toml
 [global]
@@ -129,8 +128,8 @@ address = "127.0.0.1" # This makes sure Conduit can only be reached using the re
 
 ## Setting the correct file permissions
 
-As we are using a Conduit specific user we need to allow it to read the config. To do that you can run this command on
+As we are using a Conduit specific user we need to allow it to read the config.
-Debian:
+To do that you can run this command on Debian:
 
 ```bash
 sudo chown -R conduit:nogroup /etc/matrix-conduit
@@ -143,6 +142,7 @@ sudo mkdir -p /var/lib/matrix-conduit/conduit_db
 sudo chown -R conduit:nogroup /var/lib/matrix-conduit/conduit_db
 ```
 
+
 ## Setting up the Reverse Proxy
 
 This depends on whether you use Apache, Nginx or another web server.
@@ -171,9 +171,11 @@ ProxyPassReverse /_matrix/ http://127.0.0.1:6167/_matrix/
 $ sudo systemctl reload apache2
 ```
 
+
 ### Nginx
 
-If you use Nginx and not Apache, add the following server section inside the http section of `/etc/nginx/nginx.conf`
+If you use Nginx and not Apache, add the following server section inside the
+http section of `/etc/nginx/nginx.conf`
 
 ```nginx
 server {
@@ -196,13 +198,13 @@ server {
     include /etc/letsencrypt/options-ssl-nginx.conf;
 }
 ```
-
 **You need to make some edits again.** When you are done, run
 
 ```bash
 $ sudo systemctl reload nginx
 ```
 
+
 ## SSL Certificate
 
 The easiest way to get an SSL certificate, if you don't have one already, is to install `certbot` and run this:
@@ -211,6 +213,7 @@ The easiest way to get an SSL certificate, if you don't have one already, is to
 $ sudo certbot -d your.server.name
 ```
 
+
 ## You're done!
 
 Now you can start Conduit with:

Dockerfile

@@ -1,10 +1,7 @@
 # syntax=docker/dockerfile:1
-FROM docker.io/rust:1.53-alpine AS builder
+FROM rust:1.53-alpine as builder
 WORKDIR /usr/src/conduit
 
-# Install required packages to build Conduit and it's dependencies
-RUN apk add musl-dev
-
 # == Build dependencies without our own code separately for caching ==
 #
 # Need a fake main.rs since Cargo refuses to build anything otherwise.
@@ -12,70 +9,44 @@ RUN apk add musl-dev
 # See https://github.com/rust-lang/cargo/issues/2644 for a Cargo feature
 # request that would allow just dependencies to be compiled, presumably
 # regardless of whether source files are available.
-RUN mkdir src && touch src/lib.rs && echo 'fn main() {}' > src/main.rs
+RUN mkdir src && echo 'fn main() {}' > src/main.rs
 COPY Cargo.toml Cargo.lock ./
-RUN cargo build --release && rm -r src
+RUN cargo build
+# TODO: RUN cargo build --release
 
-# Copy over actual Conduit sources
+# == Actual build ==
+RUN rm -r src
 COPY src src
-
+# main.rs has to have its timestamp updated for this to work correctly since
-# main.rs and lib.rs need their timestamp updated for this to work correctly since
 # otherwise the build with the fake main.rs from above is newer than the
 # source files (COPY preserves timestamps).
-#
+RUN touch src/main.rs
-# Builds conduit and places the binary at /usr/src/conduit/target/release/conduit
+
-RUN touch src/main.rs && touch src/lib.rs && cargo build --release
+RUN cargo install --path .
+# TODO: RUN cargo install --release --path . 
 
 
+# This build stage is going to be run later
+FROM alpine:3.14
 
-
+# Install packages needed to run Conduit
-# ---------------------------------------------------------------------------------------------------------------
-# Stuff below this line actually ends up in the resulting docker image
-# ---------------------------------------------------------------------------------------------------------------
-FROM docker.io/alpine:3.15.0 AS runner
-
-# Standard port on which Conduit launches.
-# You still need to map the port when using the docker command or docker-compose.
-EXPOSE 6167
-
-# Note from @jfowl: I would like to remove this in the future and just have the Docker version be configured with envs. 
-ENV CONDUIT_CONFIG="/srv/conduit/conduit.toml"
-
-# Conduit needs:
-#   ca-certificates: for https
-#   libgcc: Apparently this is needed, even if I (@jfowl) don't know exactly why. But whatever, it's not that big.
 RUN apk add --no-cache \
         ca-certificates \
+        curl \
         libgcc
 
-
+# Prepare path for database and media files
-# Created directory for the database and media files
 RUN mkdir -p /srv/conduit/.local/share/conduit
 
-# Test if Conduit is still alive, uses the same endpoint as Element
+# TODO: Change ? or maybe leave it like that
-COPY ./docker/healthcheck.sh /srv/conduit/healthcheck.sh
+RUN mkdir -p /srv/conduit/.local/share/conduit
-HEALTHCHECK --start-period=5s --interval=5s CMD ./healthcheck.sh
+COPY --from=builder /usr/local/cargo/bin/conduit /srv/conduit/
 
-# Copy over the actual Conduit binary from the builder stage
+# TODO: Check if we don't want to just use ENVs for running condit in docker
-COPY --from=builder /usr/src/conduit/target/release/conduit /srv/conduit/conduit
+ENV CONDUIT_CONFIG="/srv/conduit/conduit.toml"
 
-# Improve security: Don't run stuff as root, that does not need to run as root:
+# TODO: not needed, but documents it?
-# Add www-data user and group with UID 82, as used by alpine
+EXPOSE 6167
-# 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
-RUN chmod +x /srv/conduit/healthcheck.sh
-
-# Change user to www-data
-USER www-data
-# Set container home directory
 WORKDIR /srv/conduit
-
-# Run Conduit and print backtraces on panics
-ENV RUST_BACKTRACE=1
 ENTRYPOINT [ "/srv/conduit/conduit" ]

docker/README.md

@@ -2,22 +2,38 @@
 
 > **Note:** To run and use Conduit you should probably use it with a Domain or Subdomain behind a reverse proxy (like Nginx, Traefik, Apache, ...) with a Lets Encrypt certificate.
 
+
 ## Docker
 
 ### Build & Dockerfile
 
 The Dockerfile provided by Conduit has two stages, each of which creates an image.
-
 1. **Builder:** Builds the binary from local context or by cloning a git revision from the official repository.
-2. **Runner:** Copies the built binary from **Builder** and sets up the runtime environment, like creating a volume to persist the database and applying the correct permissions.
+2. **Runtime:** Copies the built binary from **Builder** and sets up the runtime environment, like creating a volume to persist the database and applying the correct permissions.
+
+The Dockerfile includes a few build arguments that should be supplied when building it.
+
+``` Dockerfile
+ARG LOCAL=false
+ARG CREATED
+ARG VERSION
+ARG GIT_REF=origin/master
+```
+
+- **CREATED:** Date and time as string (date-time as defined by RFC 3339). Will be used to create the Open Container Initiative compliant label `org.opencontainers.image.created`. Supply by it like this `$(date -u +'%Y-%m-%dT%H:%M:%SZ')`
+- **VERSION:** The SemVer version of Conduit, which is in the image. Will be used to create the Open Container Initiative compliant label `org.opencontainers.image.version`. If you have a `Cargo.toml` in your build context, you can get it with `$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)`
+- **LOCAL:** *(Optional)* A boolean value, specifies if the local build context should be used, or if the official repository will be cloned. If not supplied with the build command, it will default to `false`.
+- **GIT_REF:** *(Optional)* A git ref, like `HEAD` or a commit ID. The supplied ref will be used to create the Open Container Initiative compliant label `org.opencontainers.image.revision` and will be the ref that is cloned from the repository when not building from the local context. If not supplied with the build command, it will default to `origin/master`.
 
 To build the image you can use the following command
 
 ``` bash
-docker build --tag matrixconduit/matrix-conduit:latest .
+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)
 ```
 
 which also will tag the resulting image as `matrixconduit/matrix-conduit:latest`.
+**Note:** it ommits the two optional `build-arg`s.
+
 
 ### Run
 
@@ -30,13 +46,9 @@ docker run -d -p 8448:6167 -v ~/conduit.toml:/srv/conduit/conduit.toml -v db:/sr
 or you can skip the build step and pull the image from one of the following registries:
 
 | Registry        | Image                                                                                                               | Size                                                                                        |
-| --------------- | --------------------------------------------------------------- | --------------------- |
+| --------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
-| Docker Hub      | [matrixconduit/matrix-conduit:latest][dh]                       | ![Image Size][shield] |
+| Docker Hub      | [matrixconduit/matrix-conduit:latest](https://hub.docker.com/r/matrixconduit/matrix-conduit)                        | ![Image Size](https://img.shields.io/docker/image-size/matrixconduit/matrix-conduit/latest) |
-| GitLab Registry | [registry.gitlab.com/famedly/conduit/matrix-conduit:latest][gl] | ![Image Size][shield] |
+| GitLab Registry | [registry.gitlab.com/famedly/conduit/conduit:latest](https://gitlab.com/famedly/conduit/container_registry/2134341) | ![Image Size](https://img.shields.io/docker/image-size/matrixconduit/matrix-conduit/latest) |
-
-[dh]: https://hub.docker.com/r/matrixconduit/matrix-conduit
-[gl]: https://gitlab.com/famedly/conduit/container_registry/
-[shield]: https://img.shields.io/docker/image-size/matrixconduit/matrix-conduit/latest
 
 The `-d` flag lets the container run in detached mode. You now need to supply a `conduit.toml` config file, an example can be found [here](../conduit-example.toml).
 You can pass in different env vars to change config values on the fly. You can even configure Conduit completely by using env vars, but for that you need
@@ -44,20 +56,23 @@ to pass `-e CONDUIT_CONFIG=""` into your container. For an overview of possible
 
 If you just want to test Conduit for a short time, you can use the `--rm` flag, which will clean up everything related to your container after you stop it.
 
+
 ## Docker-compose
 
 If the docker command is not for you or your setup, you can also use one of the provided `docker-compose` files. Depending on your proxy setup, use the [`docker-compose.traefik.yml`](docker-compose.traefik.yml) and [`docker-compose.override.traefik.yml`](docker-compose.override.traefik.yml) for Traefik (don't forget to remove `.traefik` from the filenames) or the normal [`docker-compose.yml`](../docker-compose.yml) for every other reverse proxy. Additional info about deploying
 Conduit can be found [here](../DEPLOY.md).
 
+
 ### Build
 
 To build the Conduit image with docker-compose, you first need to open and modify the `docker-compose.yml` file. There you need to comment the `image:` option and uncomment the `build:` option. Then call docker-compose with:
 
 ``` bash
-docker-compose up
+CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ') VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml) docker-compose up
 ```
 
-This will also start the container right afterwards, so if want it to run in detached mode, you also should use the `-d` flag.
+This will also start the container right afterwards, so if want it to run in detached mode, you also should use the `-d` flag. For possible `build-args`, please take a look at the above `Build & Dockerfile` section.
+
 
 ### Run
 
@@ -86,9 +101,7 @@ So...step by step:
 3. Create the `conduit.toml` config file, an example can be found [here](../conduit-example.toml), or set `CONDUIT_CONFIG=""` and configure Conduit per env vars.
 4. Uncomment the `element-web` service if you want to host your own Element Web Client and create a `element_config.json`.
 5. Create the files needed by the `well-known` service.
-
     - `./nginx/matrix.conf` (relative to the compose file, you can change this, but then also need to change the volume mapping)
-
       ```nginx
       server {
           server_name <SUBDOMAIN>.<DOMAIN>;
@@ -101,7 +114,6 @@ So...step by step:
           }
       }
       ```
-
     - `./nginx/www/.well-known/matrix/client` (relative to the compose file, you can change this, but then also need to change the volume mapping)
       ```json
       {
@@ -116,6 +128,5 @@ So...step by step:
           "m.server": "<SUBDOMAIN>.<DOMAIN>:443"
       }
       ```
-
 6. Run `docker-compose up -d`
 7. Connect to your homeserver with your preferred client and create a user. You should do this immediatly after starting Conduit, because the first created user is the admin.

docker/ci-binaries-packaging.Dockerfile

@@ -1,32 +1,27 @@
 # syntax=docker/dockerfile:1
 # ---------------------------------------------------------------------------------------------------------
 # 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 jobs.
+# 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 docker.io/alpine:3.15.0 AS runner
+FROM alpine:3.14
 
-# Standard port on which Conduit launches.
+# Install packages needed to run Conduit
-# You still need to map the port when using the docker command or docker-compose.
-EXPOSE 6167
-
-# Note from @jfowl: I would like to remove this in the future and just have the Docker version be configured with envs. 
-ENV CONDUIT_CONFIG="/srv/conduit/conduit.toml"
-
-# Conduit needs:
-#   ca-certificates: for https
-#   libgcc: Apparently this is needed, even if I (@jfowl) don't know exactly why. But whatever, it's not that big.
 RUN apk add --no-cache \
         ca-certificates \
+        curl \
         libgcc
 
-
 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} \
@@ -42,21 +37,23 @@ LABEL org.opencontainers.image.created=${CREATED} \
       org.opencontainers.image.documentation="https://gitlab.com/famedly/conduit" \
       org.opencontainers.image.ref.name=""
 
-# Created directory for the database and media files
+# 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
 
 # Test if Conduit is still alive, uses the same endpoint as Element
-COPY ./docker/healthcheck.sh /srv/conduit/healthcheck.sh
+COPY ./docker/healthcheck.sh /srv/conduit/
-HEALTHCHECK --start-period=5s --interval=5s CMD ./healthcheck.sh
+HEALTHCHECK --start-period=5s --interval=60s CMD ./healthcheck.sh
 
+# Copy the Conduit binary into the image at the latest possible moment to maximise caching:
 
-# Depending on the target platform (e.g. "linux/arm/v7", "linux/arm64/v8", or "linux/amd64")
+# depending on the target platform (e.g. "linux/arm/v7", "linux/arm64/v8", or "linux/amd64")
 # copy the matching binary into this docker image
 ARG TARGETPLATFORM
 COPY ./$TARGETPLATFORM /srv/conduit/conduit
 
-
-# Improve security: Don't run stuff as root, that does not need to run as root:
 # 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 ; \
@@ -68,11 +65,9 @@ RUN set -x ; \
 RUN chown -cR www-data:www-data /srv/conduit
 RUN chmod +x /srv/conduit/healthcheck.sh
 
-# Change user to www-data
+# Set user to www-data
 USER www-data
 # Set container home directory
 WORKDIR /srv/conduit
-
+# Run Conduit
-# Run Conduit and print backtraces on panics
-ENV RUST_BACKTRACE=1
 ENTRYPOINT [ "/srv/conduit/conduit" ]

docker/healthcheck.sh

@@ -7,7 +7,7 @@ fi
 
 # The actual health check.
 # We try to first get a response on HTTP and when that fails on HTTPS and when that fails, we exit with code 1.
-# TODO: Change this to a single wget call. Do we have a config value that we can check for that?
+# TODO: Change this to a single curl call. Do we have a config value that we can check for that?
-wget --no-verbose --tries=1 --spider "http://localhost:${CONDUIT_PORT}/_matrix/client/versions" || \
+curl --fail -s "http://localhost:${CONDUIT_PORT}/_matrix/client/versions" || \
-    wget --no-verbose --tries=1 --spider "https://localhost:${CONDUIT_PORT}/_matrix/client/versions" || \
+    curl -k --fail -s "https://localhost:${CONDUIT_PORT}/_matrix/client/versions" || \
     exit 1

src/client_server/account.rs

@@ -1,4 +1,8 @@
-use std::{collections::BTreeMap, convert::TryInto, sync::Arc};
+use std::{
+    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};
@@ -7,9 +11,10 @@ use ruma::{
         error::ErrorKind,
         r0::{
             account::{
-                change_password, deactivate, get_3pids, get_username_availability, register,
+                change_password, deactivate, get_username_availability, register, whoami,
-                whoami, ThirdPartyIdRemovalStatus,
+                ThirdPartyIdRemovalStatus,
             },
+            contact::get_contacts,
             uiaa::{AuthFlow, AuthType, UiaaInfo},
         },
     },
@@ -277,7 +282,7 @@ pub async fn register_route(
         let mut content = RoomCreateEventContent::new(conduit_user.clone());
         content.federate = true;
         content.predecessor = None;
-        content.room_version = RoomVersionId::V6;
+        content.room_version = RoomVersionId::Version6;
 
         // 1. The room create event
         db.rooms.build_and_append_pdu(
@@ -306,7 +311,6 @@ pub async fn register_route(
                     third_party_invite: None,
                     blurhash: None,
                     reason: None,
-                    join_authorized_via_users_server: None,
                 })
                 .expect("event is valid, we just created it"),
                 unsigned: None,
@@ -393,7 +397,8 @@ pub async fn register_route(
         )?;
 
         // 6. Events implied by name and topic
-        let room_name = RoomName::parse(format!("{} Admin Room", db.globals.server_name()))
+        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 {
@@ -428,7 +433,7 @@ pub async fn register_route(
         )?;
 
         // Room alias
-        let alias: Box<RoomAliasId> = format!("#admins:{}", db.globals.server_name())
+        let alias: RoomAliasId = format!("#admins:{}", db.globals.server_name())
             .try_into()
             .expect("#admins:server_name is a valid alias name");
 
@@ -464,7 +469,6 @@ pub async fn register_route(
                     third_party_invite: None,
                     blurhash: None,
                     reason: None,
-                    join_authorized_via_users_server: None,
                 })
                 .expect("event is valid, we just created it"),
                 unsigned: None,
@@ -487,7 +491,6 @@ pub async fn register_route(
                     third_party_invite: None,
                     blurhash: None,
                     reason: None,
-                    join_authorized_via_users_server: None,
                 })
                 .expect("event is valid, we just created it"),
                 unsigned: None,
@@ -704,7 +707,6 @@ pub async fn deactivate_route(
             third_party_invite: None,
             blurhash: None,
             reason: None,
-            join_authorized_via_users_server: None,
         };
 
         let mutex_state = Arc::clone(
@@ -755,9 +757,9 @@ pub async fn deactivate_route(
     get("/_matrix/client/r0/account/3pid", data = "<body>")
 )]
 pub async fn third_party_route(
-    body: Ruma<get_3pids::Request>,
+    body: Ruma<get_contacts::Request>,
-) -> ConduitResult<get_3pids::Response> {
+) -> ConduitResult<get_contacts::Response> {
     let _sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    Ok(get_3pids::Response::new(Vec::new()).into())
+    Ok(get_contacts::Response::new(Vec::new()).into())
 }

src/client_server/capabilities.rs

@@ -22,12 +22,12 @@ pub async fn get_capabilities_route(
     _body: Ruma<get_capabilities::Request>,
 ) -> ConduitResult<get_capabilities::Response> {
     let mut available = BTreeMap::new();
-    available.insert(RoomVersionId::V5, RoomVersionStability::Stable);
+    available.insert(RoomVersionId::Version5, RoomVersionStability::Stable);
-    available.insert(RoomVersionId::V6, RoomVersionStability::Stable);
+    available.insert(RoomVersionId::Version6, RoomVersionStability::Stable);
 
     let mut capabilities = Capabilities::new();
     capabilities.room_versions = RoomVersionsCapability {
-        default: RoomVersionId::V6,
+        default: RoomVersionId::Version6,
         available,
     };
 

src/client_server/directory.rs

@@ -167,7 +167,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                 other_server,
                 federation::directory::get_public_rooms_filtered::v1::Request {
                     limit,
-                    since,
+                    since: since.as_deref(),
                     filter: Filter {
                         generic_search_term: filter.generic_search_term.as_deref(),
                     },

src/client_server/keys.rs

@@ -316,7 +316,7 @@ pub async fn get_key_changes_route(
 
 pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
     sender_user: Option<&UserId>,
-    device_keys_input: &BTreeMap<Box<UserId>, Vec<Box<DeviceId>>>,
+    device_keys_input: &BTreeMap<UserId, Vec<Box<DeviceId>>>,
     allowed_signatures: F,
     db: &Database,
 ) -> Result<get_keys::Response> {
@@ -328,8 +328,6 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
     let mut get_over_federation = HashMap::new();
 
     for (user_id, device_ids) in device_keys_input {
-        let user_id: &UserId = &**user_id;
-
         if user_id.server_name() != db.globals.server_name() {
             get_over_federation
                 .entry(user_id.server_name())
@@ -357,11 +355,11 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
                     container.insert(device_id, keys);
                 }
             }
-            device_keys.insert(user_id.to_owned(), container);
+            device_keys.insert(user_id.clone(), container);
         } else {
             for device_id in device_ids {
                 let mut container = BTreeMap::new();
-                if let Some(mut keys) = db.users.get_device_keys(user_id, device_id)? {
+                if let Some(mut keys) = db.users.get_device_keys(&user_id.clone(), device_id)? {
                     let metadata = db.users.get_device_metadata(user_id, device_id)?.ok_or(
                         Error::BadRequest(
                             ErrorKind::InvalidParam,
@@ -373,24 +371,24 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
                         device_display_name: metadata.display_name,
                     };
 
-                    container.insert(device_id.to_owned(), keys);
+                    container.insert(device_id.clone(), keys);
                 }
-                device_keys.insert(user_id.to_owned(), container);
+                device_keys.insert(user_id.clone(), container);
             }
         }
 
         if let Some(master_key) = db.users.get_master_key(user_id, &allowed_signatures)? {
-            master_keys.insert(user_id.to_owned(), master_key);
+            master_keys.insert(user_id.clone(), master_key);
         }
         if let Some(self_signing_key) = db
             .users
             .get_self_signing_key(user_id, &allowed_signatures)?
         {
-            self_signing_keys.insert(user_id.to_owned(), self_signing_key);
+            self_signing_keys.insert(user_id.clone(), self_signing_key);
         }
         if Some(user_id) == sender_user {
             if let Some(user_signing_key) = db.users.get_user_signing_key(user_id)? {
-                user_signing_keys.insert(user_id.to_owned(), user_signing_key);
+                user_signing_keys.insert(user_id.clone(), user_signing_key);
             }
         }
     }
@@ -402,7 +400,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
         .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.to_owned(), keys.clone());
+                device_keys_input_fed.insert(user_id.clone(), keys.clone());
             }
             (
                 server,
@@ -442,7 +440,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
 }
 
 pub(crate) async fn claim_keys_helper(
-    one_time_keys_input: &BTreeMap<Box<UserId>, BTreeMap<Box<DeviceId>, DeviceKeyAlgorithm>>,
+    one_time_keys_input: &BTreeMap<UserId, BTreeMap<Box<DeviceId>, DeviceKeyAlgorithm>>,
     db: &Database,
 ) -> Result<claim_keys::Response> {
     let mut one_time_keys = BTreeMap::new();

src/client_server/membership.rs

@@ -31,7 +31,6 @@ use serde_json::value::{to_raw_value, RawValue as RawJsonValue};
 use std::{
     collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
     convert::{TryFrom, TryInto},
-    iter,
     sync::{Arc, RwLock},
     time::{Duration, Instant},
 };
@@ -65,7 +64,7 @@ pub async fn join_room_by_id_route(
         .filter_map(|event| serde_json::from_str(event.json().get()).ok())
         .filter_map(|event: serde_json::Value| event.get("sender").cloned())
         .filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
-        .filter_map(|sender| UserId::parse(sender).ok())
+        .filter_map(|sender| UserId::try_from(sender).ok())
         .map(|user| user.server_name().to_owned())
         .collect();
 
@@ -73,7 +72,7 @@ pub async fn join_room_by_id_route(
 
     let ret = join_room_by_id_helper(
         &db,
-        body.sender_user.as_deref(),
+        body.sender_user.as_ref(),
         &body.room_id,
         &servers,
         body.third_party_signed.as_ref(),
@@ -100,10 +99,9 @@ pub async fn join_room_by_id_or_alias_route(
     db: DatabaseGuard,
     body: Ruma<join_room_by_id_or_alias::Request<'_>>,
 ) -> ConduitResult<join_room_by_id_or_alias::Response> {
-    let sender_user = body.sender_user.as_deref().expect("user is authenticated");
+    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-    let body = body.body;
 
-    let (servers, room_id) = match Box::<RoomId>::try_from(body.room_id_or_alias) {
+    let (servers, room_id) = match RoomId::try_from(body.room_id_or_alias.clone()) {
         Ok(room_id) => {
             let mut servers: HashSet<_> = db
                 .rooms
@@ -113,7 +111,7 @@ pub async fn join_room_by_id_or_alias_route(
                 .filter_map(|event| serde_json::from_str(event.json().get()).ok())
                 .filter_map(|event: serde_json::Value| event.get("sender").cloned())
                 .filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
-                .filter_map(|sender| UserId::parse(sender).ok())
+                .filter_map(|sender| UserId::try_from(sender).ok())
                 .map(|user| user.server_name().to_owned())
                 .collect();
 
@@ -129,7 +127,7 @@ pub async fn join_room_by_id_or_alias_route(
 
     let join_room_response = join_room_by_id_helper(
         &db,
-        Some(sender_user),
+        body.sender_user.as_ref(),
         &room_id,
         &servers,
         body.third_party_signed.as_ref(),
@@ -286,7 +284,6 @@ pub async fn ban_user_route(
                 third_party_invite: None,
                 blurhash: db.users.blurhash(&body.user_id)?,
                 reason: None,
-                join_authorized_via_users_server: None,
             }),
             |event| {
                 serde_json::from_str(event.content.get())
@@ -534,7 +531,7 @@ async fn join_room_by_id_helper(
             .roomid_mutex_state
             .write()
             .unwrap()
-            .entry(room_id.to_owned())
+            .entry(room_id.clone())
             .or_default(),
     );
     let state_lock = mutex_state.lock().await;
@@ -554,7 +551,7 @@ async fn join_room_by_id_helper(
                     federation::membership::create_join_event_template::v1::Request {
                         room_id,
                         user_id: sender_user,
-                        ver: &[RoomVersionId::V5, RoomVersionId::V6],
+                        ver: &[RoomVersionId::Version5, RoomVersionId::Version6],
                     },
                 )
                 .await;
@@ -570,7 +567,8 @@ async fn join_room_by_id_helper(
 
         let room_version = match make_join_response.room_version {
             Some(room_version)
-                if room_version == RoomVersionId::V5 || room_version == RoomVersionId::V6 =>
+                if room_version == RoomVersionId::Version5
+                    || room_version == RoomVersionId::Version6 =>
             {
                 room_version
             }
@@ -605,7 +603,6 @@ async fn join_room_by_id_helper(
                 third_party_invite: None,
                 blurhash: db.users.blurhash(sender_user)?,
                 reason: None,
-                join_authorized_via_users_server: None,
             })
             .expect("event is valid, we just created it"),
         );
@@ -623,12 +620,11 @@ async fn join_room_by_id_helper(
         .expect("event is valid, we just created it");
 
         // Generate event id
-        let event_id = format!(
+        let event_id = EventId::try_from(&*format!(
             "${}",
             ruma::signatures::reference_hash(&join_event_stub, &room_version)
                 .expect("ruma can calculate reference hashes")
-        );
+        ))
-        let event_id = <&EventId>::try_from(event_id.as_str())
         .expect("ruma's reference hashes are valid event ids");
 
         // Add event_id back
@@ -647,7 +643,7 @@ async fn join_room_by_id_helper(
                 remote_server,
                 federation::membership::create_join_event::v2::Request {
                     room_id,
-                    event_id,
+                    event_id: &event_id,
                     pdu: &PduEvent::convert_to_outgoing_federation_event(join_event.clone()),
                 },
             )
@@ -655,7 +651,7 @@ async fn join_room_by_id_helper(
 
         db.rooms.get_or_create_shortroomid(room_id, &db.globals)?;
 
-        let pdu = PduEvent::from_id_val(event_id, join_event.clone())
+        let pdu = PduEvent::from_id_val(&event_id, join_event.clone())
             .map_err(|_| Error::BadServerResponse("Invalid join event PDU."))?;
 
         let mut state = HashMap::new();
@@ -743,7 +739,7 @@ async fn join_room_by_id_helper(
         db.rooms.append_pdu(
             &pdu,
             utils::to_canonical_object(&pdu).expect("Pdu is valid canonical object"),
-            iter::once(&*pdu.event_id),
+            &[pdu.event_id.clone()],
             db,
         )?;
 
@@ -759,7 +755,6 @@ async fn join_room_by_id_helper(
             third_party_invite: None,
             blurhash: db.users.blurhash(sender_user)?,
             reason: None,
-            join_authorized_via_users_server: None,
         };
 
         db.rooms.build_and_append_pdu(
@@ -781,7 +776,7 @@ async fn join_room_by_id_helper(
 
     db.flush()?;
 
-    Ok(join_room_by_id::Response::new(room_id.to_owned()).into())
+    Ok(join_room_by_id::Response::new(room_id.clone()).into())
 }
 
 fn validate_and_add_event_id(
@@ -789,12 +784,12 @@ fn validate_and_add_event_id(
     room_version: &RoomVersionId,
     pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, String>>>,
     db: &Database,
-) -> Result<(Box<EventId>, CanonicalJsonObject)> {
+) -> Result<(EventId, CanonicalJsonObject)> {
     let mut value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
         error!("Invalid PDU in server response: {:?}: {:?}", pdu, e);
         Error::BadServerResponse("Invalid PDU in server response")
     })?;
-    let event_id = EventId::parse(format!(
+    let event_id = EventId::try_from(&*format!(
         "${}",
         ruma::signatures::reference_hash(&value, room_version)
             .expect("ruma can calculate reference hashes")
@@ -861,7 +856,7 @@ pub(crate) async fn invite_helper<'a>(
                     .roomid_mutex_state
                     .write()
                     .unwrap()
-                    .entry(room_id.to_owned())
+                    .entry(room_id.clone())
                     .or_default(),
             );
             let state_lock = mutex_state.lock().await;
@@ -897,7 +892,9 @@ pub(crate) async fn invite_helper<'a>(
 
             // If there was no create event yet, assume we are creating a version 6 room right now
             let room_version_id = create_event_content
-                .map_or(RoomVersionId::V6, |create_event| create_event.room_version);
+                .map_or(RoomVersionId::Version6, |create_event| {
+                    create_event.room_version
+                });
             let room_version =
                 RoomVersion::new(&room_version_id).expect("room version is supported");
 
@@ -909,7 +906,6 @@ pub(crate) async fn invite_helper<'a>(
                 third_party_invite: None,
                 blurhash: None,
                 reason: None,
-                join_authorized_via_users_server: None,
             })
             .expect("member event is valid value");
 
@@ -938,14 +934,14 @@ pub(crate) async fn invite_helper<'a>(
                 unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone());
                 unsigned.insert(
                     "prev_sender".to_owned(),
-                    to_raw_value(&prev_pdu.sender).expect("UserId is valid"),
+                    serde_json::from_str(prev_pdu.sender.as_str()).expect("UserId is valid string"),
                 );
             }
 
             let pdu = PduEvent {
-                event_id: ruma::event_id!("$thiswillbefilledinlater").into(),
+                event_id: ruma::event_id!("$thiswillbefilledinlater"),
-                room_id: room_id.to_owned(),
+                room_id: room_id.clone(),
-                sender: sender_user.to_owned(),
+                sender: sender_user.clone(),
                 origin_server_ts: utils::millis_since_unix_epoch()
                     .try_into()
                     .expect("time is valid"),
@@ -1018,12 +1014,11 @@ pub(crate) async fn invite_helper<'a>(
         };
 
         // Generate event id
-        let expected_event_id = format!(
+        let expected_event_id = EventId::try_from(&*format!(
             "${}",
             ruma::signatures::reference_hash(&pdu_json, &room_version_id)
                 .expect("ruma can calculate reference hashes")
-        );
+        ))
-        let expected_event_id = <&EventId>::try_from(expected_event_id.as_str())
         .expect("ruma's reference hashes are valid event ids");
 
         let response = db
@@ -1033,7 +1028,7 @@ pub(crate) async fn invite_helper<'a>(
                 user_id.server_name(),
                 create_invite::v2::Request {
                     room_id,
-                    event_id: expected_event_id,
+                    event_id: &expected_event_id,
                     room_version: &room_version_id,
                     event: &PduEvent::convert_to_outgoing_federation_event(pdu_json.clone()),
                     invite_room_state: &invite_room_state,
@@ -1105,7 +1100,7 @@ pub(crate) async fn invite_helper<'a>(
             .roomid_mutex_state
             .write()
             .unwrap()
-            .entry(room_id.to_owned())
+            .entry(room_id.clone())
             .or_default(),
     );
     let state_lock = mutex_state.lock().await;
@@ -1121,7 +1116,6 @@ pub(crate) async fn invite_helper<'a>(
                 third_party_invite: None,
                 blurhash: db.users.blurhash(user_id)?,
                 reason: None,
-                join_authorized_via_users_server: None,
             })
             .expect("event is valid, we just created it"),
             unsigned: None,

src/client_server/message.rs

@@ -5,8 +5,13 @@ use ruma::{
         r0::message::{get_message_events, send_message_event},
     },
     events::EventType,
+    EventId,
+};
+use std::{
+    collections::BTreeMap,
+    convert::{TryFrom, TryInto},
+    sync::Arc,
 };
-use std::{collections::BTreeMap, convert::TryInto, sync::Arc};
 
 #[cfg(feature = "conduit_bin")]
 use rocket::{get, put};
@@ -62,9 +67,10 @@ pub async fn send_message_event_route(
             ));
         }
 
-        let event_id = utils::string_from_bytes(&response)
+        let event_id = EventId::try_from(
-            .map_err(|_| Error::bad_database("Invalid txnid bytes in database."))?
+            utils::string_from_bytes(&response)
-            .try_into()
+                .map_err(|_| Error::bad_database("Invalid txnid bytes in database."))?,
+        )
         .map_err(|_| Error::bad_database("Invalid event id in txnid data."))?;
         return Ok(send_message_event::Response { event_id }.into());
     }
@@ -98,7 +104,7 @@ pub async fn send_message_event_route(
 
     db.flush()?;
 
-    Ok(send_message_event::Response::new((*event_id).to_owned()).into())
+    Ok(send_message_event::Response::new(event_id).into())
 }
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/messages`

src/client_server/mod.rs

@@ -16,7 +16,6 @@ mod profile;
 mod push;
 mod read_marker;
 mod redact;
-mod report;
 mod room;
 mod search;
 mod session;
@@ -48,7 +47,6 @@ pub use profile::*;
 pub use push::*;
 pub use read_marker::*;
 pub use redact::*;
-pub use report::*;
 pub use room::*;
 pub use search::*;
 pub use session::*;

src/client_server/push.rs

@@ -105,15 +105,15 @@ pub async fn get_pushrule_route(
 /// Creates a single specified push rule for this user.
 #[cfg_attr(
     feature = "conduit_bin",
-    put("/_matrix/client/r0/pushrules/<_>/<_>/<_>", data = "<body>")
+    put("/_matrix/client/r0/pushrules/<_>/<_>/<_>", data = "<req>")
 )]
-#[tracing::instrument(skip(db, body))]
+#[tracing::instrument(skip(db, req))]
 pub async fn set_pushrule_route(
     db: DatabaseGuard,
-    body: Ruma<set_pushrule::Request<'_>>,
+    req: Ruma<set_pushrule::Request<'_>>,
 ) -> ConduitResult<set_pushrule::Response> {
-    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
+    let sender_user = req.sender_user.as_ref().expect("user is authenticated");
-    let body = body.body;
+    let body = req.body;
 
     if body.scope != "global" {
         return Err(Error::BadRequest(

src/client_server/redact.rs

@@ -25,7 +25,6 @@ pub async fn redact_event_route(
     body: Ruma<redact_event::Request<'_>>,
 ) -> ConduitResult<redact_event::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-    let body = body.body;
 
     let mutex_state = Arc::clone(
         db.globals
@@ -46,7 +45,7 @@ pub async fn redact_event_route(
             .expect("event is valid, we just created it"),
             unsigned: None,
             state_key: None,
-            redacts: Some(body.event_id.into()),
+            redacts: Some(body.event_id.clone()),
         },
         sender_user,
         &body.room_id,
@@ -58,6 +57,5 @@ pub async fn redact_event_route(
 
     db.flush()?;
 
-    let event_id = (*event_id).to_owned();
     Ok(redact_event::Response { event_id }.into())
 }

src/client_server/report.rs

@@ -1,84 +0,0 @@
-use crate::{
-    database::{admin::AdminCommand, DatabaseGuard},
-    ConduitResult, Error, Ruma,
-};
-use ruma::{
-    api::client::{error::ErrorKind, r0::room::report_content},
-    events::room::message,
-    int,
-};
-
-#[cfg(feature = "conduit_bin")]
-use rocket::{http::RawStr, post};
-
-/// # `POST /_matrix/client/r0/rooms/{roomId}/report/{eventId}`
-///
-/// Reports an inappropriate event to homeserver admins
-///
-#[cfg_attr(
-    feature = "conduit_bin",
-    post("/_matrix/client/r0/rooms/<_>/report/<_>", data = "<body>")
-)]
-#[tracing::instrument(skip(db, body))]
-pub async fn report_event_route(
-    db: DatabaseGuard,
-    body: Ruma<report_content::Request<'_>>,
-) -> ConduitResult<report_content::Response> {
-    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-
-    let pdu = match db.rooms.get_pdu(&body.event_id)? {
-        Some(pdu) => pdu,
-        _ => {
-            return Err(Error::BadRequest(
-                ErrorKind::InvalidParam,
-                "Invalid Event ID",
-            ))
-        }
-    };
-
-    if body.score > int!(0) || body.score < int!(-100) {
-        return Err(Error::BadRequest(
-            ErrorKind::InvalidParam,
-            "Invalid score, must be within 0 to -100",
-        ));
-    };
-
-    if body.reason.chars().count() > 250 {
-        return Err(Error::BadRequest(
-            ErrorKind::InvalidParam,
-            "Reason too long, should be 250 characters or fewer",
-        ));
-    };
-
-    db.admin.send(AdminCommand::SendMessage(
-        message::RoomMessageEventContent::text_html(
-            format!(
-                "Report received from: {}\n\n\
-                Event ID: {}\n\
-                Room ID: {}\n\
-                Sent By: {}\n\n\
-                Report Score: {}\n\
-                Report Reason: {}",
-                sender_user, pdu.event_id, pdu.room_id, pdu.sender, body.score, body.reason
-            ),
-            format!(
-                "<details><summary>Report received from: <a href=\"https://matrix.to/#/{0}\">{0}\
-                </a></summary><ul><li>Event Info<ul><li>Event ID: <code>{1}</code>\
-                <a href=\"https://matrix.to/#/{2}/{1}\">🔗</a></li><li>Room ID: <code>{2}</code>\
-                </li><li>Sent By: <a href=\"https://matrix.to/#/{3}\">{3}</a></li></ul></li><li>\
-                Report Info<ul><li>Report Score: {4}</li><li>Report Reason: {5}</li></ul></li>\
-                </ul></details>",
-                sender_user,
-                pdu.event_id,
-                pdu.room_id,
-                pdu.sender,
-                body.score,
-                RawStr::new(&body.reason).html_escape()
-            ),
-        ),
-    ));
-
-    db.flush()?;
-
-    Ok(report_content::Response {}.into())
-}

src/client_server/room.rs

@@ -22,12 +22,11 @@ use ruma::{
         },
         EventType,
     },
-    int,
+    serde::JsonObject,
-    serde::{CanonicalJsonObject, JsonObject},
     RoomAliasId, RoomId, RoomVersionId,
 };
-use serde_json::{json, value::to_raw_value};
+use serde_json::value::to_raw_value;
-use std::{cmp::max, collections::BTreeMap, convert::TryInto, sync::Arc};
+use std::{cmp::max, collections::BTreeMap, convert::TryFrom, sync::Arc};
 use tracing::{info, warn};
 
 #[cfg(feature = "conduit_bin")]
@@ -84,16 +83,14 @@ pub async fn create_room_route(
         ));
     }
 
-    let alias: Option<Box<RoomAliasId>> =
+    let alias: Option<RoomAliasId> =
         body.room_alias_name
             .as_ref()
             .map_or(Ok(None), |localpart| {
                 // TODO: Check for invalid characters and maximum length
                 let alias =
-                    RoomAliasId::parse(format!("#{}:{}", localpart, db.globals.server_name()))
+                    RoomAliasId::try_from(format!("#{}:{}", localpart, db.globals.server_name()))
-                        .map_err(|_| {
+                        .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;
-                            Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias.")
-                        })?;
 
                 if db.rooms.id_from_alias(&alias)?.is_some() {
                     Err(Error::BadRequest(
@@ -105,9 +102,12 @@ pub async fn create_room_route(
                 }
             })?;
 
-    let room_version = match body.room_version.clone() {
+    let mut content = RoomCreateEventContent::new(sender_user.clone());
+    content.federate = body.creation_content.federate;
+    content.predecessor = body.creation_content.predecessor.clone();
+    content.room_version = match body.room_version.clone() {
         Some(room_version) => {
-            if room_version == RoomVersionId::V5 || room_version == RoomVersionId::V6 {
+            if room_version == RoomVersionId::Version5 || room_version == RoomVersionId::Version6 {
                 room_version
             } else {
                 return Err(Error::BadRequest(
@@ -116,59 +116,9 @@ pub async fn create_room_route(
                 ));
             }
         }
-        None => RoomVersionId::V6,
+        None => RoomVersionId::Version6,
     };
 
-    let content = match &body.creation_content {
-        Some(content) => {
-            let mut content = content
-                .deserialize_as::<CanonicalJsonObject>()
-                .expect("Invalid creation content");
-            content.insert(
-                "creator".into(),
-                json!(&sender_user).try_into().map_err(|_| {
-                    Error::BadRequest(ErrorKind::BadJson, "Invalid creation content")
-                })?,
-            );
-            content.insert(
-                "room_version".into(),
-                json!(room_version.as_str()).try_into().map_err(|_| {
-                    Error::BadRequest(ErrorKind::BadJson, "Invalid creation content")
-                })?,
-            );
-            content
-        }
-        None => {
-            let mut content = serde_json::from_str::<CanonicalJsonObject>(
-                to_raw_value(&RoomCreateEventContent::new(sender_user.clone()))
-                    .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Invalid creation content"))?
-                    .get(),
-            )
-            .unwrap();
-            content.insert(
-                "room_version".into(),
-                json!(room_version.as_str()).try_into().map_err(|_| {
-                    Error::BadRequest(ErrorKind::BadJson, "Invalid creation content")
-                })?,
-            );
-            content
-        }
-    };
-
-    // Validate creation content
-    let de_result = serde_json::from_str::<CanonicalJsonObject>(
-        to_raw_value(&content)
-            .expect("Invalid creation content")
-            .get(),
-    );
-
-    if de_result.is_err() {
-        return Err(Error::BadRequest(
-            ErrorKind::BadJson,
-            "Invalid creation content",
-        ));
-    }
-
     // 1. The room create event
     db.rooms.build_and_append_pdu(
         PduBuilder {
@@ -196,7 +146,6 @@ pub async fn create_room_route(
                 third_party_invite: None,
                 blurhash: db.users.blurhash(sender_user)?,
                 reason: None,
-                join_authorized_via_users_server: None,
             })
             .expect("event is valid, we just created it"),
             unsigned: None,
@@ -222,11 +171,11 @@ pub async fn create_room_route(
         });
 
     let mut users = BTreeMap::new();
-    users.insert(sender_user.clone(), int!(100));
+    users.insert(sender_user.clone(), 100.into());
 
     if preset == create_room::RoomPreset::TrustedPrivateChat {
         for invite_ in &body.invite {
-            users.insert(invite_.clone(), int!(100));
+            users.insert(invite_.clone(), 100.into());
         }
     }
 
@@ -268,7 +217,7 @@ pub async fn create_room_route(
             PduBuilder {
                 event_type: EventType::RoomCanonicalAlias,
                 content: to_raw_value(&RoomCanonicalAliasEventContent {
-                    alias: Some(room_alias_id.to_owned()),
+                    alias: Some(room_alias_id.clone()),
                     alt_aliases: vec![],
                 })
                 .expect("We checked that alias earlier, it must be fine"),
@@ -483,7 +432,7 @@ pub async fn get_room_aliases_route(
     .into())
 }
 
-/// # `POST /_matrix/client/r0/rooms/{roomId}/upgrade`
+/// # `GET /_matrix/client/r0/rooms/{roomId}/upgrade`
 ///
 /// Upgrades the room.
 ///
@@ -504,7 +453,10 @@ pub async fn upgrade_room_route(
 ) -> ConduitResult<upgrade_room::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    if !matches!(body.new_version, RoomVersionId::V5 | RoomVersionId::V6) {
+    if !matches!(
+        body.new_version,
+        RoomVersionId::Version5 | RoomVersionId::Version6
+    ) {
         return Err(Error::BadRequest(
             ErrorKind::UnsupportedRoomVersion,
             "This server does not support that room version.",
@@ -558,55 +510,28 @@ pub async fn upgrade_room_route(
     );
     let state_lock = mutex_state.lock().await;
 
-    // Get the old room creation event
+    // Get the old room federations status
-    let mut create_event_content = serde_json::from_str::<CanonicalJsonObject>(
+    let federate = serde_json::from_str::<RoomCreateEventContent>(
         db.rooms
             .room_state_get(&body.room_id, &EventType::RoomCreate, "")?
             .ok_or_else(|| Error::bad_database("Found room without m.room.create event."))?
             .content
             .get(),
     )
-    .map_err(|_| Error::bad_database("Invalid room event in database."))?;
+    .map_err(|_| Error::bad_database("Invalid room event in database."))?
+    .federate;
 
     // Use the m.room.tombstone event as the predecessor
     let predecessor = Some(ruma::events::room::create::PreviousRoom::new(
         body.room_id.clone(),
-        (*tombstone_event_id).to_owned(),
+        tombstone_event_id,
     ));
 
     // Send a m.room.create event containing a predecessor field and the applicable room_version
-    create_event_content.insert(
+    let mut create_event_content = RoomCreateEventContent::new(sender_user.clone());
-        "creator".into(),
+    create_event_content.federate = federate;
-        json!(&sender_user)
+    create_event_content.room_version = body.new_version.clone();
-            .try_into()
+    create_event_content.predecessor = predecessor;
-            .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Error forming creation event"))?,
-    );
-    create_event_content.insert(
-        "room_version".into(),
-        json!(&body.new_version)
-            .try_into()
-            .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Error forming creation event"))?,
-    );
-    create_event_content.insert(
-        "predecessor".into(),
-        json!(predecessor)
-            .try_into()
-            .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Error forming creation event"))?,
-    );
-
-    // Validate creation event content
-    let de_result = serde_json::from_str::<CanonicalJsonObject>(
-        to_raw_value(&create_event_content)
-            .expect("Error forming creation event")
-            .get(),
-    );
-
-    if de_result.is_err() {
-        return Err(Error::BadRequest(
-            ErrorKind::BadJson,
-            "Error forming creation event",
-        ));
-    }
 
     db.rooms.build_and_append_pdu(
         PduBuilder {
@@ -635,7 +560,6 @@ pub async fn upgrade_room_route(
                 third_party_invite: None,
                 blurhash: db.users.blurhash(sender_user)?,
                 reason: None,
-                join_authorized_via_users_server: None,
             })
             .expect("event is valid, we just created it"),
             unsigned: None,
@@ -700,7 +624,10 @@ pub async fn upgrade_room_route(
     .map_err(|_| Error::bad_database("Invalid room event in database."))?;
 
     // Setting events_default and invite to the greater of 50 and users_default + 1
-    let new_level = max(int!(50), power_levels_event_content.users_default + int!(1));
+    let new_level = max(
+        50.into(),
+        power_levels_event_content.users_default + 1.into(),
+    );
     power_levels_event_content.events_default = new_level;
     power_levels_event_content.invite = new_level;
 

src/client_server/state.rs

@@ -52,7 +52,6 @@ pub async fn send_state_event_for_key_route(
 
     db.flush()?;
 
-    let event_id = (*event_id).to_owned();
     Ok(send_state_event::Response { event_id }.into())
 }
 
@@ -94,7 +93,6 @@ pub async fn send_state_event_for_empty_key_route(
 
     db.flush()?;
 
-    let event_id = (*event_id).to_owned();
     Ok(send_state_event::Response { event_id }.into())
 }
 
@@ -269,7 +267,7 @@ async fn send_state_event_for_key_helper(
     event_type: EventType,
     json: &Raw<AnyStateEventContent>,
     state_key: String,
-) -> Result<Arc<EventId>> {
+) -> Result<EventId> {
     let sender_user = sender;
 
     // TODO: Review this check, error if event is unparsable, use event type, allow alias if it
@@ -305,7 +303,7 @@ async fn send_state_event_for_key_helper(
             .roomid_mutex_state
             .write()
             .unwrap()
-            .entry(room_id.to_owned())
+            .entry(room_id.clone())
             .or_default(),
     );
     let state_lock = mutex_state.lock().await;

src/client_server/sync.rs

@@ -10,7 +10,7 @@ use ruma::{
 };
 use std::{
     collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
-    convert::TryInto,
+    convert::{TryFrom, TryInto},
     sync::Arc,
     time::Duration,
 };
@@ -61,9 +61,8 @@ pub async fn sync_events_route(
     db: DatabaseGuard,
     body: Ruma<sync_events::Request<'_>>,
 ) -> Result<RumaResponse<sync_events::Response>, RumaResponse<UiaaResponse>> {
-    let sender_user = body.sender_user.expect("user is authenticated");
+    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-    let sender_device = body.sender_device.expect("user is authenticated");
+    let sender_device = body.sender_device.as_ref().expect("user is authenticated");
-    let body = body.body;
 
     let arc_db = Arc::new(db);
 
@@ -133,7 +132,7 @@ pub async fn sync_events_route(
 
 async fn sync_helper_wrapper(
     db: Arc<DatabaseGuard>,
-    sender_user: Box<UserId>,
+    sender_user: UserId,
     sender_device: Box<DeviceId>,
     since: Option<String>,
     full_state: bool,
@@ -177,7 +176,7 @@ async fn sync_helper_wrapper(
 
 async fn sync_helper(
     db: Arc<DatabaseGuard>,
-    sender_user: Box<UserId>,
+    sender_user: UserId,
     sender_device: Box<DeviceId>,
     since: Option<String>,
     full_state: bool,
@@ -297,7 +296,7 @@ async fn sync_helper(
                             })?;
 
                         if let Some(state_key) = &pdu.state_key {
-                            let user_id = UserId::parse(state_key.clone()).map_err(|_| {
+                            let user_id = UserId::try_from(state_key.clone()).map_err(|_| {
                                 Error::bad_database("Invalid UserId in member PDU.")
                             })?;
 
@@ -425,7 +424,7 @@ async fn sync_helper(
                     }
 
                     if let Some(state_key) = &state_event.state_key {
-                        let user_id = UserId::parse(state_key.clone())
+                        let user_id = UserId::try_from(state_key.clone())
                             .map_err(|_| Error::bad_database("Invalid UserId in member PDU."))?;
 
                         if user_id == sender_user {
@@ -794,7 +793,7 @@ fn share_encrypted_room(
 ) -> Result<bool> {
     Ok(db
         .rooms
-        .get_shared_rooms(vec![sender_user.to_owned(), user_id.to_owned()])?
+        .get_shared_rooms(vec![sender_user.clone(), user_id.clone()])?
         .filter_map(|r| r.ok())
         .filter(|room_id| room_id != ignore_room)
         .filter_map(|other_room_id| {

src/client_server/voip.rs

@@ -1,11 +1,6 @@
-use crate::{database::DatabaseGuard, ConduitResult, Ruma};
+use crate::ConduitResult;
-use hmac::{Hmac, Mac, NewMac};
 use ruma::api::client::r0::voip::get_turn_server_info;
-use ruma::SecondsSinceUnixEpoch;
+use std::time::Duration;
-use sha1::Sha1;
-use std::time::{Duration, SystemTime};
-
-type HmacSha1 = Hmac<Sha1>;
 
 #[cfg(feature = "conduit_bin")]
 use rocket::get;
@@ -13,46 +8,14 @@ use rocket::get;
 /// # `GET /_matrix/client/r0/voip/turnServer`
 ///
 /// TODO: Returns information about the recommended turn server.
-#[cfg_attr(
+#[cfg_attr(feature = "conduit_bin", get("/_matrix/client/r0/voip/turnServer"))]
-    feature = "conduit_bin",
+#[tracing::instrument]
-    get("/_matrix/client/r0/voip/turnServer", data = "<body>")
+pub async fn turn_server_route() -> ConduitResult<get_turn_server_info::Response> {
-)]
-#[tracing::instrument(skip(body, db))]
-pub async fn turn_server_route(
-    body: Ruma<get_turn_server_info::Request>,
-    db: DatabaseGuard,
-) -> ConduitResult<get_turn_server_info::Response> {
-    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-
-    let turn_secret = db.globals.turn_secret();
-
-    let (username, password) = if !turn_secret.is_empty() {
-        let expiry = SecondsSinceUnixEpoch::from_system_time(
-            SystemTime::now() + Duration::from_secs(db.globals.turn_ttl()),
-        )
-        .expect("time is valid");
-
-        let username: String = format!("{}:{}", expiry.get(), sender_user);
-
-        let mut mac = HmacSha1::new_from_slice(turn_secret.as_bytes())
-            .expect("HMAC can take key of any size");
-        mac.update(username.as_bytes());
-
-        let password: String = base64::encode_config(mac.finalize().into_bytes(), base64::STANDARD);
-
-        (username, password)
-    } else {
-        (
-            db.globals.turn_username().clone(),
-            db.globals.turn_password().clone(),
-        )
-    };
-
     Ok(get_turn_server_info::Response {
-        username,
+        username: "".to_owned(),
-        password,
+        password: "".to_owned(),
-        uris: db.globals.turn_uris().to_vec(),
+        uris: Vec::new(),
-        ttl: Duration::from_secs(db.globals.turn_ttl()),
+        ttl: Duration::from_secs(60 * 60 * 24),
     }
     .into())
 }

src/database.rs

@@ -74,16 +74,6 @@ pub struct Config {
     trusted_servers: Vec<Box<ServerName>>,
     #[serde(default = "default_log")]
     pub log: String,
-    #[serde(default)]
-    turn_username: String,
-    #[serde(default)]
-    turn_password: String,
-    #[serde(default = "Vec::new")]
-    turn_uris: Vec<String>,
-    #[serde(default)]
-    turn_secret: String,
-    #[serde(default = "default_turn_ttl")]
-    turn_ttl: u64,
 
     #[serde(flatten)]
     catchall: BTreeMap<String, IgnoredAny>,
@@ -141,10 +131,6 @@ fn default_log() -> String {
     "info,state_res=warn,rocket=off,_=off,sled=off".to_owned()
 }
 
-fn default_turn_ttl() -> u64 {
-    60 * 60 * 24
-}
-
 #[cfg(feature = "sled")]
 pub type Engine = abstraction::sled::Engine;
 
@@ -476,9 +462,10 @@ impl Database {
             if db.globals.database_version()? < 6 {
                 // Set room member count
                 for (roomid, _) in db.rooms.roomid_shortstatehash.iter() {
-                    let string = utils::string_from_bytes(&roomid).unwrap();
+                    let room_id =
-                    let room_id = <&RoomId>::try_from(string.as_str()).unwrap();
+                        RoomId::try_from(utils::string_from_bytes(&roomid).unwrap()).unwrap();
-                    db.rooms.update_joined_count(room_id, &db)?;
+
+                    db.rooms.update_joined_count(&room_id, &db)?;
                 }
 
                 db.globals.bump_database_version(6)?;
@@ -488,7 +475,7 @@ impl Database {
 
             if db.globals.database_version()? < 7 {
                 // Upgrade state store
-                let mut last_roomstates: HashMap<Box<RoomId>, u64> = HashMap::new();
+                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();
@@ -569,7 +556,7 @@ impl Database {
                         if let Some(current_sstatehash) = current_sstatehash {
                             handle_state(
                                 current_sstatehash,
-                                current_room.as_deref().unwrap(),
+                                current_room.as_ref().unwrap(),
                                 current_state,
                                 &mut last_roomstates,
                             )?;
@@ -585,9 +572,10 @@ impl Database {
                             .get(&seventid)
                             .unwrap()
                             .unwrap();
-                        let string = utils::string_from_bytes(&event_id).unwrap();
+                        let event_id =
-                        let event_id = <&EventId>::try_from(string.as_str()).unwrap();
+                            EventId::try_from(utils::string_from_bytes(&event_id).unwrap())
-                        let pdu = db.rooms.get_pdu(event_id).unwrap().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());
@@ -602,7 +590,7 @@ impl Database {
                 if let Some(current_sstatehash) = current_sstatehash {
                     handle_state(
                         current_sstatehash,
-                        current_room.as_deref().unwrap(),
+                        current_room.as_ref().unwrap(),
                         current_state,
                         &mut last_roomstates,
                     )?;

src/database/admin.rs

@@ -1,4 +1,7 @@
-use std::{convert::TryInto, sync::Arc};
+use std::{
+    convert::{TryFrom, TryInto},
+    sync::Arc,
+};
 
 use crate::{pdu::PduBuilder, Database};
 use rocket::futures::{channel::mpsc, stream::StreamExt};
@@ -33,14 +36,14 @@ impl Admin {
 
             let guard = db.read().await;
 
-            let conduit_user = UserId::parse(format!("@conduit:{}", guard.globals.server_name()))
+            let conduit_user =
+                UserId::try_from(format!("@conduit:{}", guard.globals.server_name()))
                     .expect("@conduit:server_name is valid");
 
             let conduit_room = guard
                 .rooms
                 .id_from_alias(
-                    format!("#admins:{}", guard.globals.server_name())
+                    &format!("#admins:{}", guard.globals.server_name())
-                        .as_str()
                         .try_into()
                         .expect("#admins:server_name is a valid room alias"),
                 )

src/database/globals.rs

@@ -40,13 +40,13 @@ pub struct Globals {
     dns_resolver: TokioAsyncResolver,
     jwt_decoding_key: Option<jsonwebtoken::DecodingKey<'static>>,
     pub(super) server_signingkeys: Arc<dyn Tree>,
-    pub bad_event_ratelimiter: Arc<RwLock<HashMap<Box<EventId>, RateLimitState>>>,
+    pub bad_event_ratelimiter: Arc<RwLock<HashMap<EventId, RateLimitState>>>,
     pub bad_signature_ratelimiter: Arc<RwLock<HashMap<Vec<String>, RateLimitState>>>,
     pub servername_ratelimiter: Arc<RwLock<HashMap<Box<ServerName>, Arc<Semaphore>>>>,
-    pub sync_receivers: RwLock<HashMap<(Box<UserId>, Box<DeviceId>), SyncHandle>>,
+    pub sync_receivers: RwLock<HashMap<(UserId, Box<DeviceId>), SyncHandle>>,
-    pub roomid_mutex_insert: RwLock<HashMap<Box<RoomId>, Arc<Mutex<()>>>>,
+    pub roomid_mutex_insert: RwLock<HashMap<RoomId, Arc<Mutex<()>>>>,
-    pub roomid_mutex_state: RwLock<HashMap<Box<RoomId>, Arc<TokioMutex<()>>>>,
+    pub roomid_mutex_state: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>,
-    pub roomid_mutex_federation: RwLock<HashMap<Box<RoomId>, Arc<TokioMutex<()>>>>, // this lock will be held longer
+    pub roomid_mutex_federation: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>, // this lock will be held longer
     pub rotate: RotationHandler,
 }
 
@@ -226,26 +226,6 @@ impl Globals {
         self.jwt_decoding_key.as_ref()
     }
 
-    pub fn turn_password(&self) -> &String {
-        &self.config.turn_password
-    }
-
-    pub fn turn_ttl(&self) -> u64 {
-        self.config.turn_ttl
-    }
-
-    pub fn turn_uris(&self) -> &[String] {
-        &self.config.turn_uris
-    }
-
-    pub fn turn_username(&self) -> &String {
-        &self.config.turn_username
-    }
-
-    pub fn turn_secret(&self) -> &String {
-        &self.config.turn_secret
-    }
-
     /// TODO: the key valid until timestamp is only honored in room version > 4
     /// Remove the outdated keys and insert the new ones.
     ///
@@ -254,7 +234,7 @@ impl Globals {
         &self,
         origin: &ServerName,
         new_keys: ServerSigningKeys,
-    ) -> Result<BTreeMap<Box<ServerSigningKeyId>, VerifyKey>> {
+    ) -> Result<BTreeMap<ServerSigningKeyId, VerifyKey>> {
         // Not atomic, but this is not critical
         let signingkeys = self.server_signingkeys.get(origin.as_bytes())?;
 
@@ -293,7 +273,7 @@ impl Globals {
     pub fn signing_keys_for(
         &self,
         origin: &ServerName,
-    ) -> Result<BTreeMap<Box<ServerSigningKeyId>, VerifyKey>> {
+    ) -> Result<BTreeMap<ServerSigningKeyId, VerifyKey>> {
         let signingkeys = self
             .server_signingkeys
             .get(origin.as_bytes())?

src/database/key_backups.rs

@@ -6,7 +6,7 @@ use ruma::{
     },
     RoomId, UserId,
 };
-use std::{collections::BTreeMap, sync::Arc};
+use std::{collections::BTreeMap, convert::TryFrom, sync::Arc};
 
 use super::abstraction::Tree;
 
@@ -209,13 +209,13 @@ impl KeyBackups {
         &self,
         user_id: &UserId,
         version: &str,
-    ) -> Result<BTreeMap<Box<RoomId>, RoomKeyBackup>> {
+    ) -> Result<BTreeMap<RoomId, RoomKeyBackup>> {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
         prefix.extend_from_slice(version.as_bytes());
         prefix.push(0xff);
 
-        let mut rooms = BTreeMap::<Box<RoomId>, RoomKeyBackup>::new();
+        let mut rooms = BTreeMap::<RoomId, RoomKeyBackup>::new();
 
         for result in self
             .backupkeyid_backup
@@ -231,7 +231,7 @@ impl KeyBackups {
                         Error::bad_database("backupkeyid_backup session_id is invalid.")
                     })?;
 
-                let room_id = RoomId::parse(
+                let room_id = RoomId::try_from(
                     utils::string_from_bytes(parts.next().ok_or_else(|| {
                         Error::bad_database("backupkeyid_backup key is invalid.")
                     })?)

src/database/pusher.rs

@@ -234,7 +234,7 @@ pub fn get_actions<'a>(
     db: &Database,
 ) -> Result<&'a [Action]> {
     let ctx = PushConditionRoomCtx {
-        room_id: room_id.to_owned(),
+        room_id: room_id.clone(),
         member_count: 10_u32.into(), // TODO: get member count efficiently
         user_display_name: db
             .users
@@ -277,7 +277,7 @@ async fn send_notice(
     let mut data_minus_url = pusher.data.clone();
     // The url must be stripped off according to spec
     data_minus_url.url = None;
-    device.data = data_minus_url;
+    device.data = Some(data_minus_url);
 
     // Tweaks are only added if the format is NOT event_id_only
     if !event_id_only {

src/database/rooms.rs

@@ -36,8 +36,6 @@ use std::{
     borrow::Cow,
     collections::{BTreeMap, HashMap, HashSet},
     convert::{TryFrom, TryInto},
-    fmt::Debug,
-    iter,
     mem::size_of,
     sync::{Arc, Mutex, RwLock},
     time::Instant,
@@ -109,14 +107,14 @@ pub struct Rooms {
     /// RoomId + EventId -> Parent PDU EventId.
     pub(super) referencedevents: Arc<dyn Tree>,
 
-    pub(super) pdu_cache: Mutex<LruCache<Box<EventId>, Arc<PduEvent>>>,
+    pub(super) pdu_cache: Mutex<LruCache<EventId, Arc<PduEvent>>>,
     pub(super) shorteventid_cache: Mutex<LruCache<u64, Arc<EventId>>>,
     pub(super) auth_chain_cache: Mutex<LruCache<Vec<u64>, Arc<HashSet<u64>>>>,
-    pub(super) eventidshort_cache: Mutex<LruCache<Box<EventId>, u64>>,
+    pub(super) eventidshort_cache: Mutex<LruCache<EventId, u64>>,
     pub(super) statekeyshort_cache: Mutex<LruCache<(EventType, String), u64>>,
     pub(super) shortstatekey_cache: Mutex<LruCache<u64, (EventType, String)>>,
-    pub(super) our_real_users_cache: RwLock<HashMap<Box<RoomId>, Arc<HashSet<Box<UserId>>>>>,
+    pub(super) our_real_users_cache: RwLock<HashMap<RoomId, Arc<HashSet<UserId>>>>,
-    pub(super) appservice_in_room_cache: RwLock<HashMap<Box<RoomId>, HashMap<String, bool>>>,
+    pub(super) appservice_in_room_cache: RwLock<HashMap<RoomId, HashMap<String, bool>>>,
     pub(super) stateinfo_cache: Mutex<
         LruCache<
             u64,
@@ -436,7 +434,7 @@ impl Rooms {
                 None => continue,
             };
 
-            let user_id = match UserId::parse(state_key) {
+            let user_id = match UserId::try_from(state_key) {
                 Ok(id) => id,
                 Err(_) => continue,
             };
@@ -744,7 +742,7 @@ impl Rooms {
         self.eventidshort_cache
             .lock()
             .unwrap()
-            .insert(event_id.to_owned(), short);
+            .insert(event_id.clone(), short);
 
         Ok(short)
     }
@@ -873,10 +871,12 @@ impl Rooms {
             .get(&shorteventid.to_be_bytes())?
             .ok_or_else(|| Error::bad_database("Shorteventid does not exist"))?;
 
-        let event_id = EventId::parse_arc(utils::string_from_bytes(&bytes).map_err(|_| {
+        let event_id = Arc::new(
+            EventId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
                 Error::bad_database("EventID in shorteventid_eventid is invalid unicode.")
             })?)
-        .map_err(|_| Error::bad_database("EventId in shorteventid_eventid is invalid."))?;
+            .map_err(|_| Error::bad_database("EventId in shorteventid_eventid is invalid."))?,
+        );
 
         self.shorteventid_cache
             .lock()
@@ -1112,7 +1112,7 @@ impl Rooms {
             self.pdu_cache
                 .lock()
                 .unwrap()
-                .insert(event_id.to_owned(), Arc::clone(&pdu));
+                .insert(event_id.clone(), Arc::clone(&pdu));
             Ok(Some(pdu))
         } else {
             Ok(None)
@@ -1162,14 +1162,14 @@ impl Rooms {
 
     /// Returns the leaf pdus of a room.
     #[tracing::instrument(skip(self))]
-    pub fn get_pdu_leaves(&self, room_id: &RoomId) -> Result<HashSet<Arc<EventId>>> {
+    pub fn get_pdu_leaves(&self, room_id: &RoomId) -> Result<HashSet<EventId>> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
         self.roomid_pduleaves
             .scan_prefix(prefix)
             .map(|(_, bytes)| {
-                EventId::parse_arc(utils::string_from_bytes(&bytes).map_err(|_| {
+                EventId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
                     Error::bad_database("EventID in roomid_pduleaves is invalid unicode.")
                 })?)
                 .map_err(|_| Error::bad_database("EventId in roomid_pduleaves is invalid."))
@@ -1178,7 +1178,7 @@ impl Rooms {
     }
 
     #[tracing::instrument(skip(self, room_id, event_ids))]
-    pub fn mark_as_referenced(&self, room_id: &RoomId, event_ids: &[Arc<EventId>]) -> Result<()> {
+    pub fn mark_as_referenced(&self, room_id: &RoomId, event_ids: &[EventId]) -> Result<()> {
         for prev in event_ids {
             let mut key = room_id.as_bytes().to_vec();
             key.extend_from_slice(prev.as_bytes());
@@ -1193,11 +1193,7 @@ impl Rooms {
     /// The provided `event_ids` become the new leaves, this allows a room to have multiple
     /// `prev_events`.
     #[tracing::instrument(skip(self))]
-    pub fn replace_pdu_leaves<'a>(
+    pub fn replace_pdu_leaves(&self, room_id: &RoomId, event_ids: &[EventId]) -> Result<()> {
-        &self,
-        room_id: &RoomId,
-        event_ids: impl IntoIterator<Item = &'a EventId> + Debug,
-    ) -> Result<()> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -1261,11 +1257,11 @@ impl Rooms {
     ///
     /// Returns pdu id
     #[tracing::instrument(skip(self, pdu, pdu_json, leaves, db))]
-    pub fn append_pdu<'a>(
+    pub fn append_pdu(
         &self,
         pdu: &PduEvent,
         mut pdu_json: CanonicalJsonObject,
-        leaves: impl IntoIterator<Item = &'a EventId> + Debug,
+        leaves: &[EventId],
         db: &Database,
     ) -> Result<Vec<u8>> {
         let shortroomid = self.get_shortroomid(&pdu.room_id)?.expect("room exists");
@@ -1424,7 +1420,7 @@ impl Rooms {
                     }
 
                     // if the state_key fails
-                    let target_user_id = UserId::parse(state_key.clone())
+                    let target_user_id = UserId::try_from(state_key.clone())
                         .expect("This state_key was previously validated");
 
                     let content = serde_json::from_str::<ExtractMembership>(pdu.content.get())
@@ -1480,9 +1476,8 @@ impl Rooms {
                     if body.starts_with(&format!("@conduit:{}: ", db.globals.server_name()))
                         && self
                             .id_from_alias(
-                                <&RoomAliasId>::try_from(
+                                &format!("#admins:{}", db.globals.server_name())
-                                    format!("#admins:{}", db.globals.server_name()).as_str(),
+                                    .try_into()
-                                )
                                     .expect("#admins:server_name is a valid room alias"),
                             )?
                             .as_ref()
@@ -1533,7 +1528,7 @@ impl Rooms {
                                 }
                                 "get_auth_chain" => {
                                     if args.len() == 1 {
-                                        if let Ok(event_id) = EventId::parse_arc(args[0]) {
+                                        if let Ok(event_id) = EventId::try_from(args[0]) {
                                             if let Some(event) = db.rooms.get_pdu_json(&event_id)? {
                                                 let room_id_str = event
                                                     .get("room_id")
@@ -1544,12 +1539,12 @@ impl Rooms {
                                                         )
                                                     })?;
 
-                                                let room_id = <&RoomId>::try_from(room_id_str)
+                                                let room_id = RoomId::try_from(room_id_str)
                                                 .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;
                                                 let start = Instant::now();
                                                 let count = server_server::get_auth_chain(
-                                                    room_id,
+                                                    &room_id,
-                                                    vec![event_id],
+                                                    vec![Arc::new(event_id)],
                                                     db,
                                                 )?
                                                 .count();
@@ -1572,12 +1567,12 @@ impl Rooms {
                                         let string = body[1..body.len() - 1].join("\n");
                                         match serde_json::from_str(&string) {
                                             Ok(value) => {
-                                                let event_id = EventId::parse(format!(
+                                                let event_id = EventId::try_from(&*format!(
                                                     "${}",
                                                     // Anything higher than version3 behaves the same
                                                     ruma::signatures::reference_hash(
                                                         &value,
-                                                        &RoomVersionId::V6
+                                                        &RoomVersionId::Version6
                                                     )
                                                     .expect("ruma can calculate reference hashes")
                                                 ))
@@ -1627,7 +1622,7 @@ impl Rooms {
                                 }
                                 "get_pdu" => {
                                     if args.len() == 1 {
-                                        if let Ok(event_id) = EventId::parse(args[0]) {
+                                        if let Ok(event_id) = EventId::try_from(args[0]) {
                                             let mut outlier = false;
                                             let mut pdu_json =
                                                 db.rooms.get_non_outlier_pdu_json(&event_id)?;
@@ -1953,7 +1948,7 @@ impl Rooms {
         room_id: &RoomId,
         db: &Database,
         _mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room mutex
-    ) -> Result<Arc<EventId>> {
+    ) -> Result<EventId> {
         let PduBuilder {
             event_type,
             content,
@@ -1990,7 +1985,9 @@ impl Rooms {
 
         // If there was no create event yet, assume we are creating a version 6 room right now
         let room_version_id = create_event_content
-            .map_or(RoomVersionId::V6, |create_event| create_event.room_version);
+            .map_or(RoomVersionId::Version6, |create_event| {
+                create_event.room_version
+            });
         let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");
 
         let auth_events =
@@ -2019,9 +2016,9 @@ impl Rooms {
         }
 
         let mut pdu = PduEvent {
-            event_id: ruma::event_id!("$thiswillbefilledinlater").into(),
+            event_id: ruma::event_id!("$thiswillbefilledinlater"),
-            room_id: room_id.to_owned(),
+            room_id: room_id.clone(),
-            sender: sender.to_owned(),
+            sender: sender.clone(),
             origin_server_ts: utils::millis_since_unix_epoch()
                 .try_into()
                 .expect("time is valid"),
@@ -2086,7 +2083,7 @@ impl Rooms {
         .expect("event is valid, we just created it");
 
         // Generate event id
-        pdu.event_id = EventId::parse_arc(format!(
+        pdu.event_id = EventId::try_from(&*format!(
             "${}",
             ruma::signatures::reference_hash(&pdu_json, &room_version_id)
                 .expect("ruma can calculate reference hashes")
@@ -2110,7 +2107,7 @@ impl Rooms {
             pdu_json,
             // Since this PDU references all pdu_leaves we can update the leaves
             // of the room
-            iter::once(&*pdu.event_id),
+            &[pdu.event_id.clone()],
             db,
         )?;
 
@@ -2209,7 +2206,7 @@ impl Rooms {
         let mut first_pdu_id = prefix.clone();
         first_pdu_id.extend_from_slice(&(since + 1).to_be_bytes());
 
-        let user_id = user_id.to_owned();
+        let user_id = user_id.clone();
 
         Ok(self
             .pduid_pdu
@@ -2246,7 +2243,7 @@ impl Rooms {
 
         let current: &[u8] = &current;
 
-        let user_id = user_id.to_owned();
+        let user_id = user_id.clone();
 
         Ok(self
             .pduid_pdu
@@ -2283,7 +2280,7 @@ impl Rooms {
 
         let current: &[u8] = &current;
 
-        let user_id = user_id.to_owned();
+        let user_id = user_id.clone();
 
         Ok(self
             .pduid_pdu
@@ -2415,7 +2412,7 @@ impl Rooms {
 
                             for room_ids in direct_event.content.0.values_mut() {
                                 if room_ids.iter().any(|r| r == &predecessor.room_id) {
-                                    room_ids.push(room_id.to_owned());
+                                    room_ids.push(room_id.clone());
                                     room_ids_updated = true;
                                 }
                             }
@@ -2454,11 +2451,7 @@ impl Rooms {
                         EventType::IgnoredUserList,
                     )?
                     .map_or(false, |ignored| {
-                        ignored
+                        ignored.content.ignored_users.contains(sender)
-                            .content
-                            .ignored_users
-                            .iter()
-                            .any(|user| user == sender)
                     });
 
                 if is_ignored {
@@ -2544,7 +2537,7 @@ impl Rooms {
         self.our_real_users_cache
             .write()
             .unwrap()
-            .insert(room_id.to_owned(), Arc::new(real_users));
+            .insert(room_id.clone(), Arc::new(real_users));
 
         for old_joined_server in self.room_servers(room_id).filter_map(|r| r.ok()) {
             if !joined_servers.remove(&old_joined_server) {
@@ -2589,7 +2582,7 @@ impl Rooms {
         &self,
         room_id: &RoomId,
         db: &Database,
-    ) -> Result<Arc<HashSet<Box<UserId>>>> {
+    ) -> Result<Arc<HashSet<UserId>>> {
         let maybe = self
             .our_real_users_cache
             .read()
@@ -2657,7 +2650,7 @@ impl Rooms {
             self.appservice_in_room_cache
                 .write()
                 .unwrap()
-                .entry(room_id.to_owned())
+                .entry(room_id.clone())
                 .or_default()
                 .insert(appservice.0.clone(), in_room);
 
@@ -2701,7 +2694,7 @@ impl Rooms {
                     .roomid_mutex_state
                     .write()
                     .unwrap()
-                    .entry(room_id.to_owned())
+                    .entry(room_id.clone())
                     .or_default(),
             );
             let state_lock = mutex_state.lock().await;
@@ -2761,7 +2754,7 @@ impl Rooms {
             .filter_map(|event| serde_json::from_str(event.json().get()).ok())
             .filter_map(|event: serde_json::Value| event.get("sender").cloned())
             .filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
-            .filter_map(|sender| UserId::parse(sender).ok())
+            .filter_map(|sender| UserId::try_from(sender).ok())
             .map(|user| user.server_name().to_owned())
             .collect();
 
@@ -2785,7 +2778,9 @@ impl Rooms {
         let (make_leave_response, remote_server) = make_leave_response_and_server?;
 
         let room_version_id = match make_leave_response.room_version {
-            Some(version) if version == RoomVersionId::V5 || version == RoomVersionId::V6 => {
+            Some(version)
+                if version == RoomVersionId::Version5 || version == RoomVersionId::Version6 =>
+            {
                 version
             }
             _ => return Err(Error::BadServerResponse("Room version is not supported")),
@@ -2822,7 +2817,7 @@ impl Rooms {
         .expect("event is valid, we just created it");
 
         // Generate event id
-        let event_id = EventId::parse(format!(
+        let event_id = EventId::try_from(&*format!(
             "${}",
             ruma::signatures::reference_hash(&leave_event_stub, &room_version_id)
                 .expect("ruma can calculate reference hashes")
@@ -2907,11 +2902,11 @@ impl Rooms {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn id_from_alias(&self, alias: &RoomAliasId) -> Result<Option<Box<RoomId>>> {
+    pub fn id_from_alias(&self, alias: &RoomAliasId) -> Result<Option<RoomId>> {
         self.alias_roomid
             .get(alias.alias().as_bytes())?
             .map(|bytes| {
-                RoomId::parse(utils::string_from_bytes(&bytes).map_err(|_| {
+                RoomId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
                     Error::bad_database("Room ID in alias_roomid is invalid unicode.")
                 })?)
                 .map_err(|_| Error::bad_database("Room ID in alias_roomid is invalid."))
@@ -2923,7 +2918,7 @@ impl Rooms {
     pub fn room_aliases<'a>(
         &'a self,
         room_id: &RoomId,
-    ) -> impl Iterator<Item = Result<Box<RoomAliasId>>> + 'a {
+    ) -> impl Iterator<Item = Result<RoomAliasId>> + 'a {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -2952,9 +2947,9 @@ impl Rooms {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn public_rooms(&self) -> impl Iterator<Item = Result<Box<RoomId>>> + '_ {
+    pub fn public_rooms(&self) -> impl Iterator<Item = Result<RoomId>> + '_ {
         self.publicroomids.iter().map(|(bytes, _)| {
-            RoomId::parse(
+            RoomId::try_from(
                 utils::string_from_bytes(&bytes).map_err(|_| {
                     Error::bad_database("Room ID in publicroomids is invalid unicode.")
                 })?,
@@ -3014,8 +3009,8 @@ impl Rooms {
     #[tracing::instrument(skip(self))]
     pub fn get_shared_rooms<'a>(
         &'a self,
-        users: Vec<Box<UserId>>,
+        users: Vec<UserId>,
-    ) -> Result<impl Iterator<Item = Result<Box<RoomId>>> + 'a> {
+    ) -> Result<impl Iterator<Item = Result<RoomId>> + 'a> {
         let iterators = users.into_iter().map(move |user_id| {
             let mut prefix = user_id.as_bytes().to_vec();
             prefix.push(0xff);
@@ -3042,7 +3037,7 @@ impl Rooms {
         Ok(utils::common_elements(iterators, Ord::cmp)
             .expect("users is not empty")
             .map(|bytes| {
-                RoomId::parse(utils::string_from_bytes(&*bytes).map_err(|_| {
+                RoomId::try_from(utils::string_from_bytes(&*bytes).map_err(|_| {
                     Error::bad_database("Invalid RoomId bytes in userroomid_joined")
                 })?)
                 .map_err(|_| Error::bad_database("Invalid RoomId in userroomid_joined."))
@@ -3059,7 +3054,7 @@ impl Rooms {
         prefix.push(0xff);
 
         self.roomserverids.scan_prefix(prefix).map(|(key, _)| {
-            ServerName::parse(
+            Box::<ServerName>::try_from(
                 utils::string_from_bytes(
                     key.rsplit(|&b| b == 0xff)
                         .next()
@@ -3087,12 +3082,12 @@ impl Rooms {
     pub fn server_rooms<'a>(
         &'a self,
         server: &ServerName,
-    ) -> impl Iterator<Item = Result<Box<RoomId>>> + 'a {
+    ) -> impl Iterator<Item = Result<RoomId>> + 'a {
         let mut prefix = server.as_bytes().to_vec();
         prefix.push(0xff);
 
         self.serverroomids.scan_prefix(prefix).map(|(key, _)| {
-            RoomId::parse(
+            RoomId::try_from(
                 utils::string_from_bytes(
                     key.rsplit(|&b| b == 0xff)
                         .next()
@@ -3109,12 +3104,12 @@ impl Rooms {
     pub fn room_members<'a>(
         &'a self,
         room_id: &RoomId,
-    ) -> impl Iterator<Item = Result<Box<UserId>>> + 'a {
+    ) -> impl Iterator<Item = Result<UserId>> + 'a {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
         self.roomuserid_joined.scan_prefix(prefix).map(|(key, _)| {
-            UserId::parse(
+            UserId::try_from(
                 utils::string_from_bytes(
                     key.rsplit(|&b| b == 0xff)
                         .next()
@@ -3155,14 +3150,14 @@ impl Rooms {
     pub fn room_useroncejoined<'a>(
         &'a self,
         room_id: &RoomId,
-    ) -> impl Iterator<Item = Result<Box<UserId>>> + 'a {
+    ) -> impl Iterator<Item = Result<UserId>> + 'a {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
         self.roomuseroncejoinedids
             .scan_prefix(prefix)
             .map(|(key, _)| {
-                UserId::parse(
+                UserId::try_from(
                     utils::string_from_bytes(
                         key.rsplit(|&b| b == 0xff)
                             .next()
@@ -3181,14 +3176,14 @@ impl Rooms {
     pub fn room_members_invited<'a>(
         &'a self,
         room_id: &RoomId,
-    ) -> impl Iterator<Item = Result<Box<UserId>>> + 'a {
+    ) -> impl Iterator<Item = Result<UserId>> + 'a {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
         self.roomuserid_invitecount
             .scan_prefix(prefix)
             .map(|(key, _)| {
-                UserId::parse(
+                UserId::try_from(
                     utils::string_from_bytes(
                         key.rsplit(|&b| b == 0xff)
                             .next()
@@ -3237,11 +3232,11 @@ impl Rooms {
     pub fn rooms_joined<'a>(
         &'a self,
         user_id: &UserId,
-    ) -> impl Iterator<Item = Result<Box<RoomId>>> + 'a {
+    ) -> impl Iterator<Item = Result<RoomId>> + 'a {
         self.userroomid_joined
             .scan_prefix(user_id.as_bytes().to_vec())
             .map(|(key, _)| {
-                RoomId::parse(
+                RoomId::try_from(
                     utils::string_from_bytes(
                         key.rsplit(|&b| b == 0xff)
                             .next()
@@ -3260,14 +3255,14 @@ impl Rooms {
     pub fn rooms_invited<'a>(
         &'a self,
         user_id: &UserId,
-    ) -> impl Iterator<Item = Result<(Box<RoomId>, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a {
+    ) -> impl Iterator<Item = Result<(RoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
 
         self.userroomid_invitestate
             .scan_prefix(prefix)
             .map(|(key, state)| {
-                let room_id = RoomId::parse(
+                let room_id = RoomId::try_from(
                     utils::string_from_bytes(
                         key.rsplit(|&b| b == 0xff)
                             .next()
@@ -3333,14 +3328,14 @@ impl Rooms {
     pub fn rooms_left<'a>(
         &'a self,
         user_id: &UserId,
-    ) -> impl Iterator<Item = Result<(Box<RoomId>, Vec<Raw<AnySyncStateEvent>>)>> + 'a {
+    ) -> impl Iterator<Item = Result<(RoomId, Vec<Raw<AnySyncStateEvent>>)>> + 'a {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
 
         self.userroomid_leftstate
             .scan_prefix(prefix)
             .map(|(key, state)| {
-                let room_id = RoomId::parse(
+                let room_id = RoomId::try_from(
                     utils::string_from_bytes(
                         key.rsplit(|&b| b == 0xff)
                             .next()

src/database/rooms/edus.rs

@@ -11,7 +11,7 @@ use ruma::{
 };
 use std::{
     collections::{HashMap, HashSet},
-    convert::TryInto,
+    convert::{TryFrom, TryInto},
     mem,
     sync::Arc,
 };
@@ -76,13 +76,8 @@ impl RoomEdus {
         &'a self,
         room_id: &RoomId,
         since: u64,
-    ) -> impl Iterator<
+    ) -> impl Iterator<Item = Result<(UserId, u64, Raw<ruma::events::AnySyncEphemeralRoomEvent>)>> + 'a
-        Item = Result<(
+    {
-            Box<UserId>,
-            u64,
-            Raw<ruma::events::AnySyncEphemeralRoomEvent>,
-        )>,
-    > + 'a {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
         let prefix2 = prefix.clone();
@@ -97,7 +92,7 @@ impl RoomEdus {
                 let count =
                     utils::u64_from_bytes(&k[prefix.len()..prefix.len() + mem::size_of::<u64>()])
                         .map_err(|_| Error::bad_database("Invalid readreceiptid count in db."))?;
-                let user_id = UserId::parse(
+                let user_id = UserId::try_from(
                     utils::string_from_bytes(&k[prefix.len() + mem::size_of::<u64>() + 1..])
                         .map_err(|_| {
                             Error::bad_database("Invalid readreceiptid userid bytes in db.")
@@ -310,13 +305,17 @@ impl RoomEdus {
 
         let mut user_ids = HashSet::new();
 
-        for (_, user_id) in self.typingid_userid.scan_prefix(prefix) {
+        for user_id in self
-            let user_id = UserId::parse(utils::string_from_bytes(&user_id).map_err(|_| {
+            .typingid_userid
+            .scan_prefix(prefix)
+            .map(|(_, user_id)| {
+                UserId::try_from(utils::string_from_bytes(&user_id).map_err(|_| {
                     Error::bad_database("User ID in typingid_userid is invalid unicode.")
                 })?)
-            .map_err(|_| Error::bad_database("User ID in typingid_userid is invalid."))?;
+                .map_err(|_| Error::bad_database("User ID in typingid_userid is invalid."))
-
+            })
-            user_ids.insert(user_id);
+        {
+            user_ids.insert(user_id?);
         }
 
         Ok(SyncEphemeralRoomEvent {
@@ -450,7 +449,7 @@ impl RoomEdus {
         {
             // Send new presence events to set the user offline
             let count = globals.next_count()?.to_be_bytes();
-            let user_id: Box<_> = utils::string_from_bytes(&user_id_bytes)
+            let user_id = utils::string_from_bytes(&user_id_bytes)
                 .map_err(|_| {
                     Error::bad_database("Invalid UserId bytes in userid_lastpresenceupdate.")
                 })?
@@ -476,7 +475,7 @@ impl RoomEdus {
                             presence: PresenceState::Offline,
                             status_msg: None,
                         },
-                        sender: user_id.to_owned(),
+                        sender: user_id.clone(),
                     })
                     .expect("PresenceEvent can be serialized"),
                 )?;
@@ -499,7 +498,7 @@ impl RoomEdus {
         since: u64,
         _rooms: &super::Rooms,
         _globals: &super::super::globals::Globals,
-    ) -> Result<HashMap<Box<UserId>, PresenceEvent>> {
+    ) -> Result<HashMap<UserId, PresenceEvent>> {
         //self.presence_maintain(rooms, globals)?;
 
         let mut prefix = room_id.as_bytes().to_vec();
@@ -514,7 +513,7 @@ impl RoomEdus {
             .iter_from(&*first_possible_edu, false)
             .take_while(|(key, _)| key.starts_with(&prefix))
         {
-            let user_id = UserId::parse(
+            let user_id = UserId::try_from(
                 utils::string_from_bytes(
                     key.rsplit(|&b| b == 0xff)
                         .next()

src/database/sending.rs

@@ -1,6 +1,6 @@
 use std::{
     collections::{BTreeMap, HashMap, HashSet},
-    convert::TryInto,
+    convert::{TryFrom, TryInto},
     fmt::Debug,
     sync::Arc,
     time::{Duration, Instant},
@@ -397,7 +397,7 @@ impl Sending {
             // Because synapse resyncs, we can just insert dummy data
             let edu = Edu::DeviceListUpdate(DeviceListUpdateContent {
                 user_id,
-                device_id: device_id!("dummy").to_owned(),
+                device_id: device_id!("dummy"),
                 device_display_name: Some("Dummy".to_owned()),
                 stream_id: uint!(1),
                 prev_id: Vec::new(),
@@ -583,7 +583,8 @@ impl Sending {
                         }
                     }
 
-                    let userid = UserId::parse(utils::string_from_bytes(user).map_err(|_| {
+                    let userid =
+                        UserId::try_from(utils::string_from_bytes(user).map_err(|_| {
                             (
                                 kind.clone(),
                                 Error::bad_database("Invalid push user string in db."),
@@ -731,7 +732,7 @@ impl Sending {
             })?;
 
             (
-                OutgoingKind::Appservice(ServerName::parse(server).map_err(|_| {
+                OutgoingKind::Appservice(Box::<ServerName>::try_from(server).map_err(|_| {
                     Error::bad_database("Invalid server string in server_currenttransaction")
                 })?),
                 if value.is_empty() {
@@ -770,7 +771,7 @@ impl Sending {
             })?;
 
             (
-                OutgoingKind::Normal(ServerName::parse(server).map_err(|_| {
+                OutgoingKind::Normal(Box::<ServerName>::try_from(server).map_err(|_| {
                     Error::bad_database("Invalid server string in server_currenttransaction")
                 })?),
                 if value.is_empty() {

src/database/users.rs

@@ -8,7 +8,7 @@ use ruma::{
     DeviceId, DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, RoomAliasId, UInt,
     UserId,
 };
-use std::{collections::BTreeMap, convert::TryInto, mem, sync::Arc};
+use std::{collections::BTreeMap, convert::TryFrom, mem, sync::Arc};
 use tracing::warn;
 
 use super::abstraction::Tree;
@@ -62,11 +62,12 @@ impl Users {
         rooms: &super::rooms::Rooms,
         globals: &super::globals::Globals,
     ) -> Result<bool> {
-        let admin_room_alias_id = RoomAliasId::parse(format!("#admins:{}", globals.server_name()))
+        let admin_room_alias_id =
+            RoomAliasId::try_from(format!("#admins:{}", globals.server_name()))
                 .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;
         let admin_room_id = rooms.id_from_alias(&admin_room_alias_id)?.unwrap();
 
-        rooms.is_joined(user_id, &admin_room_id)
+        Ok(rooms.is_joined(user_id, &admin_room_id)?)
     }
 
     /// Create a new user account on this homeserver.
@@ -84,7 +85,7 @@ impl Users {
 
     /// Find out which user an access token belongs to.
     #[tracing::instrument(skip(self, token))]
-    pub fn find_from_token(&self, token: &str) -> Result<Option<(Box<UserId>, String)>> {
+    pub fn find_from_token(&self, token: &str) -> Result<Option<(UserId, String)>> {
         self.token_userdeviceid
             .get(token.as_bytes())?
             .map_or(Ok(None), |bytes| {
@@ -97,7 +98,7 @@ impl Users {
                 })?;
 
                 Ok(Some((
-                    UserId::parse(utils::string_from_bytes(user_bytes).map_err(|_| {
+                    UserId::try_from(utils::string_from_bytes(user_bytes).map_err(|_| {
                         Error::bad_database("User ID in token_userdeviceid is invalid unicode.")
                     })?)
                     .map_err(|_| {
@@ -112,9 +113,9 @@ impl Users {
 
     /// Returns an iterator over all users on this homeserver.
     #[tracing::instrument(skip(self))]
-    pub fn iter(&self) -> impl Iterator<Item = Result<Box<UserId>>> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item = Result<UserId>> + '_ {
         self.userid_password.iter().map(|(bytes, _)| {
-            UserId::parse(utils::string_from_bytes(&bytes).map_err(|_| {
+            UserId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
                 Error::bad_database("User ID in userid_password is invalid unicode.")
             })?)
             .map_err(|_| Error::bad_database("User ID in userid_password is invalid."))
@@ -180,21 +181,20 @@ impl Users {
 
     /// Get the avatar_url of a user.
     #[tracing::instrument(skip(self, user_id))]
-    pub fn avatar_url(&self, user_id: &UserId) -> Result<Option<Box<MxcUri>>> {
+    pub fn avatar_url(&self, user_id: &UserId) -> Result<Option<MxcUri>> {
         self.userid_avatarurl
             .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."))?;
-                s.try_into()
+                MxcUri::try_from(s).map_err(|_| Error::bad_database("Avatar URL in db is invalid."))
-                    .map_err(|_| Error::bad_database("Avatar URL in db is invalid."))
             })
             .transpose()
     }
 
     /// 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<Box<MxcUri>>) -> Result<()> {
+    pub fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<MxcUri>) -> Result<()> {
         if let Some(avatar_url) = avatar_url {
             self.userid_avatarurl
                 .insert(user_id.as_bytes(), avatar_url.to_string().as_bytes())?;
@@ -409,7 +409,7 @@ impl Users {
         device_id: &DeviceId,
         key_algorithm: &DeviceKeyAlgorithm,
         globals: &super::globals::Globals,
-    ) -> Result<Option<(Box<DeviceKeyId>, OneTimeKey)>> {
+    ) -> Result<Option<(DeviceKeyId, OneTimeKey)>> {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
         prefix.extend_from_slice(device_id.as_bytes());
@@ -459,7 +459,7 @@ impl Users {
                 .scan_prefix(userdeviceid)
                 .map(|(bytes, _)| {
                     Ok::<_, Error>(
-                        serde_json::from_slice::<Box<DeviceKeyId>>(
+                        serde_json::from_slice::<DeviceKeyId>(
                             &*bytes.rsplit(|&b| b == 0xff).next().ok_or_else(|| {
                                 Error::bad_database("OneTimeKey ID in db is invalid.")
                             })?,
@@ -632,7 +632,7 @@ impl Users {
             .ok_or_else(|| Error::bad_database("key in keyid_key has no signatures field."))?
             .as_object_mut()
             .ok_or_else(|| Error::bad_database("key in keyid_key has invalid signatures field."))?
-            .entry(sender_id.to_owned())
+            .entry(sender_id.clone())
             .or_insert_with(|| serde_json::Map::new().into());
 
         signatures
@@ -657,7 +657,7 @@ impl Users {
         user_or_room_id: &str,
         from: u64,
         to: Option<u64>,
-    ) -> impl Iterator<Item = Result<Box<UserId>>> + 'a {
+    ) -> impl Iterator<Item = Result<UserId>> + 'a {
         let mut prefix = user_or_room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -683,7 +683,7 @@ impl Users {
                     }
             })
             .map(|(_, bytes)| {
-                UserId::parse(utils::string_from_bytes(&bytes).map_err(|_| {
+                UserId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
                     Error::bad_database("User ID in devicekeychangeid_userid is invalid unicode.")
                 })?)
                 .map_err(|_| Error::bad_database("User ID in devicekeychangeid_userid is invalid."))

src/main.rs

@@ -101,7 +101,6 @@ fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<
                 client_server::create_typing_event_route,
                 client_server::create_room_route,
                 client_server::redact_event_route,
-                client_server::report_event_route,
                 client_server::create_alias_route,
                 client_server::delete_alias_route,
                 client_server::get_alias_route,

src/pdu.rs

@@ -13,7 +13,7 @@ use serde_json::{
     json,
     value::{to_raw_value, RawValue as RawJsonValue},
 };
-use std::{cmp::Ordering, collections::BTreeMap, convert::TryInto, sync::Arc};
+use std::{cmp::Ordering, collections::BTreeMap, convert::TryFrom};
 use tracing::warn;
 
 /// Content hashes of a PDU.
@@ -25,20 +25,20 @@ pub struct EventHash {
 
 #[derive(Clone, Deserialize, Serialize, Debug)]
 pub struct PduEvent {
-    pub event_id: Arc<EventId>,
+    pub event_id: EventId,
-    pub room_id: Box<RoomId>,
+    pub room_id: RoomId,
-    pub sender: Box<UserId>,
+    pub sender: UserId,
     pub origin_server_ts: UInt,
     #[serde(rename = "type")]
     pub kind: EventType,
     pub content: Box<RawJsonValue>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub state_key: Option<String>,
-    pub prev_events: Vec<Arc<EventId>>,
+    pub prev_events: Vec<EventId>,
     pub depth: UInt,
-    pub auth_events: Vec<Arc<EventId>>,
+    pub auth_events: Vec<EventId>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub redacts: Option<Arc<EventId>>,
+    pub redacts: Option<EventId>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub unsigned: Option<Box<RawJsonValue>>,
     pub hashes: EventHash,
@@ -266,9 +266,7 @@ impl PduEvent {
 }
 
 impl state_res::Event for PduEvent {
-    type Id = Arc<EventId>;
+    fn event_id(&self) -> &EventId {
-
-    fn event_id(&self) -> &Self::Id {
         &self.event_id
     }
 
@@ -296,15 +294,15 @@ impl state_res::Event for PduEvent {
         self.state_key.as_deref()
     }
 
-    fn prev_events(&self) -> Box<dyn DoubleEndedIterator<Item = &Self::Id> + '_> {
+    fn prev_events(&self) -> Box<dyn DoubleEndedIterator<Item = &EventId> + '_> {
         Box::new(self.prev_events.iter())
     }
 
-    fn auth_events(&self) -> Box<dyn DoubleEndedIterator<Item = &Self::Id> + '_> {
+    fn auth_events(&self) -> Box<dyn DoubleEndedIterator<Item = &EventId> + '_> {
         Box::new(self.auth_events.iter())
     }
 
-    fn redacts(&self) -> Option<&Self::Id> {
+    fn redacts(&self) -> Option<&EventId> {
         self.redacts.as_ref()
     }
 }
@@ -333,19 +331,18 @@ impl Ord for PduEvent {
 /// Returns a tuple of the new `EventId` and the PDU as a `BTreeMap<String, CanonicalJsonValue>`.
 pub(crate) fn gen_event_id_canonical_json(
     pdu: &RawJsonValue,
-) -> crate::Result<(Box<EventId>, CanonicalJsonObject)> {
+) -> crate::Result<(EventId, CanonicalJsonObject)> {
     let value = serde_json::from_str(pdu.get()).map_err(|e| {
         warn!("Error parsing incoming event {:?}: {:?}", pdu, e);
         Error::BadServerResponse("Invalid PDU in server response")
     })?;
 
-    let event_id = format!(
+    let event_id = EventId::try_from(&*format!(
         "${}",
         // Anything higher than version3 behaves the same
-        ruma::signatures::reference_hash(&value, &RoomVersionId::V6)
+        ruma::signatures::reference_hash(&value, &RoomVersionId::Version6)
             .expect("ruma can calculate reference hashes")
-    )
+    ))
-    .try_into()
     .expect("ruma's reference hashes are valid event ids");
 
     Ok((event_id, value))
@@ -359,7 +356,7 @@ pub struct PduBuilder {
     pub content: Box<RawJsonValue>,
     pub unsigned: Option<BTreeMap<String, serde_json::Value>>,
     pub state_key: Option<String>,
-    pub redacts: Option<Arc<EventId>>,
+    pub redacts: Option<EventId>,
 }
 
 /// Direct conversion prevents loss of the empty `state_key` that ruma requires.

src/ruma_wrapper.rs

@@ -20,6 +20,7 @@ use {
     },
     ruma::api::{AuthScheme, IncomingRequest},
     std::collections::BTreeMap,
+    std::convert::TryFrom,
     std::io::Cursor,
     tracing::{debug, warn},
 };
@@ -28,7 +29,7 @@ use {
 /// first.
 pub struct Ruma<T: Outgoing> {
     pub body: T::Incoming,
-    pub sender_user: Option<Box<UserId>>,
+    pub sender_user: Option<UserId>,
     pub sender_device: Option<Box<DeviceId>>,
     pub sender_servername: Option<Box<ServerName>>,
     // This is None when body is not a valid string
@@ -85,7 +86,7 @@ where
                 registration
                     .get("as_token")
                     .and_then(|as_token| as_token.as_str())
-                    .map_or(false, |as_token| token == Some(as_token))
+                    .map_or(false, |as_token| token.as_deref() == Some(as_token))
             }) {
             match metadata.authentication {
                 AuthScheme::AccessToken | AuthScheme::QueryOnlyAccessToken => {
@@ -102,7 +103,8 @@ where
                             .unwrap()
                         },
                         |string| {
-                            UserId::parse(string.expect("parsing to string always works")).unwrap()
+                            UserId::try_from(string.expect("parsing to string always works"))
+                                .unwrap()
                         },
                     );
 
@@ -169,7 +171,7 @@ where
                         }
                     };
 
-                    let origin = match ServerName::parse(origin_str) {
+                    let origin = match Box::<ServerName>::try_from(origin_str) {
                         Ok(s) => s,
                         _ => {
                             warn!(

src/server_server.rs

@@ -64,7 +64,6 @@ use std::{
     future::Future,
     mem,
     net::{IpAddr, SocketAddr},
-    ops::Deref,
     pin::Pin,
     sync::{Arc, RwLock, RwLockWriteGuard},
     time::{Duration, Instant, SystemTime},
@@ -397,7 +396,10 @@ async fn find_actual_destination(
                                         }
 
                                         if let Some(port) = force_port {
-                                            FedDest::Named(delegated_hostname, format!(":{}", port))
+                                            FedDest::Named(
+                                                delegated_hostname,
+                                                format!(":{}", port.to_string()),
+                                            )
                                         } else {
                                             add_port_to_hostname(&delegated_hostname)
                                         }
@@ -430,7 +432,10 @@ async fn find_actual_destination(
                                 }
 
                                 if let Some(port) = force_port {
-                                    FedDest::Named(hostname.clone(), format!(":{}", port))
+                                    FedDest::Named(
+                                        hostname.clone(),
+                                        format!(":{}", port.to_string()),
+                                    )
                                 } else {
                                     add_port_to_hostname(&hostname)
                                 }
@@ -545,10 +550,11 @@ pub fn get_server_keys_route(db: DatabaseGuard) -> Json<String> {
         return Json("Federation is disabled.".to_owned());
     }
 
-    let mut verify_keys: BTreeMap<Box<ServerSigningKeyId>, VerifyKey> = BTreeMap::new();
+    let mut verify_keys = BTreeMap::new();
     verify_keys.insert(
-        format!("ed25519:{}", db.globals.keypair().version())
+        ServerSigningKeyId::try_from(
-            .try_into()
+            format!("ed25519:{}", db.globals.keypair().version()).as_str(),
+        )
         .expect("found invalid server signing keys in DB"),
         VerifyKey {
             key: base64::encode_config(db.globals.keypair().public_key(), base64::STANDARD_NO_PAD),
@@ -730,7 +736,7 @@ pub async fn send_transaction_message_route(
         // 0. Check the server is in the room
         let room_id = match value
             .get("room_id")
-            .and_then(|id| RoomId::parse(id.as_str()?).ok())
+            .and_then(|id| RoomId::try_from(id.as_str()?).ok())
         {
             Some(id) => id,
             None => {
@@ -995,9 +1001,14 @@ pub(crate) async fn handle_incoming_pdu<'a>(
     }
 
     // 9. Fetch any missing prev events doing all checks listed here starting at 1. These are timeline events
-    let mut graph: HashMap<Arc<EventId>, _> = HashMap::new();
+    let mut graph = HashMap::new();
     let mut eventid_info = HashMap::new();
-    let mut todo_outlier_stack: Vec<Arc<EventId>> = incoming_pdu.prev_events.clone();
+    let mut todo_outlier_stack: Vec<_> = incoming_pdu
+        .prev_events
+        .iter()
+        .cloned()
+        .map(Arc::new)
+        .collect();
 
     let mut amount = 0;
 
@@ -1016,7 +1027,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
             if amount > 100 {
                 // Max limit reached
                 warn!("Max prev event limit reached!");
-                graph.insert(prev_event_id.clone(), HashSet::new());
+                graph.insert((*prev_event_id).clone(), HashSet::new());
                 continue;
             }
 
@@ -1027,27 +1038,27 @@ pub(crate) async fn handle_incoming_pdu<'a>(
                     amount += 1;
                     for prev_prev in &pdu.prev_events {
                         if !graph.contains_key(prev_prev) {
-                            todo_outlier_stack.push(dbg!(prev_prev.clone()));
+                            todo_outlier_stack.push(dbg!(Arc::new(prev_prev.clone())));
                         }
                     }
 
                     graph.insert(
-                        prev_event_id.clone(),
+                        (*prev_event_id).clone(),
                         pdu.prev_events.iter().cloned().collect(),
                     );
                 } else {
                     // Time based check failed
-                    graph.insert(prev_event_id.clone(), HashSet::new());
+                    graph.insert((*prev_event_id).clone(), HashSet::new());
                 }
 
                 eventid_info.insert(prev_event_id.clone(), (pdu, json));
             } else {
                 // Get json failed
-                graph.insert(prev_event_id.clone(), HashSet::new());
+                graph.insert((*prev_event_id).clone(), HashSet::new());
             }
         } else {
             // Fetch and handle failed
-            graph.insert(prev_event_id.clone(), HashSet::new());
+            graph.insert((*prev_event_id).clone(), HashSet::new());
         }
     }
 
@@ -1063,6 +1074,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
                     .get(event_id)
                     .map_or_else(|| uint!(0), |info| info.0.origin_server_ts),
             ),
+            ruma::event_id!("$notimportant"),
         ))
     })
     .map_err(|_| "Error sorting prev events".to_owned())?;
@@ -1072,7 +1084,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
         if errors >= 5 {
             break;
         }
-        if let Some((pdu, json)) = eventid_info.remove(&*prev_id) {
+        if let Some((pdu, json)) = eventid_info.remove(&prev_id) {
             if pdu.origin_server_ts < first_pdu_in_room.origin_server_ts {
                 continue;
             }
@@ -1188,7 +1200,8 @@ fn handle_outlier_pdu<'a>(
             &incoming_pdu
                 .auth_events
                 .iter()
-                .map(|x| Arc::from(&**x))
+                .cloned()
+                .map(Arc::new)
                 .collect::<Vec<_>>(),
             create_event,
             room_id,
@@ -1318,7 +1331,7 @@ async fn upgrade_outlier_to_timeline_pdu(
     let mut state_at_incoming_event = None;
 
     if incoming_pdu.prev_events.len() == 1 {
-        let prev_event = &*incoming_pdu.prev_events[0];
+        let prev_event = &incoming_pdu.prev_events[0];
         let prev_event_sstatehash = db
             .rooms
             .pdu_shortstatehash(prev_event)
@@ -1340,7 +1353,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                     .get_or_create_shortstatekey(&prev_pdu.kind, state_key, &db.globals)
                     .map_err(|_| "Failed to create shortstatekey.".to_owned())?;
 
-                state.insert(shortstatekey, Arc::from(prev_event));
+                state.insert(shortstatekey, Arc::new(prev_event.clone()));
                 // Now it's the state after the pdu
             }
 
@@ -1384,7 +1397,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                         .rooms
                         .get_or_create_shortstatekey(&prev_event.kind, state_key, &db.globals)
                         .map_err(|_| "Failed to create shortstatekey.".to_owned())?;
-                    leaf_state.insert(shortstatekey, Arc::from(&*prev_event.event_id));
+                    leaf_state.insert(shortstatekey, Arc::new(prev_event.event_id.clone()));
                     // Now it's the state after the pdu
                 }
 
@@ -1397,13 +1410,14 @@ async fn upgrade_outlier_to_timeline_pdu(
                         .get_statekey_from_short(k)
                         .map_err(|_| "Failed to get_statekey_from_short.".to_owned())?;
 
-                    state.insert(k, id.clone());
+                    state.insert(k, (*id).clone());
                     starting_events.push(id);
                 }
 
                 auth_chain_sets.push(
                     get_auth_chain(room_id, starting_events, db)
                         .map_err(|_| "Failed to load auth chain.".to_owned())?
+                        .map(|event_id| (*event_id).clone())
                         .collect(),
                 );
 
@@ -1430,7 +1444,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                                 .rooms
                                 .get_or_create_shortstatekey(&event_type, &state_key, &db.globals)
                                 .map_err(|_| "Failed to get_or_create_shortstatekey".to_owned())?;
-                            Ok((shortstatekey, event_id))
+                            Ok((shortstatekey, Arc::new(event_id)))
                         })
                         .collect::<Result<_, String>>()?,
                 ),
@@ -1465,7 +1479,8 @@ async fn upgrade_outlier_to_timeline_pdu(
                     origin,
                     &res.pdu_ids
                         .iter()
-                        .map(|x| Arc::from(&**x))
+                        .cloned()
+                        .map(Arc::new)
                         .collect::<Vec<_>>(),
                     create_event,
                     room_id,
@@ -1473,7 +1488,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                 )
                 .await;
 
-                let mut state: BTreeMap<_, Arc<EventId>> = BTreeMap::new();
+                let mut state = BTreeMap::new();
                 for (pdu, _) in state_vec {
                     let state_key = pdu
                         .state_key
@@ -1487,7 +1502,7 @@ async fn upgrade_outlier_to_timeline_pdu(
 
                     match state.entry(shortstatekey) {
                         btree_map::Entry::Vacant(v) => {
-                            v.insert(Arc::from(&*pdu.event_id));
+                            v.insert(Arc::new(pdu.event_id.clone()));
                         }
                         btree_map::Entry::Occupied(_) => return Err(
                             "State event's type and state_key combination exists multiple times."
@@ -1562,7 +1577,7 @@ async fn upgrade_outlier_to_timeline_pdu(
             .roomid_mutex_state
             .write()
             .unwrap()
-            .entry(room_id.to_owned())
+            .entry(room_id.clone())
             .or_default(),
     );
     let state_lock = mutex_state.lock().await;
@@ -1632,7 +1647,7 @@ async fn upgrade_outlier_to_timeline_pdu(
             db,
             &incoming_pdu,
             val,
-            extremities.iter().map(Deref::deref),
+            extremities,
             state_ids_compressed,
             soft_fail,
             &state_lock,
@@ -1700,7 +1715,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                     .rooms
                     .get_or_create_shortstatekey(&leaf_pdu.kind, state_key, &db.globals)
                     .map_err(|_| "Failed to create shortstatekey.".to_owned())?;
-                leaf_state.insert(shortstatekey, Arc::from(&*leaf_pdu.event_id));
+                leaf_state.insert(shortstatekey, Arc::new(leaf_pdu.event_id.clone()));
                 // Now it's the state after the pdu
             }
 
@@ -1715,7 +1730,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                 .get_or_create_shortstatekey(&incoming_pdu.kind, state_key, &db.globals)
                 .map_err(|_| "Failed to create shortstatekey.".to_owned())?;
 
-            state_after.insert(shortstatekey, Arc::from(&*incoming_pdu.event_id));
+            state_after.insert(shortstatekey, Arc::new(incoming_pdu.event_id.clone()));
         }
         fork_states.push(state_after);
 
@@ -1747,6 +1762,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                         db,
                     )
                     .map_err(|_| "Failed to load auth chain.".to_owned())?
+                    .map(|event_id| (*event_id).clone())
                     .collect(),
                 );
             }
@@ -1755,7 +1771,11 @@ async fn upgrade_outlier_to_timeline_pdu(
                 .into_iter()
                 .map(|map| {
                     map.into_iter()
-                        .map(|(k, id)| db.rooms.get_statekey_from_short(k).map(|k| (k, id)))
+                        .map(|(k, id)| {
+                            db.rooms
+                                .get_statekey_from_short(k)
+                                .map(|k| (k, (*id).clone()))
+                        })
                         .collect::<Result<StateMap<_>>>()
                 })
                 .collect::<Result<_>>()
@@ -1812,7 +1832,7 @@ async fn upgrade_outlier_to_timeline_pdu(
         db,
         &incoming_pdu,
         val,
-        extremities.iter().map(Deref::deref),
+        extremities,
         state_ids_compressed,
         soft_fail,
         &state_lock,
@@ -1854,8 +1874,7 @@ pub(crate) fn fetch_and_handle_outliers<'a>(
 
         let mut pdus = vec![];
         for id in events {
-            if let Some((time, tries)) = db.globals.bad_event_ratelimiter.read().unwrap().get(&**id)
+            if let Some((time, tries)) = db.globals.bad_event_ratelimiter.read().unwrap().get(id) {
-            {
                 // Exponential backoff
                 let mut min_elapsed_duration = Duration::from_secs(5 * 60) * (*tries) * (*tries);
                 if min_elapsed_duration > Duration::from_secs(60 * 60 * 24) {
@@ -1895,7 +1914,7 @@ pub(crate) fn fetch_and_handle_outliers<'a>(
                                 match crate::pdu::gen_event_id_canonical_json(&res.pdu) {
                                     Ok(t) => t,
                                     Err(_) => {
-                                        back_off((**id).to_owned());
+                                        back_off((**id).clone());
                                         continue;
                                     }
                                 };
@@ -1920,14 +1939,14 @@ pub(crate) fn fetch_and_handle_outliers<'a>(
                                 Ok((pdu, json)) => (pdu, Some(json)),
                                 Err(e) => {
                                     warn!("Authentication of event {} failed: {:?}", id, e);
-                                    back_off((**id).to_owned());
+                                    back_off((**id).clone());
                                     continue;
                                 }
                             }
                         }
                         Err(_) => {
                             warn!("Failed to fetch event: {}", id);
-                            back_off((**id).to_owned());
+                            back_off((**id).clone());
                             continue;
                         }
                     }
@@ -2105,11 +2124,11 @@ pub(crate) async fn fetch_signing_keys(
 /// Append the incoming event setting the state snapshot to the state from the
 /// server that sent the event.
 #[tracing::instrument(skip(db, pdu, pdu_json, new_room_leaves, state_ids_compressed, _mutex_lock))]
-fn append_incoming_pdu<'a>(
+fn append_incoming_pdu(
     db: &Database,
     pdu: &PduEvent,
     pdu_json: CanonicalJsonObject,
-    new_room_leaves: impl IntoIterator<Item = &'a EventId> + Clone + Debug,
+    new_room_leaves: HashSet<EventId>,
     state_ids_compressed: HashSet<CompressedStateEvent>,
     soft_fail: bool,
     _mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room mutex
@@ -2126,11 +2145,19 @@ fn append_incoming_pdu<'a>(
     if soft_fail {
         db.rooms
             .mark_as_referenced(&pdu.room_id, &pdu.prev_events)?;
-        db.rooms.replace_pdu_leaves(&pdu.room_id, new_room_leaves)?;
+        db.rooms.replace_pdu_leaves(
+            &pdu.room_id,
+            &new_room_leaves.into_iter().collect::<Vec<_>>(),
+        )?;
         return Ok(None);
     }
 
-    let pdu_id = db.rooms.append_pdu(pdu, pdu_json, new_room_leaves, db)?;
+    let pdu_id = db.rooms.append_pdu(
+        pdu,
+        pdu_json,
+        &new_room_leaves.into_iter().collect::<Vec<_>>(),
+        db,
+    )?;
 
     for appservice in db.appservice.all()? {
         if db.rooms.appservice_in_room(&pdu.room_id, &appservice, db)? {
@@ -2271,13 +2298,13 @@ fn get_auth_chain_inner(
     event_id: &EventId,
     db: &Database,
 ) -> Result<HashSet<u64>> {
-    let mut todo = vec![Arc::from(event_id)];
+    let mut todo = vec![event_id.clone()];
     let mut found = HashSet::new();
 
     while let Some(event_id) = todo.pop() {
         match db.rooms.get_pdu(&event_id) {
             Ok(Some(pdu)) => {
-                if pdu.room_id != room_id {
+                if &pdu.room_id != room_id {
                     return Err(Error::BadRequest(ErrorKind::Forbidden, "Evil event in db"));
                 }
                 for auth_event in &pdu.auth_events {
@@ -2336,10 +2363,10 @@ pub fn get_event_route(
         .and_then(|val| val.as_str())
         .ok_or_else(|| Error::bad_database("Invalid event in database"))?;
 
-    let room_id = <&RoomId>::try_from(room_id_str)
+    let room_id = RoomId::try_from(room_id_str)
         .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;
 
-    if !db.rooms.server_in_room(sender_servername, room_id)? {
+    if !db.rooms.server_in_room(sender_servername, &room_id)? {
         return Err(Error::BadRequest(ErrorKind::NotFound, "Event not found."));
     }
 
@@ -2390,7 +2417,7 @@ pub fn get_missing_events_route(
                 .and_then(|val| val.as_str())
                 .ok_or_else(|| Error::bad_database("Invalid event in database"))?;
 
-            let event_room_id = <&RoomId>::try_from(room_id_str)
+            let event_room_id = RoomId::try_from(room_id_str)
                 .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;
 
             if event_room_id != body.room_id {
@@ -2409,7 +2436,7 @@ pub fn get_missing_events_route(
                 continue;
             }
             queued_events.extend_from_slice(
-                &serde_json::from_value::<Vec<Box<EventId>>>(
+                &serde_json::from_value::<Vec<EventId>>(
                     serde_json::to_value(pdu.get("prev_events").cloned().ok_or_else(|| {
                         Error::bad_database("Event in db has no prev_events field.")
                     })?)
@@ -2458,14 +2485,14 @@ pub fn get_event_authorization_route(
         .and_then(|val| val.as_str())
         .ok_or_else(|| Error::bad_database("Invalid event in database"))?;
 
-    let room_id = <&RoomId>::try_from(room_id_str)
+    let room_id = RoomId::try_from(room_id_str)
         .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;
 
-    if !db.rooms.server_in_room(sender_servername, room_id)? {
+    if !db.rooms.server_in_room(sender_servername, &room_id)? {
         return Err(Error::BadRequest(ErrorKind::NotFound, "Event not found."));
     }
 
-    let auth_chain_ids = get_auth_chain(room_id, vec![Arc::from(&*body.event_id)], &db)?;
+    let auth_chain_ids = get_auth_chain(&room_id, vec![Arc::new(body.event_id.clone())], &db)?;
 
     Ok(get_event_authorization::v1::Response {
         auth_chain: auth_chain_ids
@@ -2523,7 +2550,7 @@ pub fn get_room_state_route(
         })
         .collect();
 
-    let auth_chain_ids = get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)], &db)?;
+    let auth_chain_ids = get_auth_chain(&body.room_id, vec![Arc::new(body.event_id.clone())], &db)?;
 
     Ok(get_room_state::v1::Response {
         auth_chain: auth_chain_ids
@@ -2579,13 +2606,13 @@ pub fn get_room_state_ids_route(
         .rooms
         .state_full_ids(shortstatehash)?
         .into_iter()
-        .map(|(_, id)| (*id).to_owned())
+        .map(|(_, id)| (*id).clone())
         .collect();
 
-    let auth_chain_ids = get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)], &db)?;
+    let auth_chain_ids = get_auth_chain(&body.room_id, vec![Arc::new(body.event_id.clone())], &db)?;
 
     Ok(get_room_state_ids::v1::Response {
-        auth_chain_ids: auth_chain_ids.map(|id| (*id).to_owned()).collect(),
+        auth_chain_ids: auth_chain_ids.map(|id| (*id).clone()).collect(),
         pdu_ids,
     }
     .into())
@@ -2644,8 +2671,9 @@ pub fn create_join_event_template_route(
     };
 
     // If there was no create event yet, assume we are creating a version 6 room right now
-    let room_version_id =
+    let room_version_id = create_event_content.map_or(RoomVersionId::Version6, |create_event| {
-        create_event_content.map_or(RoomVersionId::V6, |create_event| create_event.room_version);
+        create_event.room_version
+    });
     let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");
 
     if !body.ver.contains(&room_version_id) {
@@ -2665,7 +2693,6 @@ pub fn create_join_event_template_route(
         membership: MembershipState::Join,
         third_party_invite: None,
         reason: None,
-        join_authorized_via_users_server: None,
     })
     .expect("member event is valid value");
 
@@ -2694,12 +2721,12 @@ pub fn create_join_event_template_route(
         unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone());
         unsigned.insert(
             "prev_sender".to_owned(),
-            to_raw_value(&prev_pdu.sender).expect("UserId is valid"),
+            serde_json::from_str(prev_pdu.sender.as_str()).expect("UserId is valid string"),
         );
     }
 
     let pdu = PduEvent {
-        event_id: ruma::event_id!("$thiswillbefilledinlater").into(),
+        event_id: ruma::event_id!("$thiswillbefilledinlater"),
         room_id: body.room_id.clone(),
         sender: body.user_id.clone(),
         origin_server_ts: utils::millis_since_unix_epoch()
@@ -2811,7 +2838,7 @@ async fn create_join_event(
             .roomid_mutex_federation
             .write()
             .unwrap()
-            .entry(room_id.to_owned())
+            .entry(room_id.clone())
             .or_default(),
     );
     let mutex_lock = mutex.lock().await;
@@ -2910,7 +2937,8 @@ pub async fn create_invite_route(
         return Err(Error::bad_config("Federation is disabled."));
     }
 
-    if body.room_version != RoomVersionId::V5 && body.room_version != RoomVersionId::V6 {
+    if body.room_version != RoomVersionId::Version5 && body.room_version != RoomVersionId::Version6
+    {
         return Err(Error::BadRequest(
             ErrorKind::IncompatibleRoomVersion {
                 room_version: body.room_version.clone(),
@@ -2931,7 +2959,7 @@ pub async fn create_invite_route(
     .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Failed to sign event."))?;
 
     // Generate event id
-    let event_id = EventId::parse(format!(
+    let event_id = EventId::try_from(&*format!(
         "${}",
         ruma::signatures::reference_hash(&signed_event, &body.room_version)
             .expect("ruma can calculate reference hashes")
@@ -2944,7 +2972,7 @@ pub async fn create_invite_route(
         CanonicalJsonValue::String(event_id.into()),
     );
 
-    let sender: Box<_> = serde_json::from_value(
+    let sender = serde_json::from_value(
         signed_event
             .get("sender")
             .ok_or(Error::BadRequest(
@@ -2956,7 +2984,7 @@ pub async fn create_invite_route(
     )
     .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "sender is not a user id."))?;
 
-    let invited_user: Box<_> = serde_json::from_value(
+    let invited_user = serde_json::from_value(
         signed_event
             .get("state_key")
             .ok_or(Error::BadRequest(
@@ -3207,7 +3235,7 @@ pub(crate) async fn fetch_required_signing_keys(
 
         let fetch_res = fetch_signing_keys(
             db,
-            signature_server.as_str().try_into().map_err(|_| {
+            &Box::<ServerName>::try_from(&**signature_server).map_err(|_| {
                 Error::BadServerResponse("Invalid servername in signatures of server response pdu.")
             })?,
             signature_ids,
@@ -3235,7 +3263,7 @@ pub(crate) async fn fetch_required_signing_keys(
 // the PDUs and either cache the key or add it to the list that needs to be retrieved.
 fn get_server_keys_from_cache(
     pdu: &RawJsonValue,
-    servers: &mut BTreeMap<Box<ServerName>, BTreeMap<Box<ServerSigningKeyId>, QueryCriteria>>,
+    servers: &mut BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, QueryCriteria>>,
     room_version: &RoomVersionId,
     pub_key_map: &mut RwLockWriteGuard<'_, BTreeMap<String, BTreeMap<String, String>>>,
     db: &Database,
@@ -3245,12 +3273,11 @@ fn get_server_keys_from_cache(
         Error::BadServerResponse("Invalid PDU in server response")
     })?;
 
-    let event_id = format!(
+    let event_id = EventId::try_from(&*format!(
         "${}",
         ruma::signatures::reference_hash(&value, room_version)
             .expect("ruma can calculate reference hashes")
-    );
+    ))
-    let event_id = <&EventId>::try_from(event_id.as_str())
     .expect("ruma's reference hashes are valid event ids");
 
     if let Some((time, tries)) = db
@@ -3258,7 +3285,7 @@ fn get_server_keys_from_cache(
         .bad_event_ratelimiter
         .read()
         .unwrap()
-        .get(event_id)
+        .get(&event_id)
     {
         // Exponential backoff
         let mut min_elapsed_duration = Duration::from_secs(30) * (*tries) * (*tries);
@@ -3292,7 +3319,7 @@ fn get_server_keys_from_cache(
         let contains_all_ids =
             |keys: &BTreeMap<String, String>| signature_ids.iter().all(|id| keys.contains_key(id));
 
-        let origin = <&ServerName>::try_from(signature_server.as_str()).map_err(|_| {
+        let origin = &Box::<ServerName>::try_from(&**signature_server).map_err(|_| {
             Error::BadServerResponse("Invalid servername in signatures of server response pdu.")
         })?;
 
@@ -3311,7 +3338,7 @@ fn get_server_keys_from_cache(
 
         if !contains_all_ids(&result) {
             trace!("Signing key not loaded for {}", origin);
-            servers.insert(origin.to_owned(), BTreeMap::new());
+            servers.insert(origin.clone(), BTreeMap::new());
         }
 
         pub_key_map.insert(origin.to_string(), result);
@@ -3326,7 +3353,7 @@ pub(crate) async fn fetch_join_signing_keys(
     pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, String>>>,
     db: &Database,
 ) -> Result<()> {
-    let mut servers: BTreeMap<Box<ServerName>, BTreeMap<Box<ServerSigningKeyId>, QueryCriteria>> =
+    let mut servers: BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, QueryCriteria>> =
         BTreeMap::new();
 
     {
@@ -3360,6 +3387,10 @@ pub(crate) async fn fetch_join_signing_keys(
                 server,
                 get_remote_server_keys_batch::v2::Request {
                     server_keys: servers.clone(),
+                    minimum_valid_until_ts: MilliSecondsSinceUnixEpoch::from_system_time(
+                        SystemTime::now() + Duration::from_secs(60),
+                    )
+                    .expect("time is valid"),
                 },
             )
             .await