chore(deps): lock file maintenance

Signed-off-by: strawberry <strawberry@puppygock.gay>

.github/workflows/ci.yml

@@ -27,10 +27,10 @@ concurrency:
     cancel-in-progress: true
 
 env:
-    # sccache
-    SCCACHE_GHA_ENABLED: "true"
-    RUSTC_WRAPPER: "sccache"
-    SCCACHE_BUCKET: "sccache"
+    # sccache only on main repo
+    SCCACHE_GHA_ENABLED: "${{ (github.event.pull_request.draft != true) && (vars.DOCKER_USERNAME != '') && (vars.GITLAB_USERNAME != '') && (vars.SCCACHE_ENDPOINT != '') && (github.event.pull_request.user.login != 'renovate[bot]') && 'true' || 'false' }}"
+    RUSTC_WRAPPER: "${{ (github.event.pull_request.draft != true) && (vars.DOCKER_USERNAME != '') && (vars.GITLAB_USERNAME != '') && (vars.SCCACHE_ENDPOINT != '') && (github.event.pull_request.user.login != 'renovate[bot]') && 'sccache' }}"
+    SCCACHE_BUCKET: "${{ (github.event.pull_request.draft != true) && (vars.DOCKER_USERNAME != '') && (vars.GITLAB_USERNAME != '') && (vars.SCCACHE_ENDPOINT != '') && (github.event.pull_request.user.login != 'renovate[bot]') && 'sccache' }}"
     SCCACHE_S3_USE_SSL: ${{ vars.SCCACHE_S3_USE_SSL }}
     SCCACHE_REGION: ${{ vars.SCCACHE_REGION }}
     SCCACHE_ENDPOINT: ${{ vars.SCCACHE_ENDPOINT }}
@@ -156,6 +156,7 @@ jobs:
 
             # use sccache for Rust
             - name: Run sccache-cache
+              if: (github.event.pull_request.draft != true) && (vars.DOCKER_USERNAME != '') && (vars.GITLAB_USERNAME != '') && (vars.SCCACHE_ENDPOINT != '') && (github.event.pull_request.user.login != 'renovate[bot]')
               uses: mozilla-actions/sccache-action@main
 
             # use rust-cache
@@ -288,6 +289,7 @@ jobs:
 
             # use sccache for Rust
             - name: Run sccache-cache
+              if: (github.event.pull_request.draft != true) && (vars.DOCKER_USERNAME != '') && (vars.GITLAB_USERNAME != '') && (vars.SCCACHE_ENDPOINT != '') && (github.event.pull_request.user.login != 'renovate[bot]')
               uses: mozilla-actions/sccache-action@main
 
             # use rust-cache

Cargo.lock

@@ -43,9 +43,9 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"
+checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
 
 [[package]]
 name = "anyhow"
@@ -472,6 +472,16 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "cargo_toml"
+version = "0.20.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad639525b1c67b6a298f378417b060fbc04618bea559482a8484381cce27d965"
+dependencies = [
+ "serde",
+ "toml",
+]
+
 [[package]]
 name = "cc"
 version = "1.1.6"
@@ -534,9 +544,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.9"
+version = "4.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64acc1846d54c1fe936a78dc189c34e28d3f5afc348403f28ecf53660b9b8462"
+checksum = "35723e6a11662c2afb578bcf0b88bf6ea8e21282a953428f240574fcc3a2b5b3"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -544,9 +554,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.9"
+version = "4.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8393d67ba2e7bfaf28a23458e4e2b543cc73a99595511eb207fdb8aede942"
+checksum = "49eb96cbfa7cfa35017b7cd548c75b14c3118c98b423041d70562665e07fb0fa"
 dependencies = [
  "anstyle",
  "clap_lex",
@@ -554,9 +564,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.8"
+version = "4.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bac35c6dafb060fd4d275d9a4ffae97917c13a6327903a8be2153cd964f7085"
+checksum = "5d029b67f89d30bbb547c89fd5161293c0aec155fc691d7924b64550662db93e"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -566,9 +576,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b82cf0babdbd58558212896d1a4272303a57bdb245c2bf1147185fb45640e70"
+checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
 [[package]]
 name = "color_quant"
@@ -612,6 +622,7 @@ dependencies = [
  "clap",
  "conduit_api",
  "conduit_core",
+ "conduit_macros",
  "conduit_service",
  "const-str",
  "futures-util",
@@ -665,9 +676,12 @@ dependencies = [
  "argon2",
  "axum 0.7.5",
  "bytes",
+ "cargo_toml",
  "checked_ops",
  "chrono",
+ "conduit_macros",
  "const-str",
+ "ctor",
  "either",
  "figment",
  "hardened_malloc-rs",
@@ -694,6 +708,7 @@ dependencies = [
  "tikv-jemallocator",
  "tokio",
  "tokio-metrics",
+ "toml",
  "tracing",
  "tracing-core",
  "tracing-subscriber",
@@ -712,6 +727,16 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "conduit_macros"
+version = "0.4.6"
+dependencies = [
+ "itertools 0.13.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.72",
+]
+
 [[package]]
 name = "conduit_router"
 version = "0.4.6"
@@ -996,6 +1021,16 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "ctor"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edb49164822f3ee45b17acd4a208cfc1251410cf0cad9a833234c9890774dd9f"
+dependencies = [
+ "quote",
+ "syn 2.0.72",
+]
+
 [[package]]
 name = "curve25519-dalek"
 version = "4.1.3"
@@ -1682,7 +1717,7 @@ dependencies = [
  "http 1.1.0",
  "hyper 1.4.1",
  "hyper-util",
- "rustls 0.23.11",
+ "rustls 0.23.12",
  "rustls-native-certs",
  "rustls-pki-types",
  "tokio",
@@ -1861,9 +1896,9 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jobserver"
-version = "0.1.31"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
 dependencies = [
  "libc",
 ]
@@ -1932,9 +1967,9 @@ dependencies = [
 
 [[package]]
 name = "lazy-regex"
-version = "3.1.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d12be4595afdf58bd19e4a9f4e24187da2a66700786ff660a418e9059937a4c"
+checksum = "576c8060ecfdf2e56995cf3274b4f2d71fa5e4fa3607c1c0b63c10180ee58741"
 dependencies = [
  "lazy-regex-proc_macros",
  "once_cell",
@@ -1943,9 +1978,9 @@ dependencies = [
 
 [[package]]
 name = "lazy-regex-proc_macros"
-version = "3.1.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44bcd58e6c97a7fcbaffcdc95728b393b8d98933bfadad49ed4097845b57ef0b"
+checksum = "9efb9e65d4503df81c615dc33ff07042a9408ac7f26b45abee25566f7fbfd12c"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2294,9 +2329,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.36.1"
+version = "0.36.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "081b846d1d56ddfc18fdf1a922e4f6e07a11768ea1b92dec44e42b72712ccfce"
+checksum = "3f203fa8daa7bb185f760ae12bd8e097f63d17041dcdcaf675ac54cdf863170e"
 dependencies = [
  "memchr",
 ]
@@ -2730,7 +2765,7 @@ dependencies = [
  "quinn-proto",
  "quinn-udp",
  "rustc-hash",
- "rustls 0.23.11",
+ "rustls 0.23.12",
  "thiserror",
  "tokio",
  "tracing",
@@ -2746,7 +2781,7 @@ dependencies = [
  "rand",
  "ring",
  "rustc-hash",
- "rustls 0.23.11",
+ "rustls 0.23.12",
  "slab",
  "thiserror",
  "tinyvec",
@@ -2885,7 +2920,7 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls 0.23.11",
+ "rustls 0.23.12",
  "rustls-native-certs",
  "rustls-pemfile",
  "rustls-pki-types",
@@ -3226,9 +3261,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.11"
+version = "0.23.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4828ea528154ae444e5a642dbb7d5623354030dc9822b83fd9bb79683c7399d0"
+checksum = "c58f8c84392efc0a126acce10fa59ff7b3d2ac06ab451a33f2741989b806b044"
 dependencies = [
  "log",
  "once_cell",
@@ -3587,9 +3622,9 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.6"
+version = "0.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0"
+checksum = "eb5b1b31579f3811bf615c144393417496f152e12ac8b7663bf664f4a815306d"
 dependencies = [
  "serde",
 ]
@@ -4020,9 +4055,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.39.1"
+version = "1.39.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d040ac2b29ab03b09d4129c2f5bbd012a3ac2f79d38ff506a4bf8dd34b0eac8a"
+checksum = "daa4fb1bc778bd6f04cbfc4bb2d06a7396a8f299dc33ea1900cedaa316f467b1"
 dependencies = [
  "backtrace",
  "bytes",
@@ -4085,16 +4120,16 @@ version = "0.26.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4"
 dependencies = [
- "rustls 0.23.11",
+ "rustls 0.23.12",
  "rustls-pki-types",
  "tokio",
 ]
 
 [[package]]
 name = "tokio-socks"
-version = "0.5.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51165dfa029d2a65969413a6cc96f354b86b464498702f174a4efa13608fd8c0"
+checksum = "0d4770b8024672c1101b3f6733eab95b18007dbe0847a8afe341fcf79e06043f"
 dependencies = [
  "either",
  "futures-util",
@@ -4128,21 +4163,21 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.8.15"
+version = "0.8.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac2caab0bf757388c6c0ae23b3293fdb463fee59434529014f85e3263b995c28"
+checksum = "81967dd0dd2c1ab0bc3468bd7caecc32b8a4aa47d0c8c695d8c2b2108168d62c"
 dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
- "toml_edit 0.22.16",
+ "toml_edit 0.22.17",
 ]
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.6"
+version = "0.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
+checksum = "f8fb9f64314842840f1d940ac544da178732128f1c78c21772e876579e0da1db"
 dependencies = [
  "serde",
 ]
@@ -4160,15 +4195,15 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.22.16"
+version = "0.22.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "278f3d518e152219c994ce877758516bca5e118eaed6996192a774fb9fbf0788"
+checksum = "8d9f8729f5aea9562aac1cc0441f5d6de3cff1ee0c5d67293eeca5eb36ee7c16"
 dependencies = [
  "indexmap 2.2.6",
  "serde",
  "serde_spanned",
  "toml_datetime",
- "winnow 0.6.15",
+ "winnow 0.6.16",
 ]
 
 [[package]]
@@ -4447,7 +4482,7 @@ dependencies = [
  "base64 0.22.1",
  "log",
  "once_cell",
- "rustls 0.23.11",
+ "rustls 0.23.12",
  "rustls-pki-types",
  "url",
  "webpki-roots",
@@ -4501,9 +4536,9 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "want"
@@ -4846,9 +4881,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.6.15"
+version = "0.6.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "557404e450152cd6795bb558bca69e43c585055f4606e3bcae5894fc6dac9ba0"
+checksum = "b480ae9340fc261e6be3e95a1ba86d54ae3f9171132a73ce8d4bbaf68339507c"
 dependencies = [
  "memchr",
 ]

Cargo.toml

@@ -28,6 +28,18 @@ name = "conduit"
 [workspace.dependencies.const-str]
 version = "0.5.7"
 
+[workspace.dependencies.ctor]
+version = "0.2.8"
+
+[workspace.dependencies.cargo_toml]
+version = "0.20"
+features = ["features"]
+
+[workspace.dependencies.toml]
+version = "0.8.14"
+default-features = false
+features = ["parse"]
+
 [workspace.dependencies.sanitize-filename]
 version = "0.5.0"
 
@@ -371,7 +383,7 @@ version = "0.34.0"
 # jemalloc usage
 # locked to 0.5.4 due to static binary linking breakage
 [workspace.dependencies.tikv-jemalloc-sys]
-version = "=0.6.0"
+version = "=0.5.4"
 default-features = false
 features = ["stats", "unprefixed_malloc_on_supported_platforms"]
 [workspace.dependencies.tikv-jemallocator]
@@ -413,6 +425,16 @@ default-features = false
 [workspace.dependencies.checked_ops]
 version = "0.1"
 
+[workspace.dependencies.syn]
+version = "2.0.72"
+features = ["full", "extra-traits"]
+
+[workspace.dependencies.quote]
+version = "1.0.36"
+
+[workspace.dependencies.proc-macro2]
+version = "1.0.86"
+
 
 #
 # Patches
@@ -480,6 +502,11 @@ package = "conduit_core"
 path = "src/core"
 default-features = false
 
+[workspace.dependencies.conduit-macros]
+package = "conduit_macros"
+path = "src/macros"
+default-features = false
+
 ###############################################################################
 #
 # Release profiles

src/admin/Cargo.toml

@@ -29,6 +29,7 @@ release_max_log_level = [
 clap.workspace = true
 conduit-api.workspace = true
 conduit-core.workspace = true
+conduit-macros.workspace = true
 conduit-service.workspace = true
 const-str.workspace = true
 futures-util.workspace = true

src/admin/admin.rs

@@ -0,0 +1,66 @@
+use clap::Parser;
+use conduit::Result;
+use ruma::events::room::message::RoomMessageEventContent;
+
+use crate::{
+	appservice, appservice::AppserviceCommand, check, check::CheckCommand, command::Command, debug,
+	debug::DebugCommand, federation, federation::FederationCommand, media, media::MediaCommand, query,
+	query::QueryCommand, room, room::RoomCommand, server, server::ServerCommand, user, user::UserCommand,
+};
+
+#[derive(Debug, Parser)]
+#[command(name = "admin", version = env!("CARGO_PKG_VERSION"))]
+pub(super) enum AdminCommand {
+	#[command(subcommand)]
+	/// - Commands for managing appservices
+	Appservices(AppserviceCommand),
+
+	#[command(subcommand)]
+	/// - Commands for managing local users
+	Users(UserCommand),
+
+	#[command(subcommand)]
+	/// - Commands for managing rooms
+	Rooms(RoomCommand),
+
+	#[command(subcommand)]
+	/// - Commands for managing federation
+	Federation(FederationCommand),
+
+	#[command(subcommand)]
+	/// - Commands for managing the server
+	Server(ServerCommand),
+
+	#[command(subcommand)]
+	/// - Commands for managing media
+	Media(MediaCommand),
+
+	#[command(subcommand)]
+	/// - Commands for checking integrity
+	Check(CheckCommand),
+
+	#[command(subcommand)]
+	/// - Commands for debugging things
+	Debug(DebugCommand),
+
+	#[command(subcommand)]
+	/// - Low-level queries for database getters and iterators
+	Query(QueryCommand),
+}
+
+#[tracing::instrument(skip_all, name = "command")]
+pub(super) async fn process(command: AdminCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	use AdminCommand::*;
+
+	Ok(match command {
+		Appservices(command) => appservice::process(command, context).await?,
+		Media(command) => media::process(command, context).await?,
+		Users(command) => user::process(command, context).await?,
+		Rooms(command) => room::process(command, context).await?,
+		Federation(command) => federation::process(command, context).await?,
+		Server(command) => server::process(command, context).await?,
+		Debug(command) => debug::process(command, context).await?,
+		Query(command) => query::process(command, context).await?,
+		Check(command) => check::process(command, context).await?,
+	})
+}

src/admin/appservice/commands.rs

@@ -1,18 +1,20 @@
 use ruma::{api::appservice::Registration, events::room::message::RoomMessageEventContent};
 
-use crate::{services, Result};
+use crate::{admin_command, Result};
 
-pub(super) async fn register(body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
+#[admin_command]
+pub(super) async fn register(&self) -> Result<RoomMessageEventContent> {
+	if self.body.len() < 2 || !self.body[0].trim().starts_with("```") || self.body.last().unwrap_or(&"").trim() != "```"
+	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"Expected code block in command body. Add --help for details.",
 		));
 	}
 
-	let appservice_config = body[1..body.len().checked_sub(1).unwrap()].join("\n");
+	let appservice_config = self.body[1..self.body.len().checked_sub(1).unwrap()].join("\n");
 	let parsed_config = serde_yaml::from_str::<Registration>(&appservice_config);
 	match parsed_config {
-		Ok(yaml) => match services().appservice.register_appservice(yaml).await {
+		Ok(yaml) => match self.services.appservice.register_appservice(yaml).await {
 			Ok(id) => Ok(RoomMessageEventContent::text_plain(format!(
 				"Appservice registered with ID: {id}."
 			))),
@@ -26,8 +28,10 @@ pub(super) async fn register(body: Vec<&str>) -> Result<RoomMessageEventContent>
 	}
 }
 
-pub(super) async fn unregister(_body: Vec<&str>, appservice_identifier: String) -> Result<RoomMessageEventContent> {
-	match services()
+#[admin_command]
+pub(super) async fn unregister(&self, appservice_identifier: String) -> Result<RoomMessageEventContent> {
+	match self
+		.services
 		.appservice
 		.unregister_appservice(&appservice_identifier)
 		.await
@@ -39,8 +43,10 @@ pub(super) async fn unregister(_body: Vec<&str>, appservice_identifier: String)
 	}
 }
 
-pub(super) async fn show(_body: Vec<&str>, appservice_identifier: String) -> Result<RoomMessageEventContent> {
-	match services()
+#[admin_command]
+pub(super) async fn show_appservice_config(&self, appservice_identifier: String) -> Result<RoomMessageEventContent> {
+	match self
+		.services
 		.appservice
 		.get_registration(&appservice_identifier)
 		.await
@@ -54,8 +60,9 @@ pub(super) async fn show(_body: Vec<&str>, appservice_identifier: String) -> Res
 	}
 }
 
-pub(super) async fn list(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let appservices = services().appservice.iter_ids().await;
+#[admin_command]
+pub(super) async fn list_registered(&self) -> Result<RoomMessageEventContent> {
+	let appservices = self.services.appservice.iter_ids().await;
 	let output = format!("Appservices ({}): {}", appservices.len(), appservices.join(", "));
 	Ok(RoomMessageEventContent::text_plain(output))
 }

src/admin/appservice/mod.rs

@@ -2,12 +2,11 @@ mod commands;
 
 use clap::Subcommand;
 use conduit::Result;
-use ruma::events::room::message::RoomMessageEventContent;
 
-use self::commands::*;
+use crate::admin_command_dispatch;
 
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
+#[derive(Debug, Subcommand)]
+#[admin_command_dispatch]
 pub(super) enum AppserviceCommand {
 	/// - Register an appservice using its registration YAML
 	///
@@ -29,24 +28,13 @@ pub(super) enum AppserviceCommand {
 	/// - Show an appservice's config using its ID
 	///
 	/// You can find the ID using the `list-appservices` command.
-	Show {
+	#[clap(alias("show"))]
+	ShowAppserviceConfig {
 		/// The appservice to show
 		appservice_identifier: String,
 	},
 
 	/// - List all the currently registered appservices
-	List,
-}
-
-pub(super) async fn process(command: AppserviceCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	Ok(match command {
-		AppserviceCommand::Register => register(body).await?,
-		AppserviceCommand::Unregister {
-			appservice_identifier,
-		} => unregister(body, appservice_identifier).await?,
-		AppserviceCommand::Show {
-			appservice_identifier,
-		} => show(body, appservice_identifier).await?,
-		AppserviceCommand::List => list(body).await?,
-	})
+	#[clap(alias("list"))]
+	ListRegistered,
 }

src/admin/check/commands.rs

@@ -1,14 +1,16 @@
 use conduit::Result;
+use conduit_macros::implement;
 use ruma::events::room::message::RoomMessageEventContent;
 
-use crate::services;
+use crate::Command;
 
 /// Uses the iterator in `src/database/key_value/users.rs` to iterator over
 /// every user in our database (remote and local). Reports total count, any
 /// errors if there were any, etc
-pub(super) async fn check_all_users(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+#[implement(Command, params = "<'_>")]
+pub(super) async fn check_all_users(&self) -> Result<RoomMessageEventContent> {
 	let timer = tokio::time::Instant::now();
-	let results = services().users.db.iter();
+	let results = self.services.users.db.iter();
 	let query_time = timer.elapsed();
 
 	let users = results.collect::<Vec<_>>();

src/admin/check/mod.rs

@@ -4,16 +4,15 @@ use clap::Subcommand;
 use conduit::Result;
 use ruma::events::room::message::RoomMessageEventContent;
 
-use self::commands::*;
+use crate::Command;
 
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
+#[derive(Debug, Subcommand)]
 pub(super) enum CheckCommand {
 	AllUsers,
 }
 
-pub(super) async fn process(command: CheckCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
+pub(super) async fn process(command: CheckCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
 	Ok(match command {
-		CheckCommand::AllUsers => check_all_users(body).await?,
+		CheckCommand::AllUsers => context.check_all_users().await?,
 	})
 }

src/admin/command.rs

@@ -0,0 +1,6 @@
+use service::Services;
+
+pub(crate) struct Command<'a> {
+	pub(crate) services: &'a Services,
+	pub(crate) body: &'a [&'a str],
+}

src/admin/debug/commands.rs

@@ -1,33 +1,37 @@
 use std::{
 	collections::{BTreeMap, HashMap},
+	fmt::Write,
 	sync::{Arc, Mutex},
-	time::Instant,
+	time::{Instant, SystemTime},
 };
 
 use api::client::validate_and_add_event_id;
 use conduit::{
 	debug, info, log,
 	log::{capture, Capture},
-	warn, Error, Result,
+	utils, warn, Error, PduEvent, Result,
 };
 use ruma::{
 	api::{client::error::ErrorKind, federation::event::get_room_state},
 	events::room::message::RoomMessageEventContent,
 	CanonicalJsonObject, EventId, OwnedRoomOrAliasId, RoomId, RoomVersionId, ServerName,
 };
-use service::{rooms::event_handler::parse_incoming_pdu, sending::resolve_actual_dest, services, PduEvent};
 use tokio::sync::RwLock;
 use tracing_subscriber::EnvFilter;
 
-pub(super) async fn echo(_body: Vec<&str>, message: Vec<String>) -> Result<RoomMessageEventContent> {
+use crate::admin_command;
+
+#[admin_command]
+pub(super) async fn echo(&self, message: Vec<String>) -> Result<RoomMessageEventContent> {
 	let message = message.join(" ");
 
 	Ok(RoomMessageEventContent::notice_plain(message))
 }
 
-pub(super) async fn get_auth_chain(_body: Vec<&str>, event_id: Box<EventId>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn get_auth_chain(&self, event_id: Box<EventId>) -> Result<RoomMessageEventContent> {
 	let event_id = Arc::<EventId>::from(event_id);
-	if let Some(event) = services().rooms.timeline.get_pdu_json(&event_id)? {
+	if let Some(event) = self.services.rooms.timeline.get_pdu_json(&event_id)? {
 		let room_id_str = event
 			.get("room_id")
 			.and_then(|val| val.as_str())
@@ -35,13 +39,16 @@ pub(super) async fn get_auth_chain(_body: Vec<&str>, event_id: Box<EventId>) ->
 
 		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 = services()
+		let count = self
+			.services
 			.rooms
 			.auth_chain
 			.event_ids_iter(room_id, vec![event_id])
 			.await?
 			.count();
+
 		let elapsed = start.elapsed();
 		Ok(RoomMessageEventContent::text_plain(format!(
 			"Loaded auth chain with length {count} in {elapsed:?}"
@@ -51,14 +58,16 @@ pub(super) async fn get_auth_chain(_body: Vec<&str>, event_id: Box<EventId>) ->
 	}
 }
 
-pub(super) async fn parse_pdu(body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
+#[admin_command]
+pub(super) async fn parse_pdu(&self) -> Result<RoomMessageEventContent> {
+	if self.body.len() < 2 || !self.body[0].trim().starts_with("```") || self.body.last().unwrap_or(&"").trim() != "```"
+	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"Expected code block in command body. Add --help for details.",
 		));
 	}
 
-	let string = body[1..body.len().saturating_sub(1)].join("\n");
+	let string = self.body[1..self.body.len().saturating_sub(1)].join("\n");
 	match serde_json::from_str(&string) {
 		Ok(value) => match ruma::signatures::reference_hash(&value, &RoomVersionId::V6) {
 			Ok(hash) => {
@@ -79,15 +88,17 @@ pub(super) async fn parse_pdu(body: Vec<&str>) -> Result<RoomMessageEventContent
 	}
 }
 
-pub(super) async fn get_pdu(_body: Vec<&str>, event_id: Box<EventId>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn get_pdu(&self, event_id: Box<EventId>) -> Result<RoomMessageEventContent> {
 	let mut outlier = false;
-	let mut pdu_json = services()
+	let mut pdu_json = self
+		.services
 		.rooms
 		.timeline
 		.get_non_outlier_pdu_json(&event_id)?;
 	if pdu_json.is_none() {
 		outlier = true;
-		pdu_json = services().rooms.timeline.get_pdu_json(&event_id)?;
+		pdu_json = self.services.rooms.timeline.get_pdu_json(&event_id)?;
 	}
 	match pdu_json {
 		Some(json) => {
@@ -106,38 +117,42 @@ pub(super) async fn get_pdu(_body: Vec<&str>, event_id: Box<EventId>) -> Result<
 	}
 }
 
+#[admin_command]
 pub(super) async fn get_remote_pdu_list(
-	body: Vec<&str>, server: Box<ServerName>, force: bool,
+	&self, server: Box<ServerName>, force: bool,
 ) -> Result<RoomMessageEventContent> {
-	if !services().globals.config.allow_federation {
+	if !self.services.globals.config.allow_federation {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Federation is disabled on this homeserver.",
 		));
 	}
 
-	if server == services().globals.server_name() {
+	if server == self.services.globals.server_name() {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Not allowed to send federation requests to ourselves. Please use `get-pdu` for fetching local PDUs from \
 			 the database.",
 		));
 	}
 
-	if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
+	if self.body.len() < 2 || !self.body[0].trim().starts_with("```") || self.body.last().unwrap_or(&"").trim() != "```"
+	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"Expected code block in command body. Add --help for details.",
 		));
 	}
 
-	let list = body
-		.clone()
-		.drain(1..body.len().checked_sub(1).unwrap())
+	let list = self
+		.body
+		.iter()
+		.collect::<Vec<_>>()
+		.drain(1..self.body.len().saturating_sub(1))
 		.filter_map(|pdu| EventId::parse(pdu).ok())
 		.collect::<Vec<_>>();
 
 	for pdu in list {
 		if force {
-			if let Err(e) = get_remote_pdu(Vec::new(), Box::from(pdu), server.clone()).await {
-				services()
+			if let Err(e) = self.get_remote_pdu(Box::from(pdu), server.clone()).await {
+				self.services
 					.admin
 					.send_message(RoomMessageEventContent::text_plain(format!(
 						"Failed to get remote PDU, ignoring error: {e}"
@@ -146,29 +161,31 @@ pub(super) async fn get_remote_pdu_list(
 				warn!(%e, "Failed to get remote PDU, ignoring error");
 			}
 		} else {
-			get_remote_pdu(Vec::new(), Box::from(pdu), server.clone()).await?;
+			self.get_remote_pdu(Box::from(pdu), server.clone()).await?;
 		}
 	}
 
 	Ok(RoomMessageEventContent::text_plain("Fetched list of remote PDUs."))
 }
 
+#[admin_command]
 pub(super) async fn get_remote_pdu(
-	_body: Vec<&str>, event_id: Box<EventId>, server: Box<ServerName>,
+	&self, event_id: Box<EventId>, server: Box<ServerName>,
 ) -> Result<RoomMessageEventContent> {
-	if !services().globals.config.allow_federation {
+	if !self.services.globals.config.allow_federation {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Federation is disabled on this homeserver.",
 		));
 	}
 
-	if server == services().globals.server_name() {
+	if server == self.services.globals.server_name() {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Not allowed to send federation requests to ourselves. Please use `get-pdu` for fetching local PDUs.",
 		));
 	}
 
-	match services()
+	match self
+		.services
 		.sending
 		.send_federation_request(
 			&server,
@@ -189,7 +206,11 @@ pub(super) async fn get_remote_pdu(
 
 			debug!("Attempting to parse PDU: {:?}", &response.pdu);
 			let parsed_pdu = {
-				let parsed_result = parse_incoming_pdu(&response.pdu);
+				let parsed_result = self
+					.services
+					.rooms
+					.event_handler
+					.parse_incoming_pdu(&response.pdu);
 				let (event_id, value, room_id) = match parsed_result {
 					Ok(t) => t,
 					Err(e) => {
@@ -207,7 +228,7 @@ pub(super) async fn get_remote_pdu(
 			let pub_key_map = RwLock::new(BTreeMap::new());
 
 			debug!("Attempting to fetch homeserver signing keys for {server}");
-			services()
+			self.services
 				.rooms
 				.event_handler
 				.fetch_required_signing_keys(parsed_pdu.iter().map(|(_event_id, event, _room_id)| event), &pub_key_map)
@@ -217,7 +238,7 @@ pub(super) async fn get_remote_pdu(
 				});
 
 			info!("Attempting to handle event ID {event_id} as backfilled PDU");
-			services()
+			self.services
 				.rooms
 				.timeline
 				.backfill_pdu(&server, response.pdu, &pub_key_map)
@@ -236,9 +257,11 @@ pub(super) async fn get_remote_pdu(
 	}
 }
 
-pub(super) async fn get_room_state(_body: Vec<&str>, room: OwnedRoomOrAliasId) -> Result<RoomMessageEventContent> {
-	let room_id = services().rooms.alias.resolve(&room).await?;
-	let room_state = services()
+#[admin_command]
+pub(super) async fn get_room_state(&self, room: OwnedRoomOrAliasId) -> Result<RoomMessageEventContent> {
+	let room_id = self.services.rooms.alias.resolve(&room).await?;
+	let room_state = self
+		.services
 		.rooms
 		.state_accessor
 		.room_state_full(&room_id)
@@ -263,8 +286,9 @@ pub(super) async fn get_room_state(_body: Vec<&str>, room: OwnedRoomOrAliasId) -
 	Ok(RoomMessageEventContent::notice_markdown(format!("```json\n{json}\n```")))
 }
 
-pub(super) async fn ping(_body: Vec<&str>, server: Box<ServerName>) -> Result<RoomMessageEventContent> {
-	if server == services().globals.server_name() {
+#[admin_command]
+pub(super) async fn ping(&self, server: Box<ServerName>) -> Result<RoomMessageEventContent> {
+	if server == self.services.globals.server_name() {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Not allowed to send federation requests to ourselves.",
 		));
@@ -272,7 +296,8 @@ pub(super) async fn ping(_body: Vec<&str>, server: Box<ServerName>) -> Result<Ro
 
 	let timer = tokio::time::Instant::now();
 
-	match services()
+	match self
+		.services
 		.sending
 		.send_federation_request(&server, ruma::api::federation::discovery::get_server_version::v1::Request {})
 		.await
@@ -301,23 +326,23 @@ pub(super) async fn ping(_body: Vec<&str>, server: Box<ServerName>) -> Result<Ro
 	}
 }
 
-pub(super) async fn force_device_list_updates(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn force_device_list_updates(&self) -> Result<RoomMessageEventContent> {
 	// Force E2EE device list updates for all users
-	for user_id in services().users.iter().filter_map(Result::ok) {
-		services().users.mark_device_key_update(&user_id)?;
+	for user_id in self.services.users.iter().filter_map(Result::ok) {
+		self.services.users.mark_device_key_update(&user_id)?;
 	}
 	Ok(RoomMessageEventContent::text_plain(
 		"Marked all devices for all users as having new keys to update",
 	))
 }
 
-pub(super) async fn change_log_level(
-	_body: Vec<&str>, filter: Option<String>, reset: bool,
-) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn change_log_level(&self, filter: Option<String>, reset: bool) -> Result<RoomMessageEventContent> {
 	let handles = &["console"];
 
 	if reset {
-		let old_filter_layer = match EnvFilter::try_new(&services().globals.config.log) {
+		let old_filter_layer = match EnvFilter::try_new(&self.services.globals.config.log) {
 			Ok(s) => s,
 			Err(e) => {
 				return Ok(RoomMessageEventContent::text_plain(format!(
@@ -326,7 +351,8 @@ pub(super) async fn change_log_level(
 			},
 		};
 
-		match services()
+		match self
+			.services
 			.server
 			.log
 			.reload
@@ -335,7 +361,7 @@ pub(super) async fn change_log_level(
 			Ok(()) => {
 				return Ok(RoomMessageEventContent::text_plain(format!(
 					"Successfully changed log level back to config value {}",
-					services().globals.config.log
+					self.services.globals.config.log
 				)));
 			},
 			Err(e) => {
@@ -356,7 +382,8 @@ pub(super) async fn change_log_level(
 			},
 		};
 
-		match services()
+		match self
+			.services
 			.server
 			.log
 			.reload
@@ -376,19 +403,21 @@ pub(super) async fn change_log_level(
 	Ok(RoomMessageEventContent::text_plain("No log level was specified."))
 }
 
-pub(super) async fn sign_json(body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
+#[admin_command]
+pub(super) async fn sign_json(&self) -> Result<RoomMessageEventContent> {
+	if self.body.len() < 2 || !self.body[0].trim().starts_with("```") || self.body.last().unwrap_or(&"").trim() != "```"
+	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"Expected code block in command body. Add --help for details.",
 		));
 	}
 
-	let string = body[1..body.len().checked_sub(1).unwrap()].join("\n");
+	let string = self.body[1..self.body.len().checked_sub(1).unwrap()].join("\n");
 	match serde_json::from_str(&string) {
 		Ok(mut value) => {
 			ruma::signatures::sign_json(
-				services().globals.server_name().as_str(),
-				services().globals.keypair(),
+				self.services.globals.server_name().as_str(),
+				self.services.globals.keypair(),
 				&mut value,
 			)
 			.expect("our request json is what ruma expects");
@@ -399,19 +428,21 @@ pub(super) async fn sign_json(body: Vec<&str>) -> Result<RoomMessageEventContent
 	}
 }
 
-pub(super) async fn verify_json(body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
+#[admin_command]
+pub(super) async fn verify_json(&self) -> Result<RoomMessageEventContent> {
+	if self.body.len() < 2 || !self.body[0].trim().starts_with("```") || self.body.last().unwrap_or(&"").trim() != "```"
+	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"Expected code block in command body. Add --help for details.",
 		));
 	}
 
-	let string = body[1..body.len().checked_sub(1).unwrap()].join("\n");
+	let string = self.body[1..self.body.len().checked_sub(1).unwrap()].join("\n");
 	match serde_json::from_str(&string) {
 		Ok(value) => {
 			let pub_key_map = RwLock::new(BTreeMap::new());
 
-			services()
+			self.services
 				.rooms
 				.event_handler
 				.fetch_required_signing_keys([&value], &pub_key_map)
@@ -429,19 +460,22 @@ pub(super) async fn verify_json(body: Vec<&str>) -> Result<RoomMessageEventConte
 	}
 }
 
-#[tracing::instrument(skip(_body))]
-pub(super) async fn first_pdu_in_room(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
-	if !services()
+#[admin_command]
+#[tracing::instrument(skip(self))]
+pub(super) async fn first_pdu_in_room(&self, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+	if !self
+		.services
 		.rooms
 		.state_cache
-		.server_in_room(&services().globals.config.server_name, &room_id)?
+		.server_in_room(&self.services.globals.config.server_name, &room_id)?
 	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"We are not participating in the room / we don't know about the room ID.",
 		));
 	}
 
-	let first_pdu = services()
+	let first_pdu = self
+		.services
 		.rooms
 		.timeline
 		.first_pdu_in_room(&room_id)?
@@ -450,19 +484,22 @@ pub(super) async fn first_pdu_in_room(_body: Vec<&str>, room_id: Box<RoomId>) ->
 	Ok(RoomMessageEventContent::text_plain(format!("{first_pdu:?}")))
 }
 
-#[tracing::instrument(skip(_body))]
-pub(super) async fn latest_pdu_in_room(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
-	if !services()
+#[admin_command]
+#[tracing::instrument(skip(self))]
+pub(super) async fn latest_pdu_in_room(&self, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+	if !self
+		.services
 		.rooms
 		.state_cache
-		.server_in_room(&services().globals.config.server_name, &room_id)?
+		.server_in_room(&self.services.globals.config.server_name, &room_id)?
 	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"We are not participating in the room / we don't know about the room ID.",
 		));
 	}
 
-	let latest_pdu = services()
+	let latest_pdu = self
+		.services
 		.rooms
 		.timeline
 		.latest_pdu_in_room(&room_id)?
@@ -471,32 +508,36 @@ pub(super) async fn latest_pdu_in_room(_body: Vec<&str>, room_id: Box<RoomId>) -
 	Ok(RoomMessageEventContent::text_plain(format!("{latest_pdu:?}")))
 }
 
-#[tracing::instrument(skip(_body))]
+#[admin_command]
+#[tracing::instrument(skip(self))]
 pub(super) async fn force_set_room_state_from_server(
-	_body: Vec<&str>, server_name: Box<ServerName>, room_id: Box<RoomId>,
+	&self, room_id: Box<RoomId>, server_name: Box<ServerName>,
 ) -> Result<RoomMessageEventContent> {
-	if !services()
+	if !self
+		.services
 		.rooms
 		.state_cache
-		.server_in_room(&services().globals.config.server_name, &room_id)?
+		.server_in_room(&self.services.globals.config.server_name, &room_id)?
 	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"We are not participating in the room / we don't know about the room ID.",
 		));
 	}
 
-	let first_pdu = services()
+	let first_pdu = self
+		.services
 		.rooms
 		.timeline
 		.latest_pdu_in_room(&room_id)?
 		.ok_or_else(|| Error::bad_database("Failed to find the latest PDU in database"))?;
 
-	let room_version = services().rooms.state.get_room_version(&room_id)?;
+	let room_version = self.services.rooms.state.get_room_version(&room_id)?;
 
 	let mut state: HashMap<u64, Arc<EventId>> = HashMap::new();
 	let pub_key_map = RwLock::new(BTreeMap::new());
 
-	let remote_state_response = services()
+	let remote_state_response = self
+		.services
 		.sending
 		.send_federation_request(
 			&server_name,
@@ -510,7 +551,7 @@ pub(super) async fn force_set_room_state_from_server(
 	let mut events = Vec::with_capacity(remote_state_response.pdus.len());
 
 	for pdu in remote_state_response.pdus.clone() {
-		events.push(match parse_incoming_pdu(&pdu) {
+		events.push(match self.services.rooms.event_handler.parse_incoming_pdu(&pdu) {
 			Ok(t) => t,
 			Err(e) => {
 				warn!("Could not parse PDU, ignoring: {e}");
@@ -520,7 +561,7 @@ pub(super) async fn force_set_room_state_from_server(
 	}
 
 	info!("Fetching required signing keys for all the state events we got");
-	services()
+	self.services
 		.rooms
 		.event_handler
 		.fetch_required_signing_keys(events.iter().map(|(_event_id, event, _room_id)| event), &pub_key_map)
@@ -530,7 +571,7 @@ pub(super) async fn force_set_room_state_from_server(
 	for result in remote_state_response
 		.pdus
 		.iter()
-		.map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map))
+		.map(|pdu| validate_and_add_event_id(self.services, pdu, &room_version, &pub_key_map))
 	{
 		let Ok((event_id, value)) = result.await else {
 			continue;
@@ -541,12 +582,13 @@ pub(super) async fn force_set_room_state_from_server(
 			Error::BadServerResponse("Invalid PDU in send_join response.")
 		})?;
 
-		services()
+		self.services
 			.rooms
 			.outlier
 			.add_pdu_outlier(&event_id, &value)?;
 		if let Some(state_key) = &pdu.state_key {
-			let shortstatekey = services()
+			let shortstatekey = self
+				.services
 				.rooms
 				.short
 				.get_or_create_shortstatekey(&pdu.kind.to_string().into(), state_key)?;
@@ -558,32 +600,34 @@ pub(super) async fn force_set_room_state_from_server(
 	for result in remote_state_response
 		.auth_chain
 		.iter()
-		.map(|pdu| validate_and_add_event_id(pdu, &room_version, &pub_key_map))
+		.map(|pdu| validate_and_add_event_id(self.services, pdu, &room_version, &pub_key_map))
 	{
 		let Ok((event_id, value)) = result.await else {
 			continue;
 		};
 
-		services()
+		self.services
 			.rooms
 			.outlier
 			.add_pdu_outlier(&event_id, &value)?;
 	}
 
-	let new_room_state = services()
+	let new_room_state = self
+		.services
 		.rooms
 		.event_handler
 		.resolve_state(room_id.clone().as_ref(), &room_version, state)
 		.await?;
 
 	info!("Forcing new room state");
-	let (short_state_hash, new, removed) = services()
+	let (short_state_hash, new, removed) = self
+		.services
 		.rooms
 		.state_compressor
 		.save_state(room_id.clone().as_ref(), new_room_state)?;
 
-	let state_lock = services().rooms.state.mutex.lock(&room_id).await;
-	services()
+	let state_lock = self.services.rooms.state.mutex.lock(&room_id).await;
+	self.services
 		.rooms
 		.state
 		.force_state(room_id.clone().as_ref(), short_state_hash, new, removed, &state_lock)
@@ -593,7 +637,10 @@ pub(super) async fn force_set_room_state_from_server(
 		"Updating joined counts for room just in case (e.g. we may have found a difference in the room's \
 		 m.room.member state"
 	);
-	services().rooms.state_cache.update_joined_count(&room_id)?;
+	self.services
+		.rooms
+		.state_cache
+		.update_joined_count(&room_id)?;
 
 	drop(state_lock);
 
@@ -602,16 +649,64 @@ pub(super) async fn force_set_room_state_from_server(
 	))
 }
 
-pub(super) async fn resolve_true_destination(
-	_body: Vec<&str>, server_name: Box<ServerName>, no_cache: bool,
+#[admin_command]
+pub(super) async fn get_signing_keys(
+	&self, server_name: Option<Box<ServerName>>, _cached: bool,
 ) -> Result<RoomMessageEventContent> {
-	if !services().globals.config.allow_federation {
+	let server_name = server_name.unwrap_or_else(|| self.services.server.config.server_name.clone().into());
+	let signing_keys = self.services.globals.signing_keys_for(&server_name)?;
+
+	Ok(RoomMessageEventContent::notice_markdown(format!(
+		"```rs\n{signing_keys:#?}\n```"
+	)))
+}
+
+#[admin_command]
+#[allow(dead_code)]
+pub(super) async fn get_verify_keys(
+	&self, server_name: Option<Box<ServerName>>, cached: bool,
+) -> Result<RoomMessageEventContent> {
+	let server_name = server_name.unwrap_or_else(|| self.services.server.config.server_name.clone().into());
+	let mut out = String::new();
+
+	if cached {
+		writeln!(out, "| Key ID | VerifyKey |")?;
+		writeln!(out, "| --- | --- |")?;
+		for (key_id, verify_key) in self.services.globals.verify_keys_for(&server_name)? {
+			writeln!(out, "| {key_id} | {verify_key:?} |")?;
+		}
+
+		return Ok(RoomMessageEventContent::notice_markdown(out));
+	}
+
+	let signature_ids: Vec<String> = Vec::new();
+	let keys = self
+		.services
+		.rooms
+		.event_handler
+		.fetch_signing_keys_for_server(&server_name, signature_ids)
+		.await?;
+
+	writeln!(out, "| Key ID | Public Key |")?;
+	writeln!(out, "| --- | --- |")?;
+	for (key_id, key) in keys {
+		writeln!(out, "| {key_id} | {key} |")?;
+	}
+
+	Ok(RoomMessageEventContent::notice_markdown(out))
+}
+
+#[admin_command]
+pub(super) async fn resolve_true_destination(
+	&self, server_name: Box<ServerName>, no_cache: bool,
+) -> Result<RoomMessageEventContent> {
+	if !self.services.globals.config.allow_federation {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Federation is disabled on this homeserver.",
 		));
 	}
 
-	if server_name == services().globals.config.server_name {
+	if server_name == self.services.globals.config.server_name {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Not allowed to send federation requests to ourselves. Please use `get-pdu` for fetching local PDUs.",
 		));
@@ -623,12 +718,16 @@ pub(super) async fn resolve_true_destination(
 			&& matches!(data.span_name(), "actual" | "well-known" | "srv")
 	};
 
-	let state = &services().server.log.capture;
+	let state = &self.services.server.log.capture;
 	let logs = Arc::new(Mutex::new(String::new()));
 	let capture = Capture::new(state, Some(filter), capture::fmt_markdown(logs.clone()));
 
 	let capture_scope = capture.start();
-	let actual = resolve_actual_dest(&server_name, !no_cache).await?;
+	let actual = self
+		.services
+		.resolver
+		.resolve_actual_dest(&server_name, !no_cache)
+		.await?;
 	drop(capture_scope);
 
 	let msg = format!(
@@ -640,23 +739,26 @@ pub(super) async fn resolve_true_destination(
 	Ok(RoomMessageEventContent::text_markdown(msg))
 }
 
-#[must_use]
-pub(super) fn memory_stats() -> RoomMessageEventContent {
+#[admin_command]
+pub(super) async fn memory_stats(&self) -> Result<RoomMessageEventContent> {
 	let html_body = conduit::alloc::memory_stats();
 
 	if html_body.is_none() {
-		return RoomMessageEventContent::text_plain("malloc stats are not supported on your compiled malloc.");
+		return Ok(RoomMessageEventContent::text_plain(
+			"malloc stats are not supported on your compiled malloc.",
+		));
 	}
 
-	RoomMessageEventContent::text_html(
+	Ok(RoomMessageEventContent::text_html(
 		"This command's output can only be viewed by clients that render HTML.".to_owned(),
 		html_body.expect("string result"),
-	)
+	))
 }
 
 #[cfg(tokio_unstable)]
-pub(super) async fn runtime_metrics(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let out = services().server.metrics.runtime_metrics().map_or_else(
+#[admin_command]
+pub(super) async fn runtime_metrics(&self) -> Result<RoomMessageEventContent> {
+	let out = self.services.server.metrics.runtime_metrics().map_or_else(
 		|| "Runtime metrics are not available.".to_owned(),
 		|metrics| format!("```rs\n{metrics:#?}\n```"),
 	);
@@ -665,15 +767,17 @@ pub(super) async fn runtime_metrics(_body: Vec<&str>) -> Result<RoomMessageEvent
 }
 
 #[cfg(not(tokio_unstable))]
-pub(super) async fn runtime_metrics(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn runtime_metrics(&self) -> Result<RoomMessageEventContent> {
 	Ok(RoomMessageEventContent::text_markdown(
 		"Runtime metrics require building with `tokio_unstable`.",
 	))
 }
 
 #[cfg(tokio_unstable)]
-pub(super) async fn runtime_interval(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let out = services().server.metrics.runtime_interval().map_or_else(
+#[admin_command]
+pub(super) async fn runtime_interval(&self) -> Result<RoomMessageEventContent> {
+	let out = self.services.server.metrics.runtime_interval().map_or_else(
 		|| "Runtime metrics are not available.".to_owned(),
 		|metrics| format!("```rs\n{metrics:#?}\n```"),
 	);
@@ -682,8 +786,40 @@ pub(super) async fn runtime_interval(_body: Vec<&str>) -> Result<RoomMessageEven
 }
 
 #[cfg(not(tokio_unstable))]
-pub(super) async fn runtime_interval(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn runtime_interval(&self) -> Result<RoomMessageEventContent> {
 	Ok(RoomMessageEventContent::text_markdown(
 		"Runtime metrics require building with `tokio_unstable`.",
 	))
 }
+
+#[admin_command]
+pub(super) async fn time(&self) -> Result<RoomMessageEventContent> {
+	let now = SystemTime::now();
+	Ok(RoomMessageEventContent::text_markdown(utils::time::format(now, "%+")))
+}
+
+#[admin_command]
+pub(super) async fn list_dependencies(&self, names: bool) -> Result<RoomMessageEventContent> {
+	if names {
+		let out = info::cargo::dependencies_names().join(" ");
+		return Ok(RoomMessageEventContent::notice_markdown(out));
+	}
+
+	let deps = info::cargo::dependencies();
+	let mut out = String::new();
+	writeln!(out, "| name | version | features |")?;
+	writeln!(out, "| ---- | ------- | -------- |")?;
+	for (name, dep) in deps {
+		let version = dep.try_req().unwrap_or("*");
+		let feats = dep.req_features();
+		let feats = if !feats.is_empty() {
+			feats.join(" ")
+		} else {
+			String::new()
+		};
+		writeln!(out, "{name} | {version} | {feats}")?;
+	}
+
+	Ok(RoomMessageEventContent::notice_markdown(out))
+}

src/admin/debug/mod.rs

@@ -3,13 +3,13 @@ pub(crate) mod tester;
 
 use clap::Subcommand;
 use conduit::Result;
-use ruma::{events::room::message::RoomMessageEventContent, EventId, OwnedRoomOrAliasId, RoomId, ServerName};
-use tester::TesterCommand;
+use ruma::{EventId, OwnedRoomOrAliasId, RoomId, ServerName};
 
-use self::commands::*;
+use self::tester::TesterCommand;
+use crate::admin_command_dispatch;
 
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
 pub(super) enum DebugCommand {
 	/// - Echo input of admin command
 	Echo {
@@ -76,6 +76,14 @@ pub(super) enum DebugCommand {
 		room_id: OwnedRoomOrAliasId,
 	},
 
+	/// - Get and display signing keys from local cache or remote server.
+	GetSigningKeys {
+		server_name: Option<Box<ServerName>>,
+
+		#[arg(short, long)]
+		cached: bool,
+	},
+
 	/// - Sends a federation request to the remote server's
 	///   `/_matrix/federation/v1/version` endpoint and measures the latency it
 	///   took for the server to respond
@@ -167,61 +175,17 @@ pub(super) enum DebugCommand {
 	///   invocation.
 	RuntimeInterval,
 
+	/// - Print the current time
+	Time,
+
+	/// - List dependencies
+	ListDependencies {
+		#[arg(short, long)]
+		names: bool,
+	},
+
 	/// - Developer test stubs
 	#[command(subcommand)]
+	#[allow(non_snake_case)]
 	Tester(TesterCommand),
 }
-
-pub(super) async fn process(command: DebugCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	Ok(match command {
-		DebugCommand::Echo {
-			message,
-		} => echo(body, message).await?,
-		DebugCommand::GetAuthChain {
-			event_id,
-		} => get_auth_chain(body, event_id).await?,
-		DebugCommand::ParsePdu => parse_pdu(body).await?,
-		DebugCommand::GetPdu {
-			event_id,
-		} => get_pdu(body, event_id).await?,
-		DebugCommand::GetRemotePdu {
-			event_id,
-			server,
-		} => get_remote_pdu(body, event_id, server).await?,
-		DebugCommand::GetRoomState {
-			room_id,
-		} => get_room_state(body, room_id).await?,
-		DebugCommand::Ping {
-			server,
-		} => ping(body, server).await?,
-		DebugCommand::ForceDeviceListUpdates => force_device_list_updates(body).await?,
-		DebugCommand::ChangeLogLevel {
-			filter,
-			reset,
-		} => change_log_level(body, filter, reset).await?,
-		DebugCommand::SignJson => sign_json(body).await?,
-		DebugCommand::VerifyJson => verify_json(body).await?,
-		DebugCommand::FirstPduInRoom {
-			room_id,
-		} => first_pdu_in_room(body, room_id).await?,
-		DebugCommand::LatestPduInRoom {
-			room_id,
-		} => latest_pdu_in_room(body, room_id).await?,
-		DebugCommand::GetRemotePduList {
-			server,
-			force,
-		} => get_remote_pdu_list(body, server, force).await?,
-		DebugCommand::ForceSetRoomStateFromServer {
-			room_id,
-			server_name,
-		} => force_set_room_state_from_server(body, server_name, room_id).await?,
-		DebugCommand::ResolveTrueDestination {
-			server_name,
-			no_cache,
-		} => resolve_true_destination(body, server_name, no_cache).await?,
-		DebugCommand::MemoryStats => memory_stats(),
-		DebugCommand::RuntimeMetrics => runtime_metrics(body).await?,
-		DebugCommand::RuntimeInterval => runtime_interval(body).await?,
-		DebugCommand::Tester(command) => tester::process(command, body).await?,
-	})
-}

src/admin/debug/tester.rs

@@ -1,34 +1,29 @@
 use ruma::events::room::message::RoomMessageEventContent;
 
-use crate::Result;
+use crate::{admin_command, admin_command_dispatch, Result};
 
-#[derive(clap::Subcommand)]
-#[cfg_attr(test, derive(Debug))]
+#[admin_command_dispatch]
+#[derive(Debug, clap::Subcommand)]
 pub(crate) enum TesterCommand {
 	Tester,
 	Timer,
 }
 
-pub(super) async fn process(command: TesterCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	match command {
-		TesterCommand::Tester => tester(body).await,
-		TesterCommand::Timer => timer(body).await,
-	}
-}
-
 #[inline(never)]
 #[rustfmt::skip]
 #[allow(unused_variables)]
-async fn tester(body: Vec<&str>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+async fn tester(&self) -> Result<RoomMessageEventContent> {
 
 	Ok(RoomMessageEventContent::notice_plain("completed"))
 }
 
 #[inline(never)]
 #[rustfmt::skip]
-async fn timer(body: Vec<&str>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+async fn timer(&self) -> Result<RoomMessageEventContent> {
 	let started = std::time::Instant::now();
-	timed(&body);
+	timed(self.body);
 
 	let elapsed = started.elapsed();
 	Ok(RoomMessageEventContent::notice_plain(format!("completed in {elapsed:#?}")))

src/admin/federation/commands.rs

@@ -1,21 +1,26 @@
 use std::fmt::Write;
 
+use conduit::Result;
 use ruma::{events::room::message::RoomMessageEventContent, OwnedRoomId, RoomId, ServerName, UserId};
 
-use crate::{escape_html, get_room_info, services, Result};
+use crate::{admin_command, escape_html, get_room_info};
 
-pub(super) async fn disable_room(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
-	services().rooms.metadata.disable_room(&room_id, true)?;
+#[admin_command]
+pub(super) async fn disable_room(&self, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+	self.services.rooms.metadata.disable_room(&room_id, true)?;
 	Ok(RoomMessageEventContent::text_plain("Room disabled."))
 }
 
-pub(super) async fn enable_room(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
-	services().rooms.metadata.disable_room(&room_id, false)?;
+#[admin_command]
+pub(super) async fn enable_room(&self, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+	self.services.rooms.metadata.disable_room(&room_id, false)?;
 	Ok(RoomMessageEventContent::text_plain("Room enabled."))
 }
 
-pub(super) async fn incoming_federation(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let map = services()
+#[admin_command]
+pub(super) async fn incoming_federation(&self) -> Result<RoomMessageEventContent> {
+	let map = self
+		.services
 		.rooms
 		.event_handler
 		.federation_handletime
@@ -31,11 +36,10 @@ pub(super) async fn incoming_federation(_body: Vec<&str>) -> Result<RoomMessageE
 	Ok(RoomMessageEventContent::text_plain(&msg))
 }
 
-pub(super) async fn fetch_support_well_known(
-	_body: Vec<&str>, server_name: Box<ServerName>,
-) -> Result<RoomMessageEventContent> {
-	let response = services()
-		.globals
+#[admin_command]
+pub(super) async fn fetch_support_well_known(&self, server_name: Box<ServerName>) -> Result<RoomMessageEventContent> {
+	let response = self
+		.services
 		.client
 		.default
 		.get(format!("https://{server_name}/.well-known/matrix/support"))
@@ -73,25 +77,27 @@ pub(super) async fn fetch_support_well_known(
 	)))
 }
 
-pub(super) async fn remote_user_in_rooms(_body: Vec<&str>, user_id: Box<UserId>) -> Result<RoomMessageEventContent> {
-	if user_id.server_name() == services().globals.config.server_name {
+#[admin_command]
+pub(super) async fn remote_user_in_rooms(&self, user_id: Box<UserId>) -> Result<RoomMessageEventContent> {
+	if user_id.server_name() == self.services.globals.config.server_name {
 		return Ok(RoomMessageEventContent::text_plain(
 			"User belongs to our server, please use `list-joined-rooms` user admin command instead.",
 		));
 	}
 
-	if !services().users.exists(&user_id)? {
+	if !self.services.users.exists(&user_id)? {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Remote user does not exist in our database.",
 		));
 	}
 
-	let mut rooms: Vec<(OwnedRoomId, u64, String)> = services()
+	let mut rooms: Vec<(OwnedRoomId, u64, String)> = self
+		.services
 		.rooms
 		.state_cache
 		.rooms_joined(&user_id)
 		.filter_map(Result::ok)
-		.map(|room_id| get_room_info(&room_id))
+		.map(|room_id| get_room_info(self.services, &room_id))
 		.collect();
 
 	if rooms.is_empty() {

src/admin/federation/mod.rs

@@ -2,12 +2,12 @@ mod commands;
 
 use clap::Subcommand;
 use conduit::Result;
-use ruma::{events::room::message::RoomMessageEventContent, RoomId, ServerName, UserId};
+use ruma::{RoomId, ServerName, UserId};
 
-use self::commands::*;
+use crate::admin_command_dispatch;
 
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
 pub(super) enum FederationCommand {
 	/// - List all rooms we are currently handling an incoming pdu from
 	IncomingFederation,
@@ -40,21 +40,3 @@ pub(super) enum FederationCommand {
 		user_id: Box<UserId>,
 	},
 }
-
-pub(super) async fn process(command: FederationCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	Ok(match command {
-		FederationCommand::DisableRoom {
-			room_id,
-		} => disable_room(body, room_id).await?,
-		FederationCommand::EnableRoom {
-			room_id,
-		} => enable_room(body, room_id).await?,
-		FederationCommand::IncomingFederation => incoming_federation(body).await?,
-		FederationCommand::FetchSupportWellKnown {
-			server_name,
-		} => fetch_support_well_known(body, server_name).await?,
-		FederationCommand::RemoteUserInRooms {
-			user_id,
-		} => remote_user_in_rooms(body, user_id).await?,
-	})
-}

src/admin/handler.rs

@@ -1,7 +1,7 @@
-use std::{panic::AssertUnwindSafe, time::Instant};
+use std::{panic::AssertUnwindSafe, sync::Arc, time::Instant};
 
 use clap::{CommandFactory, Parser};
-use conduit::{error, trace, Error};
+use conduit::{error, trace, utils::string::common_prefix, Error, Result};
 use futures_util::future::FutureExt;
 use ruma::{
 	events::{
@@ -10,82 +10,37 @@ use ruma::{
 	},
 	OwnedEventId,
 };
-
-extern crate conduit_service as service;
-
-use conduit::{utils::string::common_prefix, Result};
-pub(crate) use service::admin::{Command, Service};
-use service::admin::{CommandOutput, CommandResult, HandlerResult};
-
-use crate::{
-	appservice, appservice::AppserviceCommand, check, check::CheckCommand, debug, debug::DebugCommand, federation,
-	federation::FederationCommand, media, media::MediaCommand, query, query::QueryCommand, room, room::RoomCommand,
-	server, server::ServerCommand, services, user, user::UserCommand,
+use service::{
+	admin::{CommandInput, CommandOutput, CommandResult, HandlerResult},
+	Services,
 };
-pub(crate) const PAGE_SIZE: usize = 100;
 
-#[derive(Parser)]
-#[command(name = "admin", version = env!("CARGO_PKG_VERSION"))]
-pub(crate) enum AdminCommand {
-	#[command(subcommand)]
-	/// - Commands for managing appservices
-	Appservices(AppserviceCommand),
+use crate::{admin, admin::AdminCommand, Command};
 
-	#[command(subcommand)]
-	/// - Commands for managing local users
-	Users(UserCommand),
+#[must_use]
+pub(super) fn complete(line: &str) -> String { complete_command(AdminCommand::command(), line) }
 
-	#[command(subcommand)]
-	/// - Commands for managing rooms
-	Rooms(RoomCommand),
-
-	#[command(subcommand)]
-	/// - Commands for managing federation
-	Federation(FederationCommand),
-
-	#[command(subcommand)]
-	/// - Commands for managing the server
-	Server(ServerCommand),
-
-	#[command(subcommand)]
-	/// - Commands for managing media
-	Media(MediaCommand),
-
-	#[command(subcommand)]
-	/// - Commands for checking integrity
-	Check(CheckCommand),
-
-	#[command(subcommand)]
-	/// - Commands for debugging things
-	Debug(DebugCommand),
-
-	#[command(subcommand)]
-	/// - Low-level queries for database getters and iterators
-	Query(QueryCommand),
+#[must_use]
+pub(super) fn handle(services: Arc<Services>, command: CommandInput) -> HandlerResult {
+	Box::pin(handle_command(services, command))
 }
 
-#[must_use]
-pub(crate) fn handle(command: Command) -> HandlerResult { Box::pin(handle_command(command)) }
-
-#[must_use]
-pub(crate) fn complete(line: &str) -> String { complete_admin_command(AdminCommand::command(), line) }
-
 #[tracing::instrument(skip_all, name = "admin")]
-async fn handle_command(command: Command) -> CommandResult {
-	AssertUnwindSafe(process_command(&command))
+async fn handle_command(services: Arc<Services>, command: CommandInput) -> CommandResult {
+	AssertUnwindSafe(Box::pin(process_command(services, &command)))
 		.catch_unwind()
 		.await
 		.map_err(Error::from_panic)
 		.or_else(|error| handle_panic(&error, command))
 }
 
-async fn process_command(command: &Command) -> CommandOutput {
-	process_admin_message(&command.command)
+async fn process_command(services: Arc<Services>, command: &CommandInput) -> CommandOutput {
+	process(services, &command.command)
 		.await
 		.and_then(|content| reply(content, command.reply_id.clone()))
 }
 
-fn handle_panic(error: &Error, command: Command) -> CommandResult {
+fn handle_panic(error: &Error, command: CommandInput) -> CommandResult {
 	let link = "Please submit a [bug report](https://github.com/girlbossceo/conduwuit/issues/new). 🥺";
 	let msg = format!("Panic occurred while processing command:\n```\n{error:#?}\n```\n{link}");
 	let content = RoomMessageEventContent::notice_markdown(msg);
@@ -104,21 +59,25 @@ fn reply(mut content: RoomMessageEventContent, reply_id: Option<OwnedEventId>) -
 }
 
 // Parse and process a message from the admin room
-async fn process_admin_message(msg: &str) -> CommandOutput {
+async fn process(services: Arc<Services>, msg: &str) -> CommandOutput {
 	let mut lines = msg.lines().filter(|l| !l.trim().is_empty());
 	let command = lines.next().expect("each string has at least one line");
-	let body = lines.collect::<Vec<_>>();
-	let parsed = match parse_admin_command(command) {
+	let (parsed, body) = match parse_command(command) {
 		Ok(parsed) => parsed,
 		Err(error) => {
-			let server_name = services().globals.server_name();
+			let server_name = services.globals.server_name();
 			let message = error.replace("server.name", server_name.as_str());
 			return Some(RoomMessageEventContent::notice_markdown(message));
 		},
 	};
 
 	let timer = Instant::now();
-	let result = process_admin_command(parsed, body).await;
+	let body: Vec<&str> = body.iter().map(String::as_str).collect();
+	let context = Command {
+		services: &services,
+		body: &body,
+	};
+	let result = Box::pin(admin::process(parsed, &context)).await;
 	let elapsed = timer.elapsed();
 	conduit::debug!(?command, ok = result.is_ok(), "command processed in {elapsed:?}");
 	match result {
@@ -129,31 +88,15 @@ async fn process_admin_message(msg: &str) -> CommandOutput {
 	}
 }
 
-#[tracing::instrument(skip_all, name = "command")]
-async fn process_admin_command(command: AdminCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let reply_message_content = match command {
-		AdminCommand::Appservices(command) => appservice::process(command, body).await?,
-		AdminCommand::Media(command) => media::process(command, body).await?,
-		AdminCommand::Users(command) => user::process(command, body).await?,
-		AdminCommand::Rooms(command) => room::process(command, body).await?,
-		AdminCommand::Federation(command) => federation::process(command, body).await?,
-		AdminCommand::Server(command) => server::process(command, body).await?,
-		AdminCommand::Debug(command) => debug::process(command, body).await?,
-		AdminCommand::Query(command) => query::process(command, body).await?,
-		AdminCommand::Check(command) => check::process(command, body).await?,
-	};
-
-	Ok(reply_message_content)
-}
-
 // Parse chat messages from the admin room into an AdminCommand object
-fn parse_admin_command(command_line: &str) -> Result<AdminCommand, String> {
-	let argv = parse_command_line(command_line);
-	AdminCommand::try_parse_from(argv).map_err(|error| error.to_string())
+fn parse_command(command_line: &str) -> Result<(AdminCommand, Vec<String>), String> {
+	let argv = parse_line(command_line);
+	let com = AdminCommand::try_parse_from(&argv).map_err(|error| error.to_string())?;
+	Ok((com, argv))
 }
 
-fn complete_admin_command(mut cmd: clap::Command, line: &str) -> String {
-	let argv = parse_command_line(line);
+fn complete_command(mut cmd: clap::Command, line: &str) -> String {
+	let argv = parse_line(line);
 	let mut ret = Vec::<String>::with_capacity(argv.len().saturating_add(1));
 
 	'token: for token in argv.into_iter().skip(1) {
@@ -196,7 +139,7 @@ fn complete_admin_command(mut cmd: clap::Command, line: &str) -> String {
 }
 
 // Parse chat messages from the admin room into an AdminCommand object
-fn parse_command_line(command_line: &str) -> Vec<String> {
+fn parse_line(command_line: &str) -> Vec<String> {
 	let mut argv = command_line
 		.split_whitespace()
 		.map(str::to_owned)
@@ -208,8 +151,7 @@ fn parse_command_line(command_line: &str) -> Vec<String> {
 	}
 
 	// First indice has to be "admin" but for console convenience we add it here
-	let server_user = services().globals.server_user.as_str();
-	if !argv.is_empty() && !argv[0].ends_with("admin") && !argv[0].starts_with(server_user) {
+	if !argv.is_empty() && !argv[0].ends_with("admin") && !argv[0].starts_with('@') {
 		argv.insert(0, "admin".to_owned());
 	}
 

src/admin/media/commands.rs

@@ -1,11 +1,11 @@
-use conduit::Result;
+use conduit::{debug, info, Result};
 use ruma::{events::room::message::RoomMessageEventContent, EventId, MxcUri};
-use tracing::{debug, info};
 
-use crate::services;
+use crate::admin_command;
 
+#[admin_command]
 pub(super) async fn delete(
-	_body: Vec<&str>, mxc: Option<Box<MxcUri>>, event_id: Option<Box<EventId>>,
+	&self, mxc: Option<Box<MxcUri>>, event_id: Option<Box<EventId>>,
 ) -> Result<RoomMessageEventContent> {
 	if event_id.is_some() && mxc.is_some() {
 		return Ok(RoomMessageEventContent::text_plain(
@@ -15,7 +15,7 @@ pub(super) async fn delete(
 
 	if let Some(mxc) = mxc {
 		debug!("Got MXC URL: {mxc}");
-		services().media.delete(mxc.as_ref()).await?;
+		self.services.media.delete(mxc.as_ref()).await?;
 
 		return Ok(RoomMessageEventContent::text_plain(
 			"Deleted the MXC from our database and on our filesystem.",
@@ -27,7 +27,7 @@ pub(super) async fn delete(
 		let mut mxc_deletion_count: usize = 0;
 
 		// parsing the PDU for any MXC URLs begins here
-		if let Some(event_json) = services().rooms.timeline.get_pdu_json(&event_id)? {
+		if let Some(event_json) = self.services.rooms.timeline.get_pdu_json(&event_id)? {
 			if let Some(content_key) = event_json.get("content") {
 				debug!("Event ID has \"content\".");
 				let content_obj = content_key.as_object();
@@ -123,7 +123,7 @@ pub(super) async fn delete(
 		}
 
 		for mxc_url in mxc_urls {
-			services().media.delete(&mxc_url).await?;
+			self.services.media.delete(&mxc_url).await?;
 			mxc_deletion_count = mxc_deletion_count.saturating_add(1);
 		}
 
@@ -138,23 +138,26 @@ pub(super) async fn delete(
 	))
 }
 
-pub(super) async fn delete_list(body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
+#[admin_command]
+pub(super) async fn delete_list(&self) -> Result<RoomMessageEventContent> {
+	if self.body.len() < 2 || !self.body[0].trim().starts_with("```") || self.body.last().unwrap_or(&"").trim() != "```"
+	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"Expected code block in command body. Add --help for details.",
 		));
 	}
 
-	let mxc_list = body
-		.clone()
-		.drain(1..body.len().checked_sub(1).unwrap())
+	let mxc_list = self
+		.body
+		.to_vec()
+		.drain(1..self.body.len().checked_sub(1).unwrap())
 		.collect::<Vec<_>>();
 
 	let mut mxc_deletion_count: usize = 0;
 
 	for mxc in mxc_list {
 		debug!("Deleting MXC {mxc} in bulk");
-		services().media.delete(mxc).await?;
+		self.services.media.delete(mxc).await?;
 		mxc_deletion_count = mxc_deletion_count
 			.checked_add(1)
 			.expect("mxc_deletion_count should not get this high");
@@ -165,10 +168,10 @@ pub(super) async fn delete_list(body: Vec<&str>) -> Result<RoomMessageEventConte
 	)))
 }
 
-pub(super) async fn delete_past_remote_media(
-	_body: Vec<&str>, duration: String, force: bool,
-) -> Result<RoomMessageEventContent> {
-	let deleted_count = services()
+#[admin_command]
+pub(super) async fn delete_past_remote_media(&self, duration: String, force: bool) -> Result<RoomMessageEventContent> {
+	let deleted_count = self
+		.services
 		.media
 		.delete_all_remote_media_at_after_time(duration, force)
 		.await?;

src/admin/media/mod.rs

@@ -2,12 +2,12 @@ mod commands;
 
 use clap::Subcommand;
 use conduit::Result;
-use ruma::{events::room::message::RoomMessageEventContent, EventId, MxcUri};
+use ruma::{EventId, MxcUri};
 
-use self::commands::*;
+use crate::admin_command_dispatch;
 
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
 pub(super) enum MediaCommand {
 	/// - Deletes a single media file from our database and on the filesystem
 	///   via a single MXC URL
@@ -37,17 +37,3 @@ pub(super) enum MediaCommand {
 		force: bool,
 	},
 }
-
-pub(super) async fn process(command: MediaCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	Ok(match command {
-		MediaCommand::Delete {
-			mxc,
-			event_id,
-		} => delete(body, mxc, event_id).await?,
-		MediaCommand::DeleteList => delete_list(body).await?,
-		MediaCommand::DeletePastRemoteMedia {
-			duration,
-			force,
-		} => delete_past_remote_media(body, duration, force).await?,
-	})
-}

src/admin/mod.rs

@@ -1,54 +1,55 @@
+#![recursion_limit = "192"]
 #![allow(clippy::wildcard_imports)]
+#![allow(clippy::enum_glob_use)]
+
+pub(crate) mod admin;
+pub(crate) mod command;
+pub(crate) mod handler;
+mod tests;
+pub(crate) mod utils;
 
 pub(crate) mod appservice;
 pub(crate) mod check;
 pub(crate) mod debug;
 pub(crate) mod federation;
-pub(crate) mod handler;
 pub(crate) mod media;
 pub(crate) mod query;
 pub(crate) mod room;
 pub(crate) mod server;
-mod tests;
 pub(crate) mod user;
-pub(crate) mod utils;
 
 extern crate conduit_api as api;
 extern crate conduit_core as conduit;
 extern crate conduit_service as service;
 
-pub(crate) use conduit::{mod_ctor, mod_dtor, Result};
-pub(crate) use service::{services, user_is_local};
+pub(crate) use conduit::Result;
+pub(crate) use conduit_macros::{admin_command, admin_command_dispatch};
 
 pub(crate) use crate::{
-	handler::Service,
+	command::Command,
 	utils::{escape_html, get_room_info},
 };
 
-mod_ctor! {}
-mod_dtor! {}
+pub(crate) const PAGE_SIZE: usize = 100;
+
+conduit::mod_ctor! {}
+conduit::mod_dtor! {}
+conduit::rustc_flags_capture! {}
 
 /// Install the admin command handler
-pub async fn init() {
-	_ = services()
-		.admin
+pub async fn init(admin_service: &service::admin::Service) {
+	_ = admin_service
 		.complete
 		.write()
 		.expect("locked for writing")
 		.insert(handler::complete);
-	_ = services()
-		.admin
-		.handle
-		.write()
-		.await
-		.insert(handler::handle);
+	_ = admin_service.handle.write().await.insert(handler::handle);
 }
 
 /// Uninstall the admin command handler
-pub async fn fini() {
-	_ = services().admin.handle.write().await.take();
-	_ = services()
-		.admin
+pub async fn fini(admin_service: &service::admin::Service) {
+	_ = admin_service.handle.write().await.take();
+	_ = admin_service
 		.complete
 		.write()
 		.expect("locked for writing")

src/admin/query/account_data.rs

@@ -1,18 +1,48 @@
-use ruma::events::room::message::RoomMessageEventContent;
+use clap::Subcommand;
+use conduit::Result;
+use ruma::{
+	events::{room::message::RoomMessageEventContent, RoomAccountDataEventType},
+	RoomId, UserId,
+};
 
-use super::AccountData;
-use crate::{services, Result};
+use crate::Command;
+
+#[derive(Debug, Subcommand)]
+/// All the getters and iterators from src/database/key_value/account_data.rs
+pub(crate) enum AccountDataCommand {
+	/// - Returns all changes to the account data that happened after `since`.
+	ChangesSince {
+		/// Full user ID
+		user_id: Box<UserId>,
+		/// UNIX timestamp since (u64)
+		since: u64,
+		/// Optional room ID of the account data
+		room_id: Option<Box<RoomId>>,
+	},
+
+	/// - Searches the account data for a specific kind.
+	Get {
+		/// Full user ID
+		user_id: Box<UserId>,
+		/// Account data event type
+		kind: RoomAccountDataEventType,
+		/// Optional room ID of the account data
+		room_id: Option<Box<RoomId>>,
+	},
+}
 
 /// All the getters and iterators from src/database/key_value/account_data.rs
-pub(super) async fn account_data(subcommand: AccountData) -> Result<RoomMessageEventContent> {
+pub(super) async fn process(subcommand: AccountDataCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	let services = context.services;
+
 	match subcommand {
-		AccountData::ChangesSince {
+		AccountDataCommand::ChangesSince {
 			user_id,
 			since,
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services()
+			let results = services
 				.account_data
 				.changes_since(room_id.as_deref(), &user_id, since)?;
 			let query_time = timer.elapsed();
@@ -21,13 +51,13 @@ pub(super) async fn account_data(subcommand: AccountData) -> Result<RoomMessageE
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		AccountData::Get {
+		AccountDataCommand::Get {
 			user_id,
 			kind,
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services()
+			let results = services
 				.account_data
 				.get(room_id.as_deref(), &user_id, kind)?;
 			let query_time = timer.elapsed();

src/admin/query/appservice.rs

@@ -1,16 +1,32 @@
+use clap::Subcommand;
+use conduit::Result;
 use ruma::events::room::message::RoomMessageEventContent;
 
-use super::Appservice;
-use crate::{services, Result};
+use crate::Command;
+
+#[derive(Debug, Subcommand)]
+/// All the getters and iterators from src/database/key_value/appservice.rs
+pub(crate) enum AppserviceCommand {
+	/// - Gets the appservice registration info/details from the ID as a string
+	GetRegistration {
+		/// Appservice registration ID
+		appservice_id: Box<str>,
+	},
+
+	/// - Gets all appservice registrations with their ID and registration info
+	All,
+}
 
 /// All the getters and iterators from src/database/key_value/appservice.rs
-pub(super) async fn appservice(subcommand: Appservice) -> Result<RoomMessageEventContent> {
+pub(super) async fn process(subcommand: AppserviceCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	let services = context.services;
+
 	match subcommand {
-		Appservice::GetRegistration {
+		AppserviceCommand::GetRegistration {
 			appservice_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services()
+			let results = services
 				.appservice
 				.db
 				.get_registration(appservice_id.as_ref());
@@ -20,9 +36,9 @@ pub(super) async fn appservice(subcommand: Appservice) -> Result<RoomMessageEven
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		Appservice::All => {
+		AppserviceCommand::All => {
 			let timer = tokio::time::Instant::now();
-			let results = services().appservice.all();
+			let results = services.appservice.all();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(

src/admin/query/globals.rs

@@ -1,52 +1,73 @@
-use ruma::events::room::message::RoomMessageEventContent;
+use clap::Subcommand;
+use conduit::Result;
+use ruma::{events::room::message::RoomMessageEventContent, ServerName};
 
-use super::Globals;
-use crate::{services, Result};
+use crate::Command;
+
+#[derive(Debug, Subcommand)]
+/// All the getters and iterators from src/database/key_value/globals.rs
+pub(crate) enum GlobalsCommand {
+	DatabaseVersion,
+
+	CurrentCount,
+
+	LastCheckForUpdatesId,
+
+	LoadKeypair,
+
+	/// - This returns an empty `Ok(BTreeMap<..>)` when there are no keys found
+	///   for the server.
+	SigningKeysFor {
+		origin: Box<ServerName>,
+	},
+}
 
 /// All the getters and iterators from src/database/key_value/globals.rs
-pub(super) async fn globals(subcommand: Globals) -> Result<RoomMessageEventContent> {
+pub(super) async fn process(subcommand: GlobalsCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	let services = context.services;
+
 	match subcommand {
-		Globals::DatabaseVersion => {
+		GlobalsCommand::DatabaseVersion => {
 			let timer = tokio::time::Instant::now();
-			let results = services().globals.db.database_version();
+			let results = services.globals.db.database_version();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		Globals::CurrentCount => {
+		GlobalsCommand::CurrentCount => {
 			let timer = tokio::time::Instant::now();
-			let results = services().globals.db.current_count();
+			let results = services.globals.db.current_count();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		Globals::LastCheckForUpdatesId => {
+		GlobalsCommand::LastCheckForUpdatesId => {
 			let timer = tokio::time::Instant::now();
-			let results = services().updates.last_check_for_updates_id();
+			let results = services.updates.last_check_for_updates_id();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		Globals::LoadKeypair => {
+		GlobalsCommand::LoadKeypair => {
 			let timer = tokio::time::Instant::now();
-			let results = services().globals.db.load_keypair();
+			let results = services.globals.db.load_keypair();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		Globals::SigningKeysFor {
+		GlobalsCommand::SigningKeysFor {
 			origin,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services().globals.db.signing_keys_for(&origin);
+			let results = services.globals.db.verify_keys_for(&origin);
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(

src/admin/query/mod.rs

@@ -10,314 +10,51 @@ mod users;
 
 use clap::Subcommand;
 use conduit::Result;
-use room_state_cache::room_state_cache;
-use ruma::{
-	events::{room::message::RoomMessageEventContent, RoomAccountDataEventType},
-	OwnedServerName, RoomAliasId, RoomId, ServerName, UserId,
-};
 
 use self::{
-	account_data::account_data, appservice::appservice, globals::globals, presence::presence, resolver::resolver,
-	room_alias::room_alias, sending::sending, users::users,
+	account_data::AccountDataCommand, appservice::AppserviceCommand, globals::GlobalsCommand,
+	presence::PresenceCommand, resolver::ResolverCommand, room_alias::RoomAliasCommand,
+	room_state_cache::RoomStateCacheCommand, sending::SendingCommand, users::UsersCommand,
 };
+use crate::admin_command_dispatch;
 
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
 /// Query tables from database
 pub(super) enum QueryCommand {
 	/// - account_data.rs iterators and getters
 	#[command(subcommand)]
-	AccountData(AccountData),
+	AccountData(AccountDataCommand),
 
 	/// - appservice.rs iterators and getters
 	#[command(subcommand)]
-	Appservice(Appservice),
+	Appservice(AppserviceCommand),
 
 	/// - presence.rs iterators and getters
 	#[command(subcommand)]
-	Presence(Presence),
+	Presence(PresenceCommand),
 
 	/// - rooms/alias.rs iterators and getters
 	#[command(subcommand)]
-	RoomAlias(RoomAlias),
+	RoomAlias(RoomAliasCommand),
 
 	/// - rooms/state_cache iterators and getters
 	#[command(subcommand)]
-	RoomStateCache(RoomStateCache),
+	RoomStateCache(RoomStateCacheCommand),
 
 	/// - globals.rs iterators and getters
 	#[command(subcommand)]
-	Globals(Globals),
+	Globals(GlobalsCommand),
 
 	/// - sending.rs iterators and getters
 	#[command(subcommand)]
-	Sending(Sending),
+	Sending(SendingCommand),
 
 	/// - users.rs iterators and getters
 	#[command(subcommand)]
-	Users(Users),
+	Users(UsersCommand),
 
 	/// - resolver service
 	#[command(subcommand)]
-	Resolver(Resolver),
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-/// All the getters and iterators from src/database/key_value/account_data.rs
-pub(super) enum AccountData {
-	/// - Returns all changes to the account data that happened after `since`.
-	ChangesSince {
-		/// Full user ID
-		user_id: Box<UserId>,
-		/// UNIX timestamp since (u64)
-		since: u64,
-		/// Optional room ID of the account data
-		room_id: Option<Box<RoomId>>,
-	},
-
-	/// - Searches the account data for a specific kind.
-	Get {
-		/// Full user ID
-		user_id: Box<UserId>,
-		/// Account data event type
-		kind: RoomAccountDataEventType,
-		/// Optional room ID of the account data
-		room_id: Option<Box<RoomId>>,
-	},
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-/// All the getters and iterators from src/database/key_value/appservice.rs
-pub(super) enum Appservice {
-	/// - Gets the appservice registration info/details from the ID as a string
-	GetRegistration {
-		/// Appservice registration ID
-		appservice_id: Box<str>,
-	},
-
-	/// - Gets all appservice registrations with their ID and registration info
-	All,
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-/// All the getters and iterators from src/database/key_value/presence.rs
-pub(super) enum Presence {
-	/// - Returns the latest presence event for the given user.
-	GetPresence {
-		/// Full user ID
-		user_id: Box<UserId>,
-	},
-
-	/// - Iterator of the most recent presence updates that happened after the
-	///   event with id `since`.
-	PresenceSince {
-		/// UNIX timestamp since (u64)
-		since: u64,
-	},
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-/// All the getters and iterators from src/database/key_value/rooms/alias.rs
-pub(super) enum RoomAlias {
-	ResolveLocalAlias {
-		/// Full room alias
-		alias: Box<RoomAliasId>,
-	},
-
-	/// - Iterator of all our local room aliases for the room ID
-	LocalAliasesForRoom {
-		/// Full room ID
-		room_id: Box<RoomId>,
-	},
-
-	/// - Iterator of all our local aliases in our database with their room IDs
-	AllLocalAliases,
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-pub(super) enum RoomStateCache {
-	ServerInRoom {
-		server: Box<ServerName>,
-		room_id: Box<RoomId>,
-	},
-
-	RoomServers {
-		room_id: Box<RoomId>,
-	},
-
-	ServerRooms {
-		server: Box<ServerName>,
-	},
-
-	RoomMembers {
-		room_id: Box<RoomId>,
-	},
-
-	LocalUsersInRoom {
-		room_id: Box<RoomId>,
-	},
-
-	ActiveLocalUsersInRoom {
-		room_id: Box<RoomId>,
-	},
-
-	RoomJoinedCount {
-		room_id: Box<RoomId>,
-	},
-
-	RoomInvitedCount {
-		room_id: Box<RoomId>,
-	},
-
-	RoomUserOnceJoined {
-		room_id: Box<RoomId>,
-	},
-
-	RoomMembersInvited {
-		room_id: Box<RoomId>,
-	},
-
-	GetInviteCount {
-		room_id: Box<RoomId>,
-		user_id: Box<UserId>,
-	},
-
-	GetLeftCount {
-		room_id: Box<RoomId>,
-		user_id: Box<UserId>,
-	},
-
-	RoomsJoined {
-		user_id: Box<UserId>,
-	},
-
-	RoomsLeft {
-		user_id: Box<UserId>,
-	},
-
-	RoomsInvited {
-		user_id: Box<UserId>,
-	},
-
-	InviteState {
-		user_id: Box<UserId>,
-		room_id: Box<RoomId>,
-	},
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-/// All the getters and iterators from src/database/key_value/globals.rs
-pub(super) enum Globals {
-	DatabaseVersion,
-
-	CurrentCount,
-
-	LastCheckForUpdatesId,
-
-	LoadKeypair,
-
-	/// - This returns an empty `Ok(BTreeMap<..>)` when there are no keys found
-	///   for the server.
-	SigningKeysFor {
-		origin: Box<ServerName>,
-	},
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-/// All the getters and iterators from src/database/key_value/sending.rs
-pub(super) enum Sending {
-	/// - Queries database for all `servercurrentevent_data`
-	ActiveRequests,
-
-	/// - Queries database for `servercurrentevent_data` but for a specific
-	///   destination
-	///
-	/// This command takes only *one* format of these arguments:
-	///
-	/// appservice_id
-	/// server_name
-	/// user_id AND push_key
-	///
-	/// See src/service/sending/mod.rs for the definition of the `Destination`
-	/// enum
-	ActiveRequestsFor {
-		#[arg(short, long)]
-		appservice_id: Option<String>,
-		#[arg(short, long)]
-		server_name: Option<Box<ServerName>>,
-		#[arg(short, long)]
-		user_id: Option<Box<UserId>>,
-		#[arg(short, long)]
-		push_key: Option<String>,
-	},
-
-	/// - Queries database for `servernameevent_data` which are the queued up
-	///   requests that will eventually be sent
-	///
-	/// This command takes only *one* format of these arguments:
-	///
-	/// appservice_id
-	/// server_name
-	/// user_id AND push_key
-	///
-	/// See src/service/sending/mod.rs for the definition of the `Destination`
-	/// enum
-	QueuedRequests {
-		#[arg(short, long)]
-		appservice_id: Option<String>,
-		#[arg(short, long)]
-		server_name: Option<Box<ServerName>>,
-		#[arg(short, long)]
-		user_id: Option<Box<UserId>>,
-		#[arg(short, long)]
-		push_key: Option<String>,
-	},
-
-	GetLatestEduCount {
-		server_name: Box<ServerName>,
-	},
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-/// All the getters and iterators from src/database/key_value/users.rs
-pub(super) enum Users {
-	Iter,
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-/// Resolver service and caches
-pub(super) enum Resolver {
-	/// Query the destinations cache
-	DestinationsCache {
-		server_name: Option<OwnedServerName>,
-	},
-
-	/// Query the overrides cache
-	OverridesCache {
-		name: Option<String>,
-	},
-}
-
-/// Processes admin query commands
-pub(super) async fn process(command: QueryCommand, _body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	Ok(match command {
-		QueryCommand::AccountData(command) => account_data(command).await?,
-		QueryCommand::Appservice(command) => appservice(command).await?,
-		QueryCommand::Presence(command) => presence(command).await?,
-		QueryCommand::RoomAlias(command) => room_alias(command).await?,
-		QueryCommand::RoomStateCache(command) => room_state_cache(command).await?,
-		QueryCommand::Globals(command) => globals(command).await?,
-		QueryCommand::Sending(command) => sending(command).await?,
-		QueryCommand::Users(command) => users(command).await?,
-		QueryCommand::Resolver(command) => resolver(command).await?,
-	})
+	Resolver(ResolverCommand),
 }

src/admin/query/presence.rs

@@ -1,27 +1,47 @@
-use ruma::events::room::message::RoomMessageEventContent;
+use clap::Subcommand;
+use conduit::Result;
+use ruma::{events::room::message::RoomMessageEventContent, UserId};
 
-use super::Presence;
-use crate::{services, Result};
+use crate::Command;
+
+#[derive(Debug, Subcommand)]
+/// All the getters and iterators from src/database/key_value/presence.rs
+pub(crate) enum PresenceCommand {
+	/// - Returns the latest presence event for the given user.
+	GetPresence {
+		/// Full user ID
+		user_id: Box<UserId>,
+	},
+
+	/// - Iterator of the most recent presence updates that happened after the
+	///   event with id `since`.
+	PresenceSince {
+		/// UNIX timestamp since (u64)
+		since: u64,
+	},
+}
 
 /// All the getters and iterators in key_value/presence.rs
-pub(super) async fn presence(subcommand: Presence) -> Result<RoomMessageEventContent> {
+pub(super) async fn process(subcommand: PresenceCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	let services = context.services;
+
 	match subcommand {
-		Presence::GetPresence {
+		PresenceCommand::GetPresence {
 			user_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services().presence.db.get_presence(&user_id)?;
+			let results = services.presence.db.get_presence(&user_id)?;
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		Presence::PresenceSince {
+		PresenceCommand::PresenceSince {
 			since,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services().presence.db.presence_since(since);
+			let results = services.presence.db.presence_since(since);
 			let presence_since: Vec<(_, _, _)> = results.collect();
 			let query_time = timer.elapsed();
 

src/admin/query/resolver.rs

@@ -1,25 +1,29 @@
 use std::fmt::Write;
 
+use clap::Subcommand;
 use conduit::{utils::time, Result};
 use ruma::{events::room::message::RoomMessageEventContent, OwnedServerName};
 
-use super::Resolver;
-use crate::services;
+use crate::{admin_command, admin_command_dispatch};
 
-/// All the getters and iterators in key_value/users.rs
-pub(super) async fn resolver(subcommand: Resolver) -> Result<RoomMessageEventContent> {
-	match subcommand {
-		Resolver::DestinationsCache {
-			server_name,
-		} => destinations_cache(server_name).await,
-		Resolver::OverridesCache {
-			name,
-		} => overrides_cache(name).await,
-	}
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
+/// Resolver service and caches
+pub(crate) enum ResolverCommand {
+	/// Query the destinations cache
+	DestinationsCache {
+		server_name: Option<OwnedServerName>,
+	},
+
+	/// Query the overrides cache
+	OverridesCache {
+		name: Option<String>,
+	},
 }
 
-async fn destinations_cache(server_name: Option<OwnedServerName>) -> Result<RoomMessageEventContent> {
-	use service::sending::CachedDest;
+#[admin_command]
+async fn destinations_cache(&self, server_name: Option<OwnedServerName>) -> Result<RoomMessageEventContent> {
+	use service::resolver::cache::CachedDest;
 
 	let mut out = String::new();
 	writeln!(out, "| Server Name | Destination | Hostname | Expires |")?;
@@ -36,9 +40,10 @@ async fn destinations_cache(server_name: Option<OwnedServerName>) -> Result<Room
 		writeln!(out, "| {name} | {dest} | {host} | {expire} |").expect("wrote line");
 	};
 
-	let map = services()
-		.globals
+	let map = self
+		.services
 		.resolver
+		.cache
 		.destinations
 		.read()
 		.expect("locked");
@@ -52,8 +57,9 @@ async fn destinations_cache(server_name: Option<OwnedServerName>) -> Result<Room
 	Ok(RoomMessageEventContent::notice_markdown(out))
 }
 
-async fn overrides_cache(server_name: Option<String>) -> Result<RoomMessageEventContent> {
-	use service::sending::CachedOverride;
+#[admin_command]
+async fn overrides_cache(&self, server_name: Option<String>) -> Result<RoomMessageEventContent> {
+	use service::resolver::cache::CachedOverride;
 
 	let mut out = String::new();
 	writeln!(out, "| Server Name | IP  | Port | Expires |")?;
@@ -70,9 +76,10 @@ async fn overrides_cache(server_name: Option<String>) -> Result<RoomMessageEvent
 		writeln!(out, "| {name} | {ips:?} | {port} | {expire} |").expect("wrote line");
 	};
 
-	let map = services()
-		.globals
+	let map = self
+		.services
 		.resolver
+		.cache
 		.overrides
 		.read()
 		.expect("locked");

src/admin/query/room_alias.rs

@@ -1,27 +1,48 @@
-use ruma::events::room::message::RoomMessageEventContent;
+use clap::Subcommand;
+use conduit::Result;
+use ruma::{events::room::message::RoomMessageEventContent, RoomAliasId, RoomId};
 
-use super::RoomAlias;
-use crate::{services, Result};
+use crate::Command;
+
+#[derive(Debug, Subcommand)]
+/// All the getters and iterators from src/database/key_value/rooms/alias.rs
+pub(crate) enum RoomAliasCommand {
+	ResolveLocalAlias {
+		/// Full room alias
+		alias: Box<RoomAliasId>,
+	},
+
+	/// - Iterator of all our local room aliases for the room ID
+	LocalAliasesForRoom {
+		/// Full room ID
+		room_id: Box<RoomId>,
+	},
+
+	/// - Iterator of all our local aliases in our database with their room IDs
+	AllLocalAliases,
+}
 
 /// All the getters and iterators in src/database/key_value/rooms/alias.rs
-pub(super) async fn room_alias(subcommand: RoomAlias) -> Result<RoomMessageEventContent> {
+pub(super) async fn process(subcommand: RoomAliasCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	let services = context.services;
+
 	match subcommand {
-		RoomAlias::ResolveLocalAlias {
+		RoomAliasCommand::ResolveLocalAlias {
 			alias,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services().rooms.alias.resolve_local_alias(&alias);
+			let results = services.rooms.alias.resolve_local_alias(&alias);
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomAlias::LocalAliasesForRoom {
+		RoomAliasCommand::LocalAliasesForRoom {
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services().rooms.alias.local_aliases_for_room(&room_id);
+			let results = services.rooms.alias.local_aliases_for_room(&room_id);
 			let aliases: Vec<_> = results.collect();
 			let query_time = timer.elapsed();
 
@@ -29,9 +50,9 @@ pub(super) async fn room_alias(subcommand: RoomAlias) -> Result<RoomMessageEvent
 				"Query completed in {query_time:?}:\n\n```rs\n{aliases:#?}\n```"
 			)))
 		},
-		RoomAlias::AllLocalAliases => {
+		RoomAliasCommand::AllLocalAliases => {
 			let timer = tokio::time::Instant::now();
-			let results = services().rooms.alias.all_local_aliases();
+			let results = services.rooms.alias.all_local_aliases();
 			let aliases: Vec<_> = results.collect();
 			let query_time = timer.elapsed();
 

src/admin/query/room_state_cache.rs

@@ -1,71 +1,136 @@
-use ruma::events::room::message::RoomMessageEventContent;
+use clap::Subcommand;
+use conduit::Result;
+use ruma::{events::room::message::RoomMessageEventContent, RoomId, ServerName, UserId};
 
-use super::RoomStateCache;
-use crate::{services, Result};
+use crate::Command;
+
+#[derive(Debug, Subcommand)]
+pub(crate) enum RoomStateCacheCommand {
+	ServerInRoom {
+		server: Box<ServerName>,
+		room_id: Box<RoomId>,
+	},
+
+	RoomServers {
+		room_id: Box<RoomId>,
+	},
+
+	ServerRooms {
+		server: Box<ServerName>,
+	},
+
+	RoomMembers {
+		room_id: Box<RoomId>,
+	},
+
+	LocalUsersInRoom {
+		room_id: Box<RoomId>,
+	},
+
+	ActiveLocalUsersInRoom {
+		room_id: Box<RoomId>,
+	},
+
+	RoomJoinedCount {
+		room_id: Box<RoomId>,
+	},
+
+	RoomInvitedCount {
+		room_id: Box<RoomId>,
+	},
+
+	RoomUserOnceJoined {
+		room_id: Box<RoomId>,
+	},
+
+	RoomMembersInvited {
+		room_id: Box<RoomId>,
+	},
+
+	GetInviteCount {
+		room_id: Box<RoomId>,
+		user_id: Box<UserId>,
+	},
+
+	GetLeftCount {
+		room_id: Box<RoomId>,
+		user_id: Box<UserId>,
+	},
+
+	RoomsJoined {
+		user_id: Box<UserId>,
+	},
+
+	RoomsLeft {
+		user_id: Box<UserId>,
+	},
+
+	RoomsInvited {
+		user_id: Box<UserId>,
+	},
+
+	InviteState {
+		user_id: Box<UserId>,
+		room_id: Box<RoomId>,
+	},
+}
+
+pub(super) async fn process(
+	subcommand: RoomStateCacheCommand, context: &Command<'_>,
+) -> Result<RoomMessageEventContent> {
+	let services = context.services;
 
-pub(super) async fn room_state_cache(subcommand: RoomStateCache) -> Result<RoomMessageEventContent> {
 	match subcommand {
-		RoomStateCache::ServerInRoom {
+		RoomStateCacheCommand::ServerInRoom {
 			server,
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let result = services()
-				.rooms
-				.state_cache
-				.server_in_room(&server, &room_id);
+			let result = services.rooms.state_cache.server_in_room(&server, &room_id);
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{result:#?}\n```"
 			)))
 		},
-		RoomStateCache::RoomServers {
+		RoomStateCacheCommand::RoomServers {
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Result<Vec<_>> = services()
-				.rooms
-				.state_cache
-				.room_servers(&room_id)
-				.collect();
+			let results: Result<Vec<_>> = services.rooms.state_cache.room_servers(&room_id).collect();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::ServerRooms {
+		RoomStateCacheCommand::ServerRooms {
 			server,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Result<Vec<_>> = services().rooms.state_cache.server_rooms(&server).collect();
+			let results: Result<Vec<_>> = services.rooms.state_cache.server_rooms(&server).collect();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::RoomMembers {
+		RoomStateCacheCommand::RoomMembers {
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Result<Vec<_>> = services()
-				.rooms
-				.state_cache
-				.room_members(&room_id)
-				.collect();
+			let results: Result<Vec<_>> = services.rooms.state_cache.room_members(&room_id).collect();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::LocalUsersInRoom {
+		RoomStateCacheCommand::LocalUsersInRoom {
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Vec<_> = services()
+			let results: Vec<_> = services
 				.rooms
 				.state_cache
 				.local_users_in_room(&room_id)
@@ -76,11 +141,11 @@ pub(super) async fn room_state_cache(subcommand: RoomStateCache) -> Result<RoomM
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::ActiveLocalUsersInRoom {
+		RoomStateCacheCommand::ActiveLocalUsersInRoom {
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Vec<_> = services()
+			let results: Vec<_> = services
 				.rooms
 				.state_cache
 				.active_local_users_in_room(&room_id)
@@ -91,33 +156,33 @@ pub(super) async fn room_state_cache(subcommand: RoomStateCache) -> Result<RoomM
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::RoomJoinedCount {
+		RoomStateCacheCommand::RoomJoinedCount {
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services().rooms.state_cache.room_joined_count(&room_id);
+			let results = services.rooms.state_cache.room_joined_count(&room_id);
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::RoomInvitedCount {
+		RoomStateCacheCommand::RoomInvitedCount {
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services().rooms.state_cache.room_invited_count(&room_id);
+			let results = services.rooms.state_cache.room_invited_count(&room_id);
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::RoomUserOnceJoined {
+		RoomStateCacheCommand::RoomUserOnceJoined {
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Result<Vec<_>> = services()
+			let results: Result<Vec<_>> = services
 				.rooms
 				.state_cache
 				.room_useroncejoined(&room_id)
@@ -128,11 +193,11 @@ pub(super) async fn room_state_cache(subcommand: RoomStateCache) -> Result<RoomM
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::RoomMembersInvited {
+		RoomStateCacheCommand::RoomMembersInvited {
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Result<Vec<_>> = services()
+			let results: Result<Vec<_>> = services
 				.rooms
 				.state_cache
 				.room_members_invited(&room_id)
@@ -143,12 +208,12 @@ pub(super) async fn room_state_cache(subcommand: RoomStateCache) -> Result<RoomM
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::GetInviteCount {
+		RoomStateCacheCommand::GetInviteCount {
 			room_id,
 			user_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services()
+			let results = services
 				.rooms
 				.state_cache
 				.get_invite_count(&room_id, &user_id);
@@ -158,12 +223,12 @@ pub(super) async fn room_state_cache(subcommand: RoomStateCache) -> Result<RoomM
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::GetLeftCount {
+		RoomStateCacheCommand::GetLeftCount {
 			room_id,
 			user_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services()
+			let results = services
 				.rooms
 				.state_cache
 				.get_left_count(&room_id, &user_id);
@@ -173,56 +238,45 @@ pub(super) async fn room_state_cache(subcommand: RoomStateCache) -> Result<RoomM
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::RoomsJoined {
+		RoomStateCacheCommand::RoomsJoined {
 			user_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Result<Vec<_>> = services()
-				.rooms
-				.state_cache
-				.rooms_joined(&user_id)
-				.collect();
+			let results: Result<Vec<_>> = services.rooms.state_cache.rooms_joined(&user_id).collect();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::RoomsInvited {
+		RoomStateCacheCommand::RoomsInvited {
 			user_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Result<Vec<_>> = services()
-				.rooms
-				.state_cache
-				.rooms_invited(&user_id)
-				.collect();
+			let results: Result<Vec<_>> = services.rooms.state_cache.rooms_invited(&user_id).collect();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::RoomsLeft {
+		RoomStateCacheCommand::RoomsLeft {
 			user_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results: Result<Vec<_>> = services().rooms.state_cache.rooms_left(&user_id).collect();
+			let results: Result<Vec<_>> = services.rooms.state_cache.rooms_left(&user_id).collect();
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(
 				"Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```"
 			)))
 		},
-		RoomStateCache::InviteState {
+		RoomStateCacheCommand::InviteState {
 			user_id,
 			room_id,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services()
-				.rooms
-				.state_cache
-				.invite_state(&user_id, &room_id);
+			let results = services.rooms.state_cache.invite_state(&user_id, &room_id);
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(

src/admin/query/sending.rs

@@ -1,14 +1,73 @@
-use ruma::events::room::message::RoomMessageEventContent;
+use clap::Subcommand;
+use conduit::Result;
+use ruma::{events::room::message::RoomMessageEventContent, ServerName, UserId};
+use service::sending::Destination;
 
-use super::Sending;
-use crate::{service::sending::Destination, services, Result};
+use crate::Command;
+
+#[derive(Debug, Subcommand)]
+/// All the getters and iterators from src/database/key_value/sending.rs
+pub(crate) enum SendingCommand {
+	/// - Queries database for all `servercurrentevent_data`
+	ActiveRequests,
+
+	/// - Queries database for `servercurrentevent_data` but for a specific
+	///   destination
+	///
+	/// This command takes only *one* format of these arguments:
+	///
+	/// appservice_id
+	/// server_name
+	/// user_id AND push_key
+	///
+	/// See src/service/sending/mod.rs for the definition of the `Destination`
+	/// enum
+	ActiveRequestsFor {
+		#[arg(short, long)]
+		appservice_id: Option<String>,
+		#[arg(short, long)]
+		server_name: Option<Box<ServerName>>,
+		#[arg(short, long)]
+		user_id: Option<Box<UserId>>,
+		#[arg(short, long)]
+		push_key: Option<String>,
+	},
+
+	/// - Queries database for `servernameevent_data` which are the queued up
+	///   requests that will eventually be sent
+	///
+	/// This command takes only *one* format of these arguments:
+	///
+	/// appservice_id
+	/// server_name
+	/// user_id AND push_key
+	///
+	/// See src/service/sending/mod.rs for the definition of the `Destination`
+	/// enum
+	QueuedRequests {
+		#[arg(short, long)]
+		appservice_id: Option<String>,
+		#[arg(short, long)]
+		server_name: Option<Box<ServerName>>,
+		#[arg(short, long)]
+		user_id: Option<Box<UserId>>,
+		#[arg(short, long)]
+		push_key: Option<String>,
+	},
+
+	GetLatestEduCount {
+		server_name: Box<ServerName>,
+	},
+}
 
 /// All the getters and iterators in key_value/sending.rs
-pub(super) async fn sending(subcommand: Sending) -> Result<RoomMessageEventContent> {
+pub(super) async fn process(subcommand: SendingCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	let services = context.services;
+
 	match subcommand {
-		Sending::ActiveRequests => {
+		SendingCommand::ActiveRequests => {
 			let timer = tokio::time::Instant::now();
-			let results = services().sending.db.active_requests();
+			let results = services.sending.db.active_requests();
 			let active_requests: Result<Vec<(_, _, _)>> = results.collect();
 			let query_time = timer.elapsed();
 
@@ -16,7 +75,7 @@ pub(super) async fn sending(subcommand: Sending) -> Result<RoomMessageEventConte
 				"Query completed in {query_time:?}:\n\n```rs\n{active_requests:#?}\n```"
 			)))
 		},
-		Sending::QueuedRequests {
+		SendingCommand::QueuedRequests {
 			appservice_id,
 			server_name,
 			user_id,
@@ -38,12 +97,12 @@ pub(super) async fn sending(subcommand: Sending) -> Result<RoomMessageEventConte
 						));
 					}
 
-					services()
+					services
 						.sending
 						.db
 						.queued_requests(&Destination::Appservice(appservice_id))
 				},
-				(None, Some(server_name), None, None) => services()
+				(None, Some(server_name), None, None) => services
 					.sending
 					.db
 					.queued_requests(&Destination::Normal(server_name.into())),
@@ -55,7 +114,7 @@ pub(super) async fn sending(subcommand: Sending) -> Result<RoomMessageEventConte
 						));
 					}
 
-					services()
+					services
 						.sending
 						.db
 						.queued_requests(&Destination::Push(user_id.into(), push_key))
@@ -81,7 +140,7 @@ pub(super) async fn sending(subcommand: Sending) -> Result<RoomMessageEventConte
 				"Query completed in {query_time:?}:\n\n```rs\n{queued_requests:#?}\n```"
 			)))
 		},
-		Sending::ActiveRequestsFor {
+		SendingCommand::ActiveRequestsFor {
 			appservice_id,
 			server_name,
 			user_id,
@@ -104,12 +163,12 @@ pub(super) async fn sending(subcommand: Sending) -> Result<RoomMessageEventConte
 						));
 					}
 
-					services()
+					services
 						.sending
 						.db
 						.active_requests_for(&Destination::Appservice(appservice_id))
 				},
-				(None, Some(server_name), None, None) => services()
+				(None, Some(server_name), None, None) => services
 					.sending
 					.db
 					.active_requests_for(&Destination::Normal(server_name.into())),
@@ -121,7 +180,7 @@ pub(super) async fn sending(subcommand: Sending) -> Result<RoomMessageEventConte
 						));
 					}
 
-					services()
+					services
 						.sending
 						.db
 						.active_requests_for(&Destination::Push(user_id.into(), push_key))
@@ -147,11 +206,11 @@ pub(super) async fn sending(subcommand: Sending) -> Result<RoomMessageEventConte
 				"Query completed in {query_time:?}:\n\n```rs\n{active_requests:#?}\n```"
 			)))
 		},
-		Sending::GetLatestEduCount {
+		SendingCommand::GetLatestEduCount {
 			server_name,
 		} => {
 			let timer = tokio::time::Instant::now();
-			let results = services().sending.db.get_latest_educount(&server_name);
+			let results = services.sending.db.get_latest_educount(&server_name);
 			let query_time = timer.elapsed();
 
 			Ok(RoomMessageEventContent::notice_markdown(format!(

src/admin/query/users.rs

@@ -1,14 +1,23 @@
+use clap::Subcommand;
+use conduit::Result;
 use ruma::events::room::message::RoomMessageEventContent;
 
-use super::Users;
-use crate::{services, Result};
+use crate::Command;
+
+#[derive(Debug, Subcommand)]
+/// All the getters and iterators from src/database/key_value/users.rs
+pub(crate) enum UsersCommand {
+	Iter,
+}
 
 /// All the getters and iterators in key_value/users.rs
-pub(super) async fn users(subcommand: Users) -> Result<RoomMessageEventContent> {
+pub(super) async fn process(subcommand: UsersCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	let services = context.services;
+
 	match subcommand {
-		Users::Iter => {
+		UsersCommand::Iter => {
 			let timer = tokio::time::Instant::now();
-			let results = services().users.db.iter();
+			let results = services.users.db.iter();
 			let users = results.collect::<Vec<_>>();
 			let query_time = timer.elapsed();
 

src/admin/room/alias.rs

@@ -1,12 +1,49 @@
 use std::fmt::Write;
 
-use ruma::{events::room::message::RoomMessageEventContent, RoomAliasId};
+use clap::Subcommand;
+use conduit::Result;
+use ruma::{events::room::message::RoomMessageEventContent, RoomAliasId, RoomId};
 
-use super::RoomAliasCommand;
-use crate::{escape_html, services, Result};
+use crate::{escape_html, Command};
 
-pub(super) async fn process(command: RoomAliasCommand, _body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let server_user = &services().globals.server_user;
+#[derive(Debug, Subcommand)]
+pub(crate) enum RoomAliasCommand {
+	/// - Make an alias point to a room.
+	Set {
+		#[arg(short, long)]
+		/// Set the alias even if a room is already using it
+		force: bool,
+
+		/// The room id to set the alias on
+		room_id: Box<RoomId>,
+
+		/// The alias localpart to use (`alias`, not `#alias:servername.tld`)
+		room_alias_localpart: String,
+	},
+
+	/// - Remove a local alias
+	Remove {
+		/// The alias localpart to remove (`alias`, not `#alias:servername.tld`)
+		room_alias_localpart: String,
+	},
+
+	/// - Show which room is using an alias
+	Which {
+		/// The alias localpart to look up (`alias`, not
+		/// `#alias:servername.tld`)
+		room_alias_localpart: String,
+	},
+
+	/// - List aliases currently being used
+	List {
+		/// If set, only list the aliases for this room
+		room_id: Option<Box<RoomId>>,
+	},
+}
+
+pub(super) async fn process(command: RoomAliasCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	let services = context.services;
+	let server_user = &services.globals.server_user;
 
 	match command {
 		RoomAliasCommand::Set {
@@ -19,7 +56,7 @@ pub(super) async fn process(command: RoomAliasCommand, _body: Vec<&str>) -> Resu
 		| RoomAliasCommand::Which {
 			ref room_alias_localpart,
 		} => {
-			let room_alias_str = format!("#{}:{}", room_alias_localpart, services().globals.server_name());
+			let room_alias_str = format!("#{}:{}", room_alias_localpart, services.globals.server_name());
 			let room_alias = match RoomAliasId::parse_box(room_alias_str) {
 				Ok(alias) => alias,
 				Err(err) => return Ok(RoomMessageEventContent::text_plain(format!("Failed to parse alias: {err}"))),
@@ -29,8 +66,8 @@ pub(super) async fn process(command: RoomAliasCommand, _body: Vec<&str>) -> Resu
 					force,
 					room_id,
 					..
-				} => match (force, services().rooms.alias.resolve_local_alias(&room_alias)) {
-					(true, Ok(Some(id))) => match services()
+				} => match (force, services.rooms.alias.resolve_local_alias(&room_alias)) {
+					(true, Ok(Some(id))) => match services
 						.rooms
 						.alias
 						.set_alias(&room_alias, &room_id, server_user)
@@ -43,7 +80,7 @@ pub(super) async fn process(command: RoomAliasCommand, _body: Vec<&str>) -> Resu
 					(false, Ok(Some(id))) => Ok(RoomMessageEventContent::text_plain(format!(
 						"Refusing to overwrite in use alias for {id}, use -f or --force to overwrite"
 					))),
-					(_, Ok(None)) => match services()
+					(_, Ok(None)) => match services
 						.rooms
 						.alias
 						.set_alias(&room_alias, &room_id, server_user)
@@ -55,8 +92,8 @@ pub(super) async fn process(command: RoomAliasCommand, _body: Vec<&str>) -> Resu
 				},
 				RoomAliasCommand::Remove {
 					..
-				} => match services().rooms.alias.resolve_local_alias(&room_alias) {
-					Ok(Some(id)) => match services()
+				} => match services.rooms.alias.resolve_local_alias(&room_alias) {
+					Ok(Some(id)) => match services
 						.rooms
 						.alias
 						.remove_alias(&room_alias, server_user)
@@ -70,7 +107,7 @@ pub(super) async fn process(command: RoomAliasCommand, _body: Vec<&str>) -> Resu
 				},
 				RoomAliasCommand::Which {
 					..
-				} => match services().rooms.alias.resolve_local_alias(&room_alias) {
+				} => match services.rooms.alias.resolve_local_alias(&room_alias) {
 					Ok(Some(id)) => Ok(RoomMessageEventContent::text_plain(format!("Alias resolves to {id}"))),
 					Ok(None) => Ok(RoomMessageEventContent::text_plain("Alias isn't in use.")),
 					Err(err) => Ok(RoomMessageEventContent::text_plain(format!("Unable to lookup alias: {err}"))),
@@ -84,7 +121,7 @@ pub(super) async fn process(command: RoomAliasCommand, _body: Vec<&str>) -> Resu
 			room_id,
 		} => {
 			if let Some(room_id) = room_id {
-				let aliases = services()
+				let aliases = services
 					.rooms
 					.alias
 					.local_aliases_for_room(&room_id)
@@ -109,14 +146,14 @@ pub(super) async fn process(command: RoomAliasCommand, _body: Vec<&str>) -> Resu
 					Err(err) => Ok(RoomMessageEventContent::text_plain(format!("Unable to list aliases: {err}"))),
 				}
 			} else {
-				let aliases = services()
+				let aliases = services
 					.rooms
 					.alias
 					.all_local_aliases()
 					.collect::<Result<Vec<_>, _>>();
 				match aliases {
 					Ok(aliases) => {
-						let server_name = services().globals.server_name();
+						let server_name = services.globals.server_name();
 						let plain_list = aliases
 							.iter()
 							.fold(String::new(), |mut output, (alias, id)| {

src/admin/room/commands.rs

@@ -1,15 +1,18 @@
 use std::fmt::Write;
 
+use conduit::Result;
 use ruma::events::room::message::RoomMessageEventContent;
 
-use crate::{escape_html, get_room_info, handler::PAGE_SIZE, services, Result};
+use crate::{admin_command, escape_html, get_room_info, PAGE_SIZE};
 
-pub(super) async fn list(
-	_body: Vec<&str>, page: Option<usize>, exclude_disabled: bool, exclude_banned: bool,
+#[admin_command]
+pub(super) async fn list_rooms(
+	&self, page: Option<usize>, exclude_disabled: bool, exclude_banned: bool,
 ) -> Result<RoomMessageEventContent> {
 	// TODO: i know there's a way to do this with clap, but i can't seem to find it
 	let page = page.unwrap_or(1);
-	let mut rooms = services()
+	let mut rooms = self
+		.services
 		.rooms
 		.metadata
 		.iter_ids()
@@ -18,7 +21,8 @@ pub(super) async fn list(
 				.ok()
 				.filter(|room_id| {
 					if exclude_disabled
-						&& services()
+						&& self
+							.services
 							.rooms
 							.metadata
 							.is_disabled(room_id)
@@ -28,7 +32,8 @@ pub(super) async fn list(
 					}
 
 					if exclude_banned
-						&& services()
+						&& self
+							.services
 							.rooms
 							.metadata
 							.is_banned(room_id)
@@ -39,7 +44,7 @@ pub(super) async fn list(
 
 					true
 				})
-				.map(|room_id| get_room_info(&room_id))
+				.map(|room_id| get_room_info(self.services, &room_id))
 		})
 		.collect::<Vec<_>>();
 	rooms.sort_by_key(|r| r.1);

src/admin/room/directory.rs

@@ -1,21 +1,43 @@
 use std::fmt::Write;
 
-use ruma::{events::room::message::RoomMessageEventContent, OwnedRoomId};
+use clap::Subcommand;
+use conduit::Result;
+use ruma::{events::room::message::RoomMessageEventContent, OwnedRoomId, RoomId};
 
-use super::RoomDirectoryCommand;
-use crate::{escape_html, get_room_info, handler::PAGE_SIZE, services, Result};
+use crate::{escape_html, get_room_info, Command, PAGE_SIZE};
 
-pub(super) async fn process(command: RoomDirectoryCommand, _body: Vec<&str>) -> Result<RoomMessageEventContent> {
+#[derive(Debug, Subcommand)]
+pub(crate) enum RoomDirectoryCommand {
+	/// - Publish a room to the room directory
+	Publish {
+		/// The room id of the room to publish
+		room_id: Box<RoomId>,
+	},
+
+	/// - Unpublish a room to the room directory
+	Unpublish {
+		/// The room id of the room to unpublish
+		room_id: Box<RoomId>,
+	},
+
+	/// - List rooms that are published
+	List {
+		page: Option<usize>,
+	},
+}
+
+pub(super) async fn process(command: RoomDirectoryCommand, context: &Command<'_>) -> Result<RoomMessageEventContent> {
+	let services = context.services;
 	match command {
 		RoomDirectoryCommand::Publish {
 			room_id,
-		} => match services().rooms.directory.set_public(&room_id) {
+		} => match services.rooms.directory.set_public(&room_id) {
 			Ok(()) => Ok(RoomMessageEventContent::text_plain("Room published")),
 			Err(err) => Ok(RoomMessageEventContent::text_plain(format!("Unable to update room: {err}"))),
 		},
 		RoomDirectoryCommand::Unpublish {
 			room_id,
-		} => match services().rooms.directory.set_not_public(&room_id) {
+		} => match services.rooms.directory.set_not_public(&room_id) {
 			Ok(()) => Ok(RoomMessageEventContent::text_plain("Room unpublished")),
 			Err(err) => Ok(RoomMessageEventContent::text_plain(format!("Unable to update room: {err}"))),
 		},
@@ -24,12 +46,12 @@ pub(super) async fn process(command: RoomDirectoryCommand, _body: Vec<&str>) ->
 		} => {
 			// TODO: i know there's a way to do this with clap, but i can't seem to find it
 			let page = page.unwrap_or(1);
-			let mut rooms = services()
+			let mut rooms = services
 				.rooms
 				.directory
 				.public_rooms()
 				.filter_map(Result::ok)
-				.map(|id: OwnedRoomId| get_room_info(&id))
+				.map(|id: OwnedRoomId| get_room_info(services, &id))
 				.collect::<Vec<_>>();
 			rooms.sort_by_key(|r| r.1);
 			rooms.reverse();

src/admin/room/info.rs

@@ -1,22 +1,30 @@
+use clap::Subcommand;
+use conduit::Result;
 use ruma::{events::room::message::RoomMessageEventContent, RoomId};
-use service::services;
 
-use super::RoomInfoCommand;
-use crate::Result;
+use crate::{admin_command, admin_command_dispatch};
 
-pub(super) async fn process(command: RoomInfoCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	match command {
-		RoomInfoCommand::ListJoinedMembers {
-			room_id,
-		} => list_joined_members(body, room_id).await,
-		RoomInfoCommand::ViewRoomTopic {
-			room_id,
-		} => view_room_topic(body, room_id).await,
-	}
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
+pub(crate) enum RoomInfoCommand {
+	/// - List joined members in a room
+	ListJoinedMembers {
+		room_id: Box<RoomId>,
+	},
+
+	/// - Displays room topic
+	///
+	/// Room topics can be huge, so this is in its
+	/// own separate command
+	ViewRoomTopic {
+		room_id: Box<RoomId>,
+	},
 }
 
-async fn list_joined_members(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
-	let room_name = services()
+#[admin_command]
+async fn list_joined_members(&self, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+	let room_name = self
+		.services
 		.rooms
 		.state_accessor
 		.get_name(&room_id)
@@ -24,7 +32,8 @@ async fn list_joined_members(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<R
 		.flatten()
 		.unwrap_or_else(|| room_id.to_string());
 
-	let members = services()
+	let members = self
+		.services
 		.rooms
 		.state_cache
 		.room_members(&room_id)
@@ -35,7 +44,7 @@ async fn list_joined_members(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<R
 		.map(|user_id| {
 			(
 				user_id.clone(),
-				services()
+				self.services
 					.users
 					.displayname(&user_id)
 					.unwrap_or(None)
@@ -58,8 +67,14 @@ async fn list_joined_members(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<R
 	Ok(RoomMessageEventContent::notice_markdown(output_plain))
 }
 
-async fn view_room_topic(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
-	let Some(room_topic) = services().rooms.state_accessor.get_room_topic(&room_id)? else {
+#[admin_command]
+async fn view_room_topic(&self, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+	let Some(room_topic) = self
+		.services
+		.rooms
+		.state_accessor
+		.get_room_topic(&room_id)?
+	else {
 		return Ok(RoomMessageEventContent::text_plain("Room does not have a room topic set."));
 	};
 

src/admin/room/mod.rs

@@ -1,20 +1,23 @@
-mod room_alias_commands;
-mod room_commands;
-mod room_directory_commands;
-mod room_info_commands;
-mod room_moderation_commands;
+mod alias;
+mod commands;
+mod directory;
+mod info;
+mod moderation;
 
 use clap::Subcommand;
 use conduit::Result;
-use ruma::{events::room::message::RoomMessageEventContent, RoomId, RoomOrAliasId};
 
-use self::room_commands::list;
+use self::{
+	alias::RoomAliasCommand, directory::RoomDirectoryCommand, info::RoomInfoCommand, moderation::RoomModerationCommand,
+};
+use crate::admin_command_dispatch;
 
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
 pub(super) enum RoomCommand {
 	/// - List all rooms the server knows about
-	List {
+	#[clap(alias = "list")]
+	ListRooms {
 		page: Option<usize>,
 
 		/// Excludes rooms that we have federation disabled with
@@ -42,153 +45,3 @@ pub(super) enum RoomCommand {
 	/// - Manage the room directory
 	Directory(RoomDirectoryCommand),
 }
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-pub(super) enum RoomInfoCommand {
-	/// - List joined members in a room
-	ListJoinedMembers {
-		room_id: Box<RoomId>,
-	},
-
-	/// - Displays room topic
-	///
-	/// Room topics can be huge, so this is in its
-	/// own separate command
-	ViewRoomTopic {
-		room_id: Box<RoomId>,
-	},
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-pub(super) enum RoomAliasCommand {
-	/// - Make an alias point to a room.
-	Set {
-		#[arg(short, long)]
-		/// Set the alias even if a room is already using it
-		force: bool,
-
-		/// The room id to set the alias on
-		room_id: Box<RoomId>,
-
-		/// The alias localpart to use (`alias`, not `#alias:servername.tld`)
-		room_alias_localpart: String,
-	},
-
-	/// - Remove a local alias
-	Remove {
-		/// The alias localpart to remove (`alias`, not `#alias:servername.tld`)
-		room_alias_localpart: String,
-	},
-
-	/// - Show which room is using an alias
-	Which {
-		/// The alias localpart to look up (`alias`, not
-		/// `#alias:servername.tld`)
-		room_alias_localpart: String,
-	},
-
-	/// - List aliases currently being used
-	List {
-		/// If set, only list the aliases for this room
-		room_id: Option<Box<RoomId>>,
-	},
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-pub(super) enum RoomDirectoryCommand {
-	/// - Publish a room to the room directory
-	Publish {
-		/// The room id of the room to publish
-		room_id: Box<RoomId>,
-	},
-
-	/// - Unpublish a room to the room directory
-	Unpublish {
-		/// The room id of the room to unpublish
-		room_id: Box<RoomId>,
-	},
-
-	/// - List rooms that are published
-	List {
-		page: Option<usize>,
-	},
-}
-
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
-pub(super) enum RoomModerationCommand {
-	/// - Bans a room from local users joining and evicts all our local users
-	///   from the room. Also blocks any invites (local and remote) for the
-	///   banned room.
-	///
-	/// Server admins (users in the conduwuit admin room) will not be evicted
-	/// and server admins can still join the room. To evict admins too, use
-	/// --force (also ignores errors) To disable incoming federation of the
-	/// room, use --disable-federation
-	BanRoom {
-		#[arg(short, long)]
-		/// Evicts admins out of the room and ignores any potential errors when
-		/// making our local users leave the room
-		force: bool,
-
-		#[arg(long)]
-		/// Disables incoming federation of the room after banning and evicting
-		/// users
-		disable_federation: bool,
-
-		/// The room in the format of `!roomid:example.com` or a room alias in
-		/// the format of `#roomalias:example.com`
-		room: Box<RoomOrAliasId>,
-	},
-
-	/// - Bans a list of rooms (room IDs and room aliases) from a newline
-	///   delimited codeblock similar to `user deactivate-all`
-	BanListOfRooms {
-		#[arg(short, long)]
-		/// Evicts admins out of the room and ignores any potential errors when
-		/// making our local users leave the room
-		force: bool,
-
-		#[arg(long)]
-		/// Disables incoming federation of the room after banning and evicting
-		/// users
-		disable_federation: bool,
-	},
-
-	/// - Unbans a room to allow local users to join again
-	///
-	/// To re-enable incoming federation of the room, use --enable-federation
-	UnbanRoom {
-		#[arg(long)]
-		/// Enables incoming federation of the room after unbanning
-		enable_federation: bool,
-
-		/// The room in the format of `!roomid:example.com` or a room alias in
-		/// the format of `#roomalias:example.com`
-		room: Box<RoomOrAliasId>,
-	},
-
-	/// - List of all rooms we have banned
-	ListBannedRooms,
-}
-
-pub(super) async fn process(command: RoomCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	Ok(match command {
-		RoomCommand::Info(command) => room_info_commands::process(command, body).await?,
-
-		RoomCommand::Alias(command) => room_alias_commands::process(command, body).await?,
-
-		RoomCommand::Directory(command) => room_directory_commands::process(command, body).await?,
-
-		RoomCommand::Moderation(command) => room_moderation_commands::process(command, body).await?,
-
-		RoomCommand::List {
-			page,
-			exclude_disabled,
-			exclude_banned,
-		} => list(body, page, exclude_disabled, exclude_banned).await?,
-	})
-}

src/admin/room/moderation.rs

@@ -1,37 +1,77 @@
 use api::client::leave_room;
+use clap::Subcommand;
+use conduit::{debug, error, info, warn, Result};
 use ruma::{events::room::message::RoomMessageEventContent, OwnedRoomId, RoomAliasId, RoomId, RoomOrAliasId};
-use tracing::{debug, error, info, warn};
 
-use super::{super::Service, RoomModerationCommand};
-use crate::{get_room_info, services, user_is_local, Result};
+use crate::{admin_command, admin_command_dispatch, get_room_info};
 
-pub(super) async fn process(command: RoomModerationCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	match command {
-		RoomModerationCommand::BanRoom {
-			force,
-			room,
-			disable_federation,
-		} => ban_room(body, force, room, disable_federation).await,
-		RoomModerationCommand::BanListOfRooms {
-			force,
-			disable_federation,
-		} => ban_list_of_rooms(body, force, disable_federation).await,
-		RoomModerationCommand::UnbanRoom {
-			room,
-			enable_federation,
-		} => unban_room(body, room, enable_federation).await,
-		RoomModerationCommand::ListBannedRooms => list_banned_rooms(body).await,
-	}
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
+pub(crate) enum RoomModerationCommand {
+	/// - Bans a room from local users joining and evicts all our local users
+	///   from the room. Also blocks any invites (local and remote) for the
+	///   banned room.
+	///
+	/// Server admins (users in the conduwuit admin room) will not be evicted
+	/// and server admins can still join the room. To evict admins too, use
+	/// --force (also ignores errors) To disable incoming federation of the
+	/// room, use --disable-federation
+	BanRoom {
+		#[arg(short, long)]
+		/// Evicts admins out of the room and ignores any potential errors when
+		/// making our local users leave the room
+		force: bool,
+
+		#[arg(long)]
+		/// Disables incoming federation of the room after banning and evicting
+		/// users
+		disable_federation: bool,
+
+		/// The room in the format of `!roomid:example.com` or a room alias in
+		/// the format of `#roomalias:example.com`
+		room: Box<RoomOrAliasId>,
+	},
+
+	/// - Bans a list of rooms (room IDs and room aliases) from a newline
+	///   delimited codeblock similar to `user deactivate-all`
+	BanListOfRooms {
+		#[arg(short, long)]
+		/// Evicts admins out of the room and ignores any potential errors when
+		/// making our local users leave the room
+		force: bool,
+
+		#[arg(long)]
+		/// Disables incoming federation of the room after banning and evicting
+		/// users
+		disable_federation: bool,
+	},
+
+	/// - Unbans a room to allow local users to join again
+	///
+	/// To re-enable incoming federation of the room, use --enable-federation
+	UnbanRoom {
+		#[arg(long)]
+		/// Enables incoming federation of the room after unbanning
+		enable_federation: bool,
+
+		/// The room in the format of `!roomid:example.com` or a room alias in
+		/// the format of `#roomalias:example.com`
+		room: Box<RoomOrAliasId>,
+	},
+
+	/// - List of all rooms we have banned
+	ListBannedRooms,
 }
 
+#[admin_command]
 async fn ban_room(
-	_body: Vec<&str>, force: bool, room: Box<RoomOrAliasId>, disable_federation: bool,
+	&self, force: bool, disable_federation: bool, room: Box<RoomOrAliasId>,
 ) -> Result<RoomMessageEventContent> {
 	debug!("Got room alias or ID: {}", room);
 
-	let admin_room_alias = &services().globals.admin_alias;
+	let admin_room_alias = &self.services.globals.admin_alias;
 
-	if let Some(admin_room_id) = Service::get_admin_room()? {
+	if let Some(admin_room_id) = self.services.admin.get_admin_room()? {
 		if room.to_string().eq(&admin_room_id) || room.to_string().eq(admin_room_alias) {
 			return Ok(RoomMessageEventContent::text_plain("Not allowed to ban the admin room."));
 		}
@@ -50,7 +90,7 @@ async fn ban_room(
 
 		debug!("Room specified is a room ID, banning room ID");
 
-		services().rooms.metadata.ban_room(&room_id, true)?;
+		self.services.rooms.metadata.ban_room(&room_id, true)?;
 
 		room_id
 	} else if room.is_room_alias_id() {
@@ -69,12 +109,13 @@ async fn ban_room(
 			 get_alias_helper to fetch room ID remotely"
 		);
 
-		let room_id = if let Some(room_id) = services().rooms.alias.resolve_local_alias(&room_alias)? {
+		let room_id = if let Some(room_id) = self.services.rooms.alias.resolve_local_alias(&room_alias)? {
 			room_id
 		} else {
 			debug!("We don't have this room alias to a room ID locally, attempting to fetch room ID over federation");
 
-			match services()
+			match self
+				.services
 				.rooms
 				.alias
 				.resolve_alias(&room_alias, None)
@@ -92,7 +133,7 @@ async fn ban_room(
 			}
 		};
 
-		services().rooms.metadata.ban_room(&room_id, true)?;
+		self.services.rooms.metadata.ban_room(&room_id, true)?;
 
 		room_id
 	} else {
@@ -104,20 +145,21 @@ async fn ban_room(
 
 	debug!("Making all users leave the room {}", &room);
 	if force {
-		for local_user in services()
+		for local_user in self
+			.services
 			.rooms
 			.state_cache
 			.room_members(&room_id)
 			.filter_map(|user| {
 				user.ok().filter(|local_user| {
-					user_is_local(local_user)
+					self.services.globals.user_is_local(local_user)
 								// additional wrapped check here is to avoid adding remote users
 								// who are in the admin room to the list of local users (would
 								// fail auth check)
-								&& (user_is_local(local_user)
+								&& (self.services.globals.user_is_local(local_user)
 									// since this is a force operation, assume user is an admin
 									// if somehow this fails
-									&& services()
+									&& self.services
 										.users
 										.is_admin(local_user)
 										.unwrap_or(true))
@@ -128,30 +170,31 @@ async fn ban_room(
 				&local_user, &room_id
 			);
 
-			if let Err(e) = leave_room(&local_user, &room_id, None).await {
+			if let Err(e) = leave_room(self.services, &local_user, &room_id, None).await {
 				warn!(%e, "Failed to leave room");
 			}
 		}
 	} else {
-		for local_user in services()
+		for local_user in self
+			.services
 			.rooms
 			.state_cache
 			.room_members(&room_id)
 			.filter_map(|user| {
 				user.ok().filter(|local_user| {
-					local_user.server_name() == services().globals.server_name()
+					local_user.server_name() == self.services.globals.server_name()
 								// additional wrapped check here is to avoid adding remote users
 								// who are in the admin room to the list of local users (would fail auth check)
 								&& (local_user.server_name()
-									== services().globals.server_name()
-									&& !services()
+									== self.services.globals.server_name()
+									&& !self.services
 										.users
 										.is_admin(local_user)
 										.unwrap_or(false))
 				})
 			}) {
 			debug!("Attempting leave for user {} in room {}", &local_user, &room_id);
-			if let Err(e) = leave_room(&local_user, &room_id, None).await {
+			if let Err(e) = leave_room(self.services, &local_user, &room_id, None).await {
 				error!(
 					"Error attempting to make local user {} leave room {} during room banning: {}",
 					&local_user, &room_id, e
@@ -166,7 +209,7 @@ async fn ban_room(
 	}
 
 	if disable_federation {
-		services().rooms.metadata.disable_room(&room_id, true)?;
+		self.services.rooms.metadata.disable_room(&room_id, true)?;
 		return Ok(RoomMessageEventContent::text_plain(
 			"Room banned, removed all our local users, and disabled incoming federation with room.",
 		));
@@ -178,19 +221,22 @@ async fn ban_room(
 	))
 }
 
-async fn ban_list_of_rooms(body: Vec<&str>, force: bool, disable_federation: bool) -> Result<RoomMessageEventContent> {
-	if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
+#[admin_command]
+async fn ban_list_of_rooms(&self, force: bool, disable_federation: bool) -> Result<RoomMessageEventContent> {
+	if self.body.len() < 2 || !self.body[0].trim().starts_with("```") || self.body.last().unwrap_or(&"").trim() != "```"
+	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"Expected code block in command body. Add --help for details.",
 		));
 	}
 
-	let rooms_s = body
-		.clone()
-		.drain(1..body.len().saturating_sub(1))
+	let rooms_s = self
+		.body
+		.to_vec()
+		.drain(1..self.body.len().saturating_sub(1))
 		.collect::<Vec<_>>();
 
-	let admin_room_alias = &services().globals.admin_alias;
+	let admin_room_alias = &self.services.globals.admin_alias;
 
 	let mut room_ban_count: usize = 0;
 	let mut room_ids: Vec<OwnedRoomId> = Vec::new();
@@ -198,7 +244,7 @@ async fn ban_list_of_rooms(body: Vec<&str>, force: bool, disable_federation: boo
 	for &room in &rooms_s {
 		match <&RoomOrAliasId>::try_from(room) {
 			Ok(room_alias_or_id) => {
-				if let Some(admin_room_id) = Service::get_admin_room()? {
+				if let Some(admin_room_id) = self.services.admin.get_admin_room()? {
 					if room.to_owned().eq(&admin_room_id) || room.to_owned().eq(admin_room_alias) {
 						info!("User specified admin room in bulk ban list, ignoring");
 						continue;
@@ -231,7 +277,7 @@ async fn ban_list_of_rooms(body: Vec<&str>, force: bool, disable_federation: boo
 					match RoomAliasId::parse(room_alias_or_id) {
 						Ok(room_alias) => {
 							let room_id =
-								if let Some(room_id) = services().rooms.alias.resolve_local_alias(&room_alias)? {
+								if let Some(room_id) = self.services.rooms.alias.resolve_local_alias(&room_alias)? {
 									room_id
 								} else {
 									debug!(
@@ -239,7 +285,8 @@ async fn ban_list_of_rooms(body: Vec<&str>, force: bool, disable_federation: boo
 										 ID over federation"
 									);
 
-									match services()
+									match self
+										.services
 										.rooms
 										.alias
 										.resolve_alias(&room_alias, None)
@@ -303,28 +350,35 @@ async fn ban_list_of_rooms(body: Vec<&str>, force: bool, disable_federation: boo
 	}
 
 	for room_id in room_ids {
-		if services().rooms.metadata.ban_room(&room_id, true).is_ok() {
+		if self
+			.services
+			.rooms
+			.metadata
+			.ban_room(&room_id, true)
+			.is_ok()
+		{
 			debug!("Banned {room_id} successfully");
 			room_ban_count = room_ban_count.saturating_add(1);
 		}
 
 		debug!("Making all users leave the room {}", &room_id);
 		if force {
-			for local_user in services()
+			for local_user in self
+				.services
 				.rooms
 				.state_cache
 				.room_members(&room_id)
 				.filter_map(|user| {
 					user.ok().filter(|local_user| {
-						local_user.server_name() == services().globals.server_name()
+						local_user.server_name() == self.services.globals.server_name()
 										// additional wrapped check here is to avoid adding remote
 										// users who are in the admin room to the list of local
 										// users (would fail auth check)
 										&& (local_user.server_name()
-											== services().globals.server_name()
+											== self.services.globals.server_name()
 											// since this is a force operation, assume user is an
 											// admin if somehow this fails
-											&& services()
+											&& self.services
 												.users
 												.is_admin(local_user)
 												.unwrap_or(true))
@@ -334,31 +388,32 @@ async fn ban_list_of_rooms(body: Vec<&str>, force: bool, disable_federation: boo
 					"Attempting leave for user {} in room {} (forced, ignoring all errors, evicting admins too)",
 					&local_user, room_id
 				);
-				if let Err(e) = leave_room(&local_user, &room_id, None).await {
+				if let Err(e) = leave_room(self.services, &local_user, &room_id, None).await {
 					warn!(%e, "Failed to leave room");
 				}
 			}
 		} else {
-			for local_user in services()
+			for local_user in self
+				.services
 				.rooms
 				.state_cache
 				.room_members(&room_id)
 				.filter_map(|user| {
 					user.ok().filter(|local_user| {
-						local_user.server_name() == services().globals.server_name()
+						local_user.server_name() == self.services.globals.server_name()
 										// additional wrapped check here is to avoid adding remote
 										// users who are in the admin room to the list of local
 										// users (would fail auth check)
 										&& (local_user.server_name()
-											== services().globals.server_name()
-											&& !services()
+											== self.services.globals.server_name()
+											&& !self.services
 												.users
 												.is_admin(local_user)
 												.unwrap_or(false))
 					})
 				}) {
 				debug!("Attempting leave for user {} in room {}", &local_user, &room_id);
-				if let Err(e) = leave_room(&local_user, &room_id, None).await {
+				if let Err(e) = leave_room(self.services, &local_user, &room_id, None).await {
 					error!(
 						"Error attempting to make local user {} leave room {} during bulk room banning: {}",
 						&local_user, &room_id, e
@@ -374,7 +429,7 @@ async fn ban_list_of_rooms(body: Vec<&str>, force: bool, disable_federation: boo
 		}
 
 		if disable_federation {
-			services().rooms.metadata.disable_room(&room_id, true)?;
+			self.services.rooms.metadata.disable_room(&room_id, true)?;
 		}
 	}
 
@@ -390,9 +445,8 @@ async fn ban_list_of_rooms(body: Vec<&str>, force: bool, disable_federation: boo
 	}
 }
 
-async fn unban_room(
-	_body: Vec<&str>, room: Box<RoomOrAliasId>, enable_federation: bool,
-) -> Result<RoomMessageEventContent> {
+#[admin_command]
+async fn unban_room(&self, enable_federation: bool, room: Box<RoomOrAliasId>) -> Result<RoomMessageEventContent> {
 	let room_id = if room.is_room_id() {
 		let room_id = match RoomId::parse(&room) {
 			Ok(room_id) => room_id,
@@ -406,7 +460,7 @@ async fn unban_room(
 
 		debug!("Room specified is a room ID, unbanning room ID");
 
-		services().rooms.metadata.ban_room(&room_id, false)?;
+		self.services.rooms.metadata.ban_room(&room_id, false)?;
 
 		room_id
 	} else if room.is_room_alias_id() {
@@ -425,12 +479,13 @@ async fn unban_room(
 			 get_alias_helper to fetch room ID remotely"
 		);
 
-		let room_id = if let Some(room_id) = services().rooms.alias.resolve_local_alias(&room_alias)? {
+		let room_id = if let Some(room_id) = self.services.rooms.alias.resolve_local_alias(&room_alias)? {
 			room_id
 		} else {
 			debug!("We don't have this room alias to a room ID locally, attempting to fetch room ID over federation");
 
-			match services()
+			match self
+				.services
 				.rooms
 				.alias
 				.resolve_alias(&room_alias, None)
@@ -448,7 +503,7 @@ async fn unban_room(
 			}
 		};
 
-		services().rooms.metadata.ban_room(&room_id, false)?;
+		self.services.rooms.metadata.ban_room(&room_id, false)?;
 
 		room_id
 	} else {
@@ -459,7 +514,7 @@ async fn unban_room(
 	};
 
 	if enable_federation {
-		services().rooms.metadata.disable_room(&room_id, false)?;
+		self.services.rooms.metadata.disable_room(&room_id, false)?;
 		return Ok(RoomMessageEventContent::text_plain("Room unbanned."));
 	}
 
@@ -469,8 +524,10 @@ async fn unban_room(
 	))
 }
 
-async fn list_banned_rooms(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let rooms = services()
+#[admin_command]
+async fn list_banned_rooms(&self) -> Result<RoomMessageEventContent> {
+	let rooms = self
+		.services
 		.rooms
 		.metadata
 		.list_banned_rooms()
@@ -484,7 +541,7 @@ async fn list_banned_rooms(_body: Vec<&str>) -> Result<RoomMessageEventContent>
 
 			let mut rooms = room_ids
 				.into_iter()
-				.map(|room_id| get_room_info(&room_id))
+				.map(|room_id| get_room_info(self.services, &room_id))
 				.collect::<Vec<_>>();
 			rooms.sort_by_key(|r| r.1);
 			rooms.reverse();

src/admin/server/commands.rs

@@ -1,10 +1,14 @@
-use conduit::{utils::time, warn, Err, Result};
+use std::{fmt::Write, sync::Arc};
+
+use conduit::{info, utils::time, warn, Err, Result};
 use ruma::events::room::message::RoomMessageEventContent;
 
-use crate::services;
+use crate::admin_command;
 
-pub(super) async fn uptime(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let elapsed = services()
+#[admin_command]
+pub(super) async fn uptime(&self) -> Result<RoomMessageEventContent> {
+	let elapsed = self
+		.services
 		.server
 		.started
 		.elapsed()
@@ -14,14 +18,58 @@ pub(super) async fn uptime(_body: Vec<&str>) -> Result<RoomMessageEventContent>
 	Ok(RoomMessageEventContent::notice_plain(format!("{result}.")))
 }
 
-pub(super) async fn show_config(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn show_config(&self) -> Result<RoomMessageEventContent> {
 	// Construct and send the response
-	Ok(RoomMessageEventContent::text_plain(format!("{}", services().globals.config)))
+	Ok(RoomMessageEventContent::text_plain(format!("{}", self.services.globals.config)))
 }
 
-pub(super) async fn memory_usage(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let services_usage = services().memory_usage().await?;
-	let database_usage = services().db.db.memory_usage()?;
+#[admin_command]
+pub(super) async fn list_features(
+	&self, available: bool, enabled: bool, comma: bool,
+) -> Result<RoomMessageEventContent> {
+	let delim = if comma {
+		","
+	} else {
+		" "
+	};
+	if enabled && !available {
+		let features = info::rustc::features().join(delim);
+		let out = format!("```\n{features}\n```");
+		return Ok(RoomMessageEventContent::text_markdown(out));
+	}
+
+	if available && !enabled {
+		let features = info::cargo::features().join(delim);
+		let out = format!("```\n{features}\n```");
+		return Ok(RoomMessageEventContent::text_markdown(out));
+	}
+
+	let mut features = String::new();
+	let enabled = info::rustc::features();
+	let available = info::cargo::features();
+	for feature in available {
+		let active = enabled.contains(&feature.as_str());
+		let emoji = if active {
+			"✅"
+		} else {
+			"❌"
+		};
+		let remark = if active {
+			"[enabled]"
+		} else {
+			""
+		};
+		writeln!(features, "{emoji} {feature} {remark}")?;
+	}
+
+	Ok(RoomMessageEventContent::text_markdown(features))
+}
+
+#[admin_command]
+pub(super) async fn memory_usage(&self) -> Result<RoomMessageEventContent> {
+	let services_usage = self.services.memory_usage().await?;
+	let database_usage = self.services.db.db.memory_usage()?;
 	let allocator_usage = conduit::alloc::memory_usage().map_or(String::new(), |s| format!("\nAllocator:\n{s}"));
 
 	Ok(RoomMessageEventContent::text_plain(format!(
@@ -29,14 +77,16 @@ pub(super) async fn memory_usage(_body: Vec<&str>) -> Result<RoomMessageEventCon
 	)))
 }
 
-pub(super) async fn clear_caches(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	services().clear_cache().await;
+#[admin_command]
+pub(super) async fn clear_caches(&self) -> Result<RoomMessageEventContent> {
+	self.services.clear_cache().await;
 
 	Ok(RoomMessageEventContent::text_plain("Done."))
 }
 
-pub(super) async fn list_backups(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let result = services().globals.db.backup_list()?;
+#[admin_command]
+pub(super) async fn list_backups(&self) -> Result<RoomMessageEventContent> {
+	let result = self.services.globals.db.backup_list()?;
 
 	if result.is_empty() {
 		Ok(RoomMessageEventContent::text_plain("No backups found."))
@@ -45,46 +95,51 @@ pub(super) async fn list_backups(_body: Vec<&str>) -> Result<RoomMessageEventCon
 	}
 }
 
-pub(super) async fn backup_database(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let mut result = services()
+#[admin_command]
+pub(super) async fn backup_database(&self) -> Result<RoomMessageEventContent> {
+	let globals = Arc::clone(&self.services.globals);
+	let mut result = self
+		.services
 		.server
 		.runtime()
-		.spawn_blocking(move || match services().globals.db.backup() {
+		.spawn_blocking(move || match globals.db.backup() {
 			Ok(()) => String::new(),
 			Err(e) => (*e).to_string(),
 		})
-		.await
-		.unwrap();
+		.await?;
 
 	if result.is_empty() {
-		result = services().globals.db.backup_list()?;
+		result = self.services.globals.db.backup_list()?;
 	}
 
-	Ok(RoomMessageEventContent::text_plain(&result))
-}
-
-pub(super) async fn list_database_files(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	let result = services().globals.db.file_list()?;
-
 	Ok(RoomMessageEventContent::notice_markdown(result))
 }
 
-pub(super) async fn admin_notice(_body: Vec<&str>, message: Vec<String>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn list_database_files(&self) -> Result<RoomMessageEventContent> {
+	let result = self.services.globals.db.file_list()?;
+
+	Ok(RoomMessageEventContent::notice_markdown(result))
+}
+
+#[admin_command]
+pub(super) async fn admin_notice(&self, message: Vec<String>) -> Result<RoomMessageEventContent> {
 	let message = message.join(" ");
-	services().admin.send_text(&message).await;
+	self.services.admin.send_text(&message).await;
 
 	Ok(RoomMessageEventContent::notice_plain("Notice was sent to #admins"))
 }
 
-#[cfg(conduit_mods)]
-pub(super) async fn reload(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	services().server.reload()?;
+#[admin_command]
+pub(super) async fn reload_mods(&self) -> Result<RoomMessageEventContent> {
+	self.services.server.reload()?;
 
 	Ok(RoomMessageEventContent::notice_plain("Reloading server..."))
 }
 
+#[admin_command]
 #[cfg(unix)]
-pub(super) async fn restart(_body: Vec<&str>, force: bool) -> Result<RoomMessageEventContent> {
+pub(super) async fn restart(&self, force: bool) -> Result<RoomMessageEventContent> {
 	use conduit::utils::sys::current_exe_deleted;
 
 	if !force && current_exe_deleted() {
@@ -94,14 +149,15 @@ pub(super) async fn restart(_body: Vec<&str>, force: bool) -> Result<RoomMessage
 		);
 	}
 
-	services().server.restart()?;
+	self.services.server.restart()?;
 
 	Ok(RoomMessageEventContent::notice_plain("Restarting server..."))
 }
 
-pub(super) async fn shutdown(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn shutdown(&self) -> Result<RoomMessageEventContent> {
 	warn!("shutdown command");
-	services().server.shutdown()?;
+	self.services.server.shutdown()?;
 
 	Ok(RoomMessageEventContent::notice_plain("Shutting down server..."))
 }

src/admin/server/mod.rs

@@ -2,12 +2,11 @@ mod commands;
 
 use clap::Subcommand;
 use conduit::Result;
-use ruma::events::room::message::RoomMessageEventContent;
 
-use self::commands::*;
+use crate::admin_command_dispatch;
 
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
 pub(super) enum ServerCommand {
 	/// - Time elapsed since startup
 	Uptime,
@@ -15,6 +14,18 @@ pub(super) enum ServerCommand {
 	/// - Show configuration values
 	ShowConfig,
 
+	/// - List the features built into the server
+	ListFeatures {
+		#[arg(short, long)]
+		available: bool,
+
+		#[arg(short, long)]
+		enabled: bool,
+
+		#[arg(short, long)]
+		comma: bool,
+	},
+
 	/// - Print database memory usage statistics
 	MemoryUsage,
 
@@ -36,9 +47,9 @@ pub(super) enum ServerCommand {
 		message: Vec<String>,
 	},
 
-	#[cfg(conduit_mods)]
 	/// - Hot-reload the server
-	Reload,
+	#[clap(alias = "reload")]
+	ReloadMods,
 
 	#[cfg(unix)]
 	/// - Restart the server
@@ -50,25 +61,3 @@ pub(super) enum ServerCommand {
 	/// - Shutdown the server
 	Shutdown,
 }
-
-pub(super) async fn process(command: ServerCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	Ok(match command {
-		ServerCommand::Uptime => uptime(body).await?,
-		ServerCommand::ShowConfig => show_config(body).await?,
-		ServerCommand::MemoryUsage => memory_usage(body).await?,
-		ServerCommand::ClearCaches => clear_caches(body).await?,
-		ServerCommand::ListBackups => list_backups(body).await?,
-		ServerCommand::BackupDatabase => backup_database(body).await?,
-		ServerCommand::ListDatabaseFiles => list_database_files(body).await?,
-		ServerCommand::AdminNotice {
-			message,
-		} => admin_notice(body, message).await?,
-		#[cfg(conduit_mods)]
-		ServerCommand::Reload => reload(body).await?,
-		#[cfg(unix)]
-		ServerCommand::Restart {
-			force,
-		} => restart(body, force).await?,
-		ServerCommand::Shutdown => shutdown(body).await?,
-	})
-}

src/admin/tests.rs

@@ -12,7 +12,7 @@ fn get_help_subcommand() { get_help_inner("help"); }
 fn get_help_inner(input: &str) {
 	use clap::Parser;
 
-	use crate::handler::AdminCommand;
+	use crate::admin::AdminCommand;
 
 	let Err(error) = AdminCommand::try_parse_from(["argv[0] doesn't matter", input]) else {
 		panic!("no error!");

src/admin/user/commands.rs

@@ -1,7 +1,7 @@
 use std::{collections::BTreeMap, fmt::Write as _};
 
 use api::client::{join_room_by_id_helper, leave_all_rooms, update_avatar_url, update_displayname};
-use conduit::{utils, Result};
+use conduit::{error, info, utils, warn, Result};
 use ruma::{
 	events::{
 		room::message::RoomMessageEventContent,
@@ -10,17 +10,17 @@ use ruma::{
 	},
 	OwnedRoomId, OwnedRoomOrAliasId, OwnedUserId, RoomId,
 };
-use tracing::{error, info, warn};
 
 use crate::{
-	escape_html, get_room_info, services,
+	admin_command, escape_html, get_room_info,
 	utils::{parse_active_local_user_id, parse_local_user_id},
 };
 
 const AUTO_GEN_PASSWORD_LENGTH: usize = 25;
 
-pub(super) async fn list(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	match services().users.list_local_users() {
+#[admin_command]
+pub(super) async fn list_users(&self) -> Result<RoomMessageEventContent> {
+	match self.services.users.list_local_users() {
 		Ok(users) => {
 			let mut plain_msg = format!("Found {} local user account(s):\n```\n", users.len());
 			plain_msg += users.join("\n").as_str();
@@ -32,13 +32,12 @@ pub(super) async fn list(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	}
 }
 
-pub(super) async fn create(
-	_body: Vec<&str>, username: String, password: Option<String>,
-) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn create_user(&self, username: String, password: Option<String>) -> Result<RoomMessageEventContent> {
 	// Validate user id
-	let user_id = parse_local_user_id(&username)?;
+	let user_id = parse_local_user_id(self.services, &username)?;
 
-	if services().users.exists(&user_id)? {
+	if self.services.users.exists(&user_id)? {
 		return Ok(RoomMessageEventContent::text_plain(format!("Userid {user_id} already exists")));
 	}
 
@@ -51,30 +50,33 @@ pub(super) async fn create(
 	let password = password.unwrap_or_else(|| utils::random_string(AUTO_GEN_PASSWORD_LENGTH));
 
 	// Create user
-	services().users.create(&user_id, Some(password.as_str()))?;
+	self.services
+		.users
+		.create(&user_id, Some(password.as_str()))?;
 
 	// Default to pretty displayname
 	let mut displayname = user_id.localpart().to_owned();
 
 	// If `new_user_displayname_suffix` is set, registration will push whatever
 	// content is set to the user's display name with a space before it
-	if !services()
+	if !self
+		.services
 		.globals
 		.config
 		.new_user_displayname_suffix
 		.is_empty()
 	{
-		write!(displayname, " {}", services().globals.config.new_user_displayname_suffix)
+		write!(displayname, " {}", self.services.globals.config.new_user_displayname_suffix)
 			.expect("should be able to write to string buffer");
 	}
 
-	services()
+	self.services
 		.users
 		.set_displayname(&user_id, Some(displayname))
 		.await?;
 
 	// Initial account data
-	services().account_data.update(
+	self.services.account_data.update(
 		None,
 		&user_id,
 		ruma::events::GlobalAccountDataEventType::PushRules
@@ -88,12 +90,13 @@ pub(super) async fn create(
 		.expect("to json value always works"),
 	)?;
 
-	if !services().globals.config.auto_join_rooms.is_empty() {
-		for room in &services().globals.config.auto_join_rooms {
-			if !services()
+	if !self.services.globals.config.auto_join_rooms.is_empty() {
+		for room in &self.services.globals.config.auto_join_rooms {
+			if !self
+				.services
 				.rooms
 				.state_cache
-				.server_in_room(services().globals.server_name(), room)?
+				.server_in_room(self.services.globals.server_name(), room)?
 			{
 				warn!("Skipping room {room} to automatically join as we have never joined before.");
 				continue;
@@ -101,10 +104,11 @@ pub(super) async fn create(
 
 			if let Some(room_id_server_name) = room.server_name() {
 				match join_room_by_id_helper(
+					self.services,
 					&user_id,
 					room,
 					Some("Automatically joining this room upon registration".to_owned()),
-					&[room_id_server_name.to_owned(), services().globals.server_name().to_owned()],
+					&[room_id_server_name.to_owned(), self.services.globals.server_name().to_owned()],
 					None,
 				)
 				.await
@@ -129,38 +133,38 @@ pub(super) async fn create(
 	)))
 }
 
-pub(super) async fn deactivate(
-	_body: Vec<&str>, no_leave_rooms: bool, user_id: String,
-) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn deactivate(&self, no_leave_rooms: bool, user_id: String) -> Result<RoomMessageEventContent> {
 	// Validate user id
-	let user_id = parse_local_user_id(&user_id)?;
+	let user_id = parse_local_user_id(self.services, &user_id)?;
 
 	// don't deactivate the server service account
-	if user_id == services().globals.server_user {
+	if user_id == self.services.globals.server_user {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Not allowed to deactivate the server service account.",
 		));
 	}
 
-	services().users.deactivate_account(&user_id)?;
+	self.services.users.deactivate_account(&user_id)?;
 
 	if !no_leave_rooms {
-		services()
+		self.services
 			.admin
 			.send_message(RoomMessageEventContent::text_plain(format!(
 				"Making {user_id} leave all rooms after deactivation..."
 			)))
 			.await;
 
-		let all_joined_rooms: Vec<OwnedRoomId> = services()
+		let all_joined_rooms: Vec<OwnedRoomId> = self
+			.services
 			.rooms
 			.state_cache
 			.rooms_joined(&user_id)
 			.filter_map(Result::ok)
 			.collect();
-		update_displayname(user_id.clone(), None, all_joined_rooms.clone()).await?;
-		update_avatar_url(user_id.clone(), None, None, all_joined_rooms).await?;
-		leave_all_rooms(&user_id).await;
+		update_displayname(self.services, user_id.clone(), None, all_joined_rooms.clone()).await?;
+		update_avatar_url(self.services, user_id.clone(), None, None, all_joined_rooms).await?;
+		leave_all_rooms(self.services, &user_id).await;
 	}
 
 	Ok(RoomMessageEventContent::text_plain(format!(
@@ -168,10 +172,11 @@ pub(super) async fn deactivate(
 	)))
 }
 
-pub(super) async fn reset_password(_body: Vec<&str>, username: String) -> Result<RoomMessageEventContent> {
-	let user_id = parse_local_user_id(&username)?;
+#[admin_command]
+pub(super) async fn reset_password(&self, username: String) -> Result<RoomMessageEventContent> {
+	let user_id = parse_local_user_id(self.services, &username)?;
 
-	if user_id == services().globals.server_user {
+	if user_id == self.services.globals.server_user {
 		return Ok(RoomMessageEventContent::text_plain(
 			"Not allowed to set the password for the server account. Please use the emergency password config option.",
 		));
@@ -179,7 +184,8 @@ pub(super) async fn reset_password(_body: Vec<&str>, username: String) -> Result
 
 	let new_password = utils::random_string(AUTO_GEN_PASSWORD_LENGTH);
 
-	match services()
+	match self
+		.services
 		.users
 		.set_password(&user_id, Some(new_password.as_str()))
 	{
@@ -192,28 +198,29 @@ pub(super) async fn reset_password(_body: Vec<&str>, username: String) -> Result
 	}
 }
 
-pub(super) async fn deactivate_all(
-	body: Vec<&str>, no_leave_rooms: bool, force: bool,
-) -> Result<RoomMessageEventContent> {
-	if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
+#[admin_command]
+pub(super) async fn deactivate_all(&self, no_leave_rooms: bool, force: bool) -> Result<RoomMessageEventContent> {
+	if self.body.len() < 2 || !self.body[0].trim().starts_with("```") || self.body.last().unwrap_or(&"").trim() != "```"
+	{
 		return Ok(RoomMessageEventContent::text_plain(
 			"Expected code block in command body. Add --help for details.",
 		));
 	}
 
-	let usernames = body
-		.clone()
-		.drain(1..body.len().saturating_sub(1))
+	let usernames = self
+		.body
+		.to_vec()
+		.drain(1..self.body.len().saturating_sub(1))
 		.collect::<Vec<_>>();
 
 	let mut user_ids: Vec<OwnedUserId> = Vec::with_capacity(usernames.len());
 	let mut admins = Vec::new();
 
 	for username in usernames {
-		match parse_active_local_user_id(username) {
+		match parse_active_local_user_id(self.services, username) {
 			Ok(user_id) => {
-				if services().users.is_admin(&user_id)? && !force {
-					services()
+				if self.services.users.is_admin(&user_id)? && !force {
+					self.services
 						.admin
 						.send_message(RoomMessageEventContent::text_plain(format!(
 							"{username} is an admin and --force is not set, skipping over"
@@ -224,8 +231,8 @@ pub(super) async fn deactivate_all(
 				}
 
 				// don't deactivate the server service account
-				if user_id == services().globals.server_user {
-					services()
+				if user_id == self.services.globals.server_user {
+					self.services
 						.admin
 						.send_message(RoomMessageEventContent::text_plain(format!(
 							"{username} is the server service account, skipping over"
@@ -237,7 +244,7 @@ pub(super) async fn deactivate_all(
 				user_ids.push(user_id);
 			},
 			Err(e) => {
-				services()
+				self.services
 					.admin
 					.send_message(RoomMessageEventContent::text_plain(format!(
 						"{username} is not a valid username, skipping over: {e}"
@@ -251,24 +258,25 @@ pub(super) async fn deactivate_all(
 	let mut deactivation_count: usize = 0;
 
 	for user_id in user_ids {
-		match services().users.deactivate_account(&user_id) {
+		match self.services.users.deactivate_account(&user_id) {
 			Ok(()) => {
 				deactivation_count = deactivation_count.saturating_add(1);
 				if !no_leave_rooms {
 					info!("Forcing user {user_id} to leave all rooms apart of deactivate-all");
-					let all_joined_rooms: Vec<OwnedRoomId> = services()
+					let all_joined_rooms: Vec<OwnedRoomId> = self
+						.services
 						.rooms
 						.state_cache
 						.rooms_joined(&user_id)
 						.filter_map(Result::ok)
 						.collect();
-					update_displayname(user_id.clone(), None, all_joined_rooms.clone()).await?;
-					update_avatar_url(user_id.clone(), None, None, all_joined_rooms).await?;
-					leave_all_rooms(&user_id).await;
+					update_displayname(self.services, user_id.clone(), None, all_joined_rooms.clone()).await?;
+					update_avatar_url(self.services, user_id.clone(), None, None, all_joined_rooms).await?;
+					leave_all_rooms(self.services, &user_id).await;
 				}
 			},
 			Err(e) => {
-				services()
+				self.services
 					.admin
 					.send_message(RoomMessageEventContent::text_plain(format!("Failed deactivating user: {e}")))
 					.await;
@@ -289,16 +297,18 @@ pub(super) async fn deactivate_all(
 	}
 }
 
-pub(super) async fn list_joined_rooms(_body: Vec<&str>, user_id: String) -> Result<RoomMessageEventContent> {
+#[admin_command]
+pub(super) async fn list_joined_rooms(&self, user_id: String) -> Result<RoomMessageEventContent> {
 	// Validate user id
-	let user_id = parse_local_user_id(&user_id)?;
+	let user_id = parse_local_user_id(self.services, &user_id)?;
 
-	let mut rooms: Vec<(OwnedRoomId, u64, String)> = services()
+	let mut rooms: Vec<(OwnedRoomId, u64, String)> = self
+		.services
 		.rooms
 		.state_cache
 		.rooms_joined(&user_id)
 		.filter_map(Result::ok)
-		.map(|room_id| get_room_info(&room_id))
+		.map(|room_id| get_room_info(self.services, &room_id))
 		.collect();
 
 	if rooms.is_empty() {
@@ -340,41 +350,55 @@ pub(super) async fn list_joined_rooms(_body: Vec<&str>, user_id: String) -> Resu
 	Ok(RoomMessageEventContent::text_html(output_plain, output_html))
 }
 
+#[admin_command]
 pub(super) async fn force_join_room(
-	_body: Vec<&str>, user_id: String, room_id: OwnedRoomOrAliasId,
+	&self, user_id: String, room_id: OwnedRoomOrAliasId,
 ) -> Result<RoomMessageEventContent> {
-	let user_id = parse_local_user_id(&user_id)?;
-	let room_id = services().rooms.alias.resolve(&room_id).await?;
+	let user_id = parse_local_user_id(self.services, &user_id)?;
+	let room_id = self.services.rooms.alias.resolve(&room_id).await?;
 
-	assert!(service::user_is_local(&user_id), "Parsed user_id must be a local user");
-	join_room_by_id_helper(&user_id, &room_id, None, &[], None).await?;
+	assert!(
+		self.services.globals.user_is_local(&user_id),
+		"Parsed user_id must be a local user"
+	);
+	join_room_by_id_helper(self.services, &user_id, &room_id, None, &[], None).await?;
 
 	Ok(RoomMessageEventContent::notice_markdown(format!(
 		"{user_id} has been joined to {room_id}.",
 	)))
 }
 
-pub(super) async fn make_user_admin(_body: Vec<&str>, user_id: String) -> Result<RoomMessageEventContent> {
-	let user_id = parse_local_user_id(&user_id)?;
-	let displayname = services()
+#[admin_command]
+pub(super) async fn make_user_admin(&self, user_id: String) -> Result<RoomMessageEventContent> {
+	let user_id = parse_local_user_id(self.services, &user_id)?;
+	let displayname = self
+		.services
 		.users
 		.displayname(&user_id)?
 		.unwrap_or_else(|| user_id.to_string());
 
-	assert!(service::user_is_local(&user_id), "Parsed user_id must be a local user");
-	service::admin::make_user_admin(&user_id, displayname).await?;
+	assert!(
+		self.services.globals.user_is_local(&user_id),
+		"Parsed user_id must be a local user"
+	);
+	self.services
+		.admin
+		.make_user_admin(&user_id, displayname)
+		.await?;
 
 	Ok(RoomMessageEventContent::notice_markdown(format!(
 		"{user_id} has been granted admin privileges.",
 	)))
 }
 
+#[admin_command]
 pub(super) async fn put_room_tag(
-	_body: Vec<&str>, user_id: String, room_id: Box<RoomId>, tag: String,
+	&self, user_id: String, room_id: Box<RoomId>, tag: String,
 ) -> Result<RoomMessageEventContent> {
-	let user_id = parse_active_local_user_id(&user_id)?;
+	let user_id = parse_active_local_user_id(self.services, &user_id)?;
 
-	let event = services()
+	let event = self
+		.services
 		.account_data
 		.get(Some(&room_id), &user_id, RoomAccountDataEventType::Tag)?;
 
@@ -392,7 +416,7 @@ pub(super) async fn put_room_tag(
 		.tags
 		.insert(tag.clone().into(), TagInfo::new());
 
-	services().account_data.update(
+	self.services.account_data.update(
 		Some(&room_id),
 		&user_id,
 		RoomAccountDataEventType::Tag,
@@ -404,12 +428,14 @@ pub(super) async fn put_room_tag(
 	)))
 }
 
+#[admin_command]
 pub(super) async fn delete_room_tag(
-	_body: Vec<&str>, user_id: String, room_id: Box<RoomId>, tag: String,
+	&self, user_id: String, room_id: Box<RoomId>, tag: String,
 ) -> Result<RoomMessageEventContent> {
-	let user_id = parse_active_local_user_id(&user_id)?;
+	let user_id = parse_active_local_user_id(self.services, &user_id)?;
 
-	let event = services()
+	let event = self
+		.services
 		.account_data
 		.get(Some(&room_id), &user_id, RoomAccountDataEventType::Tag)?;
 
@@ -424,7 +450,7 @@ pub(super) async fn delete_room_tag(
 
 	tags_event.content.tags.remove(&tag.clone().into());
 
-	services().account_data.update(
+	self.services.account_data.update(
 		Some(&room_id),
 		&user_id,
 		RoomAccountDataEventType::Tag,
@@ -436,12 +462,12 @@ pub(super) async fn delete_room_tag(
 	)))
 }
 
-pub(super) async fn get_room_tags(
-	_body: Vec<&str>, user_id: String, room_id: Box<RoomId>,
-) -> Result<RoomMessageEventContent> {
-	let user_id = parse_active_local_user_id(&user_id)?;
+#[admin_command]
+pub(super) async fn get_room_tags(&self, user_id: String, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
+	let user_id = parse_active_local_user_id(self.services, &user_id)?;
 
-	let event = services()
+	let event = self
+		.services
 		.account_data
 		.get(Some(&room_id), &user_id, RoomAccountDataEventType::Tag)?;
 

src/admin/user/mod.rs

@@ -2,15 +2,16 @@ mod commands;
 
 use clap::Subcommand;
 use conduit::Result;
-use ruma::{events::room::message::RoomMessageEventContent, OwnedRoomOrAliasId, RoomId};
+use ruma::{OwnedRoomOrAliasId, RoomId};
 
-use self::commands::*;
+use crate::admin_command_dispatch;
 
-#[cfg_attr(test, derive(Debug))]
-#[derive(Subcommand)]
+#[admin_command_dispatch]
+#[derive(Debug, Subcommand)]
 pub(super) enum UserCommand {
 	/// - Create a new user
-	Create {
+	#[clap(alias = "create")]
+	CreateUser {
 		/// Username of the new user
 		username: String,
 		/// Password of the new user, if unspecified one is generated
@@ -57,7 +58,8 @@ pub(super) enum UserCommand {
 	},
 
 	/// - List local users in the database
-	List,
+	#[clap(alias = "list")]
+	ListUsers,
 
 	/// - Lists all the rooms (local and remote) that the specified user is
 	///   joined in
@@ -102,48 +104,3 @@ pub(super) enum UserCommand {
 		room_id: Box<RoomId>,
 	},
 }
-
-pub(super) async fn process(command: UserCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
-	Ok(match command {
-		UserCommand::List => list(body).await?,
-		UserCommand::Create {
-			username,
-			password,
-		} => create(body, username, password).await?,
-		UserCommand::Deactivate {
-			no_leave_rooms,
-			user_id,
-		} => deactivate(body, no_leave_rooms, user_id).await?,
-		UserCommand::ResetPassword {
-			username,
-		} => reset_password(body, username).await?,
-		UserCommand::DeactivateAll {
-			no_leave_rooms,
-			force,
-		} => deactivate_all(body, no_leave_rooms, force).await?,
-		UserCommand::ListJoinedRooms {
-			user_id,
-		} => list_joined_rooms(body, user_id).await?,
-		UserCommand::ForceJoinRoom {
-			user_id,
-			room_id,
-		} => force_join_room(body, user_id, room_id).await?,
-		UserCommand::MakeUserAdmin {
-			user_id,
-		} => make_user_admin(body, user_id).await?,
-		UserCommand::PutRoomTag {
-			user_id,
-			room_id,
-			tag,
-		} => put_room_tag(body, user_id, room_id, tag).await?,
-		UserCommand::DeleteRoomTag {
-			user_id,
-			room_id,
-			tag,
-		} => delete_room_tag(body, user_id, room_id, tag).await?,
-		UserCommand::GetRoomTags {
-			user_id,
-			room_id,
-		} => get_room_tags(body, user_id, room_id).await?,
-	})
-}

src/admin/utils.rs

@@ -1,8 +1,6 @@
-use conduit_core::{err, Err};
+use conduit_core::{err, Err, Result};
 use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId};
-use service::user_is_local;
-
-use crate::{services, Result};
+use service::Services;
 
 pub(crate) fn escape_html(s: &str) -> String {
 	s.replace('&', "&")
@@ -10,17 +8,17 @@ pub(crate) fn escape_html(s: &str) -> String {
 		.replace('>', ">")
 }
 
-pub(crate) fn get_room_info(id: &RoomId) -> (OwnedRoomId, u64, String) {
+pub(crate) fn get_room_info(services: &Services, id: &RoomId) -> (OwnedRoomId, u64, String) {
 	(
 		id.into(),
-		services()
+		services
 			.rooms
 			.state_cache
 			.room_joined_count(id)
 			.ok()
 			.flatten()
 			.unwrap_or(0),
-		services()
+		services
 			.rooms
 			.state_accessor
 			.get_name(id)
@@ -31,16 +29,16 @@ pub(crate) fn get_room_info(id: &RoomId) -> (OwnedRoomId, u64, String) {
 }
 
 /// Parses user ID
-pub(crate) fn parse_user_id(user_id: &str) -> Result<OwnedUserId> {
-	UserId::parse_with_server_name(user_id.to_lowercase(), services().globals.server_name())
+pub(crate) fn parse_user_id(services: &Services, user_id: &str) -> Result<OwnedUserId> {
+	UserId::parse_with_server_name(user_id.to_lowercase(), services.globals.server_name())
 		.map_err(|e| err!("The supplied username is not a valid username: {e}"))
 }
 
 /// Parses user ID as our local user
-pub(crate) fn parse_local_user_id(user_id: &str) -> Result<OwnedUserId> {
-	let user_id = parse_user_id(user_id)?;
+pub(crate) fn parse_local_user_id(services: &Services, user_id: &str) -> Result<OwnedUserId> {
+	let user_id = parse_user_id(services, user_id)?;
 
-	if !user_is_local(&user_id) {
+	if !services.globals.user_is_local(&user_id) {
 		return Err!("User {user_id:?} does not belong to our server.");
 	}
 
@@ -48,14 +46,14 @@ pub(crate) fn parse_local_user_id(user_id: &str) -> Result<OwnedUserId> {
 }
 
 /// Parses user ID that is an active (not guest or deactivated) local user
-pub(crate) fn parse_active_local_user_id(user_id: &str) -> Result<OwnedUserId> {
-	let user_id = parse_local_user_id(user_id)?;
+pub(crate) fn parse_active_local_user_id(services: &Services, user_id: &str) -> Result<OwnedUserId> {
+	let user_id = parse_local_user_id(services, user_id)?;
 
-	if !services().users.exists(&user_id)? {
+	if !services.users.exists(&user_id)? {
 		return Err!("User {user_id:?} does not exist on this server.");
 	}
 
-	if services().users.is_deactivated(&user_id)? {
+	if services.users.is_deactivated(&user_id)? {
 		return Err!("User {user_id:?} is deactivated.");
 	}
 

src/api/client/account.rs

@@ -1,7 +1,8 @@
 use std::fmt::Write;
 
+use axum::extract::State;
 use axum_client_ip::InsecureClientIp;
-use conduit::debug_info;
+use conduit::{debug_info, error, info, utils, warn, Error, Result};
 use register::RegistrationKind;
 use ruma::{
 	api::client::{
@@ -17,15 +18,9 @@ use ruma::{
 	events::{room::message::RoomMessageEventContent, GlobalAccountDataEventType},
 	push, OwnedRoomId, UserId,
 };
-use tracing::{error, info, warn};
 
 use super::{join_room_by_id_helper, DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
-use crate::{
-	service::user_is_local,
-	services,
-	utils::{self},
-	Error, Result, Ruma,
-};
+use crate::Ruma;
 
 const RANDOM_USER_ID_LENGTH: usize = 10;
 
@@ -42,20 +37,21 @@ const RANDOM_USER_ID_LENGTH: usize = 10;
 /// invalid when trying to register
 #[tracing::instrument(skip_all, fields(%client), name = "register_available")]
 pub(crate) async fn get_register_available_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_username_availability::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_username_availability::v3::Request>,
 ) -> Result<get_username_availability::v3::Response> {
 	// Validate user id
-	let user_id = UserId::parse_with_server_name(body.username.to_lowercase(), services().globals.server_name())
+	let user_id = UserId::parse_with_server_name(body.username.to_lowercase(), services.globals.server_name())
 		.ok()
-		.filter(|user_id| !user_id.is_historical() && user_is_local(user_id))
+		.filter(|user_id| !user_id.is_historical() && services.globals.user_is_local(user_id))
 		.ok_or(Error::BadRequest(ErrorKind::InvalidUsername, "Username is invalid."))?;
 
 	// Check if username is creative enough
-	if services().users.exists(&user_id)? {
+	if services.users.exists(&user_id)? {
 		return Err(Error::BadRequest(ErrorKind::UserInUse, "Desired user ID is already taken."));
 	}
 
-	if services()
+	if services
 		.globals
 		.forbidden_usernames()
 		.is_match(user_id.localpart())
@@ -91,9 +87,9 @@ pub(crate) async fn get_register_available_route(
 #[allow(clippy::doc_markdown)]
 #[tracing::instrument(skip_all, fields(%client), name = "register")]
 pub(crate) async fn register_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<register::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp, body: Ruma<register::v3::Request>,
 ) -> Result<register::v3::Response> {
-	if !services().globals.allow_registration() && body.appservice_info.is_none() {
+	if !services.globals.allow_registration() && body.appservice_info.is_none() {
 		info!(
 			"Registration disabled and request not from known appservice, rejecting registration attempt for username \
 			 {:?}",
@@ -105,8 +101,8 @@ pub(crate) async fn register_route(
 	let is_guest = body.kind == RegistrationKind::Guest;
 
 	if is_guest
-		&& (!services().globals.allow_guest_registration()
-			|| (services().globals.allow_registration() && services().globals.config.registration_token.is_some()))
+		&& (!services.globals.allow_guest_registration()
+			|| (services.globals.allow_registration() && services.globals.config.registration_token.is_some()))
 	{
 		info!(
 			"Guest registration disabled / registration enabled with token configured, rejecting guest registration \
@@ -121,7 +117,7 @@ pub(crate) async fn register_route(
 
 	// forbid guests from registering if there is not a real admin user yet. give
 	// generic user error.
-	if is_guest && services().users.count()? < 2 {
+	if is_guest && services.users.count()? < 2 {
 		warn!(
 			"Guest account attempted to register before a real admin user has been registered, rejecting \
 			 registration. Guest's initial device name: {:?}",
@@ -133,16 +129,16 @@ pub(crate) async fn register_route(
 	let user_id = match (&body.username, is_guest) {
 		(Some(username), false) => {
 			let proposed_user_id =
-				UserId::parse_with_server_name(username.to_lowercase(), services().globals.server_name())
+				UserId::parse_with_server_name(username.to_lowercase(), services.globals.server_name())
 					.ok()
-					.filter(|user_id| !user_id.is_historical() && user_is_local(user_id))
+					.filter(|user_id| !user_id.is_historical() && services.globals.user_is_local(user_id))
 					.ok_or(Error::BadRequest(ErrorKind::InvalidUsername, "Username is invalid."))?;
 
-			if services().users.exists(&proposed_user_id)? {
+			if services.users.exists(&proposed_user_id)? {
 				return Err(Error::BadRequest(ErrorKind::UserInUse, "Desired user ID is already taken."));
 			}
 
-			if services()
+			if services
 				.globals
 				.forbidden_usernames()
 				.is_match(proposed_user_id.localpart())
@@ -155,10 +151,10 @@ pub(crate) async fn register_route(
 		_ => loop {
 			let proposed_user_id = UserId::parse_with_server_name(
 				utils::random_string(RANDOM_USER_ID_LENGTH).to_lowercase(),
-				services().globals.server_name(),
+				services.globals.server_name(),
 			)
 			.unwrap();
-			if !services().users.exists(&proposed_user_id)? {
+			if !services.users.exists(&proposed_user_id)? {
 				break proposed_user_id;
 			}
 		},
@@ -172,13 +168,13 @@ pub(crate) async fn register_route(
 		} else {
 			return Err(Error::BadRequest(ErrorKind::MissingToken, "Missing appservice token."));
 		}
-	} else if services().appservice.is_exclusive_user_id(&user_id).await {
+	} else if services.appservice.is_exclusive_user_id(&user_id).await {
 		return Err(Error::BadRequest(ErrorKind::Exclusive, "User ID reserved by appservice."));
 	}
 
 	// UIAA
 	let mut uiaainfo;
-	let skip_auth = if services().globals.config.registration_token.is_some() {
+	let skip_auth = if services.globals.config.registration_token.is_some() {
 		// Registration token required
 		uiaainfo = UiaaInfo {
 			flows: vec![AuthFlow {
@@ -206,8 +202,8 @@ pub(crate) async fn register_route(
 
 	if !skip_auth {
 		if let Some(auth) = &body.auth {
-			let (worked, uiaainfo) = services().uiaa.try_auth(
-				&UserId::parse_with_server_name("", services().globals.server_name()).expect("we know this is valid"),
+			let (worked, uiaainfo) = services.uiaa.try_auth(
+				&UserId::parse_with_server_name("", services.globals.server_name()).expect("we know this is valid"),
 				"".into(),
 				auth,
 				&uiaainfo,
@@ -218,8 +214,8 @@ pub(crate) async fn register_route(
 		// Success!
 		} else if let Some(json) = body.json_body {
 			uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-			services().uiaa.create(
-				&UserId::parse_with_server_name("", services().globals.server_name()).expect("we know this is valid"),
+			services.uiaa.create(
+				&UserId::parse_with_server_name("", services.globals.server_name()).expect("we know this is valid"),
 				"".into(),
 				&uiaainfo,
 				&json,
@@ -237,25 +233,25 @@ pub(crate) async fn register_route(
 	};
 
 	// Create user
-	services().users.create(&user_id, password)?;
+	services.users.create(&user_id, password)?;
 
 	// Default to pretty displayname
 	let mut displayname = user_id.localpart().to_owned();
 
 	// If `new_user_displayname_suffix` is set, registration will push whatever
 	// content is set to the user's display name with a space before it
-	if !services().globals.new_user_displayname_suffix().is_empty() {
-		write!(displayname, " {}", services().globals.config.new_user_displayname_suffix)
+	if !services.globals.new_user_displayname_suffix().is_empty() {
+		write!(displayname, " {}", services.globals.config.new_user_displayname_suffix)
 			.expect("should be able to write to string buffer");
 	}
 
-	services()
+	services
 		.users
 		.set_displayname(&user_id, Some(displayname.clone()))
 		.await?;
 
 	// Initial account data
-	services().account_data.update(
+	services.account_data.update(
 		None,
 		&user_id,
 		GlobalAccountDataEventType::PushRules.to_string().into(),
@@ -290,7 +286,7 @@ pub(crate) async fn register_route(
 	let token = utils::random_string(TOKEN_LENGTH);
 
 	// Create device for this account
-	services()
+	services
 		.users
 		.create_device(&user_id, &device_id, &token, body.initial_device_display_name.clone())?;
 
@@ -299,7 +295,7 @@ pub(crate) async fn register_route(
 	// log in conduit admin channel if a non-guest user registered
 	if body.appservice_info.is_none() && !is_guest {
 		info!("New user \"{user_id}\" registered on this server.");
-		services()
+		services
 			.admin
 			.send_message(RoomMessageEventContent::notice_plain(format!(
 				"New user \"{user_id}\" registered on this server from IP {client}."
@@ -308,7 +304,7 @@ pub(crate) async fn register_route(
 	}
 
 	// log in conduit admin channel if a guest registered
-	if body.appservice_info.is_none() && is_guest && services().globals.log_guest_registrations() {
+	if body.appservice_info.is_none() && is_guest && services.globals.log_guest_registrations() {
 		info!("New guest user \"{user_id}\" registered on this server.");
 
 		if let Some(device_display_name) = &body.initial_device_display_name {
@@ -317,7 +313,7 @@ pub(crate) async fn register_route(
 				.as_ref()
 				.is_some_and(|device_display_name| !device_display_name.is_empty())
 			{
-				services()
+				services
 					.admin
 					.send_message(RoomMessageEventContent::notice_plain(format!(
 						"Guest user \"{user_id}\" with device display name `{device_display_name}` registered on this \
@@ -325,7 +321,7 @@ pub(crate) async fn register_route(
 					)))
 					.await;
 			} else {
-				services()
+				services
 					.admin
 					.send_message(RoomMessageEventContent::notice_plain(format!(
 						"Guest user \"{user_id}\" with no device display name registered on this server from IP \
@@ -334,7 +330,7 @@ pub(crate) async fn register_route(
 					.await;
 			}
 		} else {
-			services()
+			services
 				.admin
 				.send_message(RoomMessageEventContent::notice_plain(format!(
 					"Guest user \"{user_id}\" with no device display name registered on this server from IP {client}.",
@@ -346,14 +342,12 @@ pub(crate) async fn register_route(
 	// If this is the first real user, grant them admin privileges except for guest
 	// users Note: the server user, @conduit:servername, is generated first
 	if !is_guest {
-		if let Some(admin_room) = service::admin::Service::get_admin_room()? {
-			if services()
-				.rooms
-				.state_cache
-				.room_joined_count(&admin_room)?
-				== Some(1)
-			{
-				service::admin::make_user_admin(&user_id, displayname).await?;
+		if let Some(admin_room) = services.admin.get_admin_room()? {
+			if services.rooms.state_cache.room_joined_count(&admin_room)? == Some(1) {
+				services
+					.admin
+					.make_user_admin(&user_id, displayname)
+					.await?;
 
 				warn!("Granting {user_id} admin privileges as the first user");
 			}
@@ -361,14 +355,14 @@ pub(crate) async fn register_route(
 	}
 
 	if body.appservice_info.is_none()
-		&& !services().globals.config.auto_join_rooms.is_empty()
-		&& (services().globals.allow_guests_auto_join_rooms() || !is_guest)
+		&& !services.globals.config.auto_join_rooms.is_empty()
+		&& (services.globals.allow_guests_auto_join_rooms() || !is_guest)
 	{
-		for room in &services().globals.config.auto_join_rooms {
-			if !services()
+		for room in &services.globals.config.auto_join_rooms {
+			if !services
 				.rooms
 				.state_cache
-				.server_in_room(services().globals.server_name(), room)?
+				.server_in_room(services.globals.server_name(), room)?
 			{
 				warn!("Skipping room {room} to automatically join as we have never joined before.");
 				continue;
@@ -376,10 +370,11 @@ pub(crate) async fn register_route(
 
 			if let Some(room_id_server_name) = room.server_name() {
 				if let Err(e) = join_room_by_id_helper(
+					&services,
 					&user_id,
 					room,
 					Some("Automatically joining this room upon registration".to_owned()),
-					&[room_id_server_name.to_owned(), services().globals.server_name().to_owned()],
+					&[room_id_server_name.to_owned(), services.globals.server_name().to_owned()],
 					None,
 				)
 				.await
@@ -421,7 +416,8 @@ pub(crate) async fn register_route(
 /// - Triggers device list updates
 #[tracing::instrument(skip_all, fields(%client), name = "change_password")]
 pub(crate) async fn change_password_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<change_password::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<change_password::v3::Request>,
 ) -> Result<change_password::v3::Response> {
 	// Authentication for this endpoint was made optional, but we need
 	// authentication currently
@@ -442,7 +438,7 @@ pub(crate) async fn change_password_route(
 	};
 
 	if let Some(auth) = &body.auth {
-		let (worked, uiaainfo) = services()
+		let (worked, uiaainfo) = services
 			.uiaa
 			.try_auth(sender_user, sender_device, auth, &uiaainfo)?;
 		if !worked {
@@ -451,7 +447,7 @@ pub(crate) async fn change_password_route(
 	// Success!
 	} else if let Some(json) = body.json_body {
 		uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-		services()
+		services
 			.uiaa
 			.create(sender_user, sender_device, &uiaainfo, &json)?;
 		return Err(Error::Uiaa(uiaainfo));
@@ -459,24 +455,24 @@ pub(crate) async fn change_password_route(
 		return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
 	}
 
-	services()
+	services
 		.users
 		.set_password(sender_user, Some(&body.new_password))?;
 
 	if body.logout_devices {
 		// Logout all devices except the current one
-		for id in services()
+		for id in services
 			.users
 			.all_device_ids(sender_user)
 			.filter_map(Result::ok)
 			.filter(|id| id != sender_device)
 		{
-			services().users.remove_device(sender_user, &id)?;
+			services.users.remove_device(sender_user, &id)?;
 		}
 	}
 
 	info!("User {sender_user} changed their password.");
-	services()
+	services
 		.admin
 		.send_message(RoomMessageEventContent::notice_plain(format!(
 			"User {sender_user} changed their password."
@@ -491,14 +487,16 @@ pub(crate) async fn change_password_route(
 /// Get `user_id` of the sender user.
 ///
 /// Note: Also works for Application Services
-pub(crate) async fn whoami_route(body: Ruma<whoami::v3::Request>) -> Result<whoami::v3::Response> {
+pub(crate) async fn whoami_route(
+	State(services): State<crate::State>, body: Ruma<whoami::v3::Request>,
+) -> Result<whoami::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let device_id = body.sender_device.clone();
 
 	Ok(whoami::v3::Response {
 		user_id: sender_user.clone(),
 		device_id,
-		is_guest: services().users.is_deactivated(sender_user)? && body.appservice_info.is_none(),
+		is_guest: services.users.is_deactivated(sender_user)? && body.appservice_info.is_none(),
 	})
 }
 
@@ -515,7 +513,8 @@ pub(crate) async fn whoami_route(body: Ruma<whoami::v3::Request>) -> Result<whoa
 /// - Removes ability to log in again
 #[tracing::instrument(skip_all, fields(%client), name = "deactivate")]
 pub(crate) async fn deactivate_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<deactivate::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<deactivate::v3::Request>,
 ) -> Result<deactivate::v3::Response> {
 	// Authentication for this endpoint was made optional, but we need
 	// authentication currently
@@ -536,7 +535,7 @@ pub(crate) async fn deactivate_route(
 	};
 
 	if let Some(auth) = &body.auth {
-		let (worked, uiaainfo) = services()
+		let (worked, uiaainfo) = services
 			.uiaa
 			.try_auth(sender_user, sender_device, auth, &uiaainfo)?;
 		if !worked {
@@ -545,7 +544,7 @@ pub(crate) async fn deactivate_route(
 	// Success!
 	} else if let Some(json) = body.json_body {
 		uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-		services()
+		services
 			.uiaa
 			.create(sender_user, sender_device, &uiaainfo, &json)?;
 		return Err(Error::Uiaa(uiaainfo));
@@ -554,23 +553,23 @@ pub(crate) async fn deactivate_route(
 	}
 
 	// Remove devices and mark account as deactivated
-	services().users.deactivate_account(sender_user)?;
+	services.users.deactivate_account(sender_user)?;
 
 	// Remove profile pictures and display name
-	let all_joined_rooms: Vec<OwnedRoomId> = services()
+	let all_joined_rooms: Vec<OwnedRoomId> = services
 		.rooms
 		.state_cache
 		.rooms_joined(sender_user)
 		.filter_map(Result::ok)
 		.collect();
-	super::update_displayname(sender_user.clone(), None, all_joined_rooms.clone()).await?;
-	super::update_avatar_url(sender_user.clone(), None, None, all_joined_rooms).await?;
+	super::update_displayname(&services, sender_user.clone(), None, all_joined_rooms.clone()).await?;
+	super::update_avatar_url(&services, sender_user.clone(), None, None, all_joined_rooms).await?;
 
 	// Make the user leave all rooms before deactivation
-	super::leave_all_rooms(sender_user).await;
+	super::leave_all_rooms(&services, sender_user).await;
 
 	info!("User {sender_user} deactivated their account.");
-	services()
+	services
 		.admin
 		.send_message(RoomMessageEventContent::notice_plain(format!(
 			"User {sender_user} deactivated their account."
@@ -632,9 +631,9 @@ pub(crate) async fn request_3pid_management_token_via_msisdn_route(
 /// Currently does not have any ratelimiting, and this isn't very practical as
 /// there is only one registration token allowed.
 pub(crate) async fn check_registration_token_validity(
-	body: Ruma<check_registration_token_validity::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<check_registration_token_validity::v1::Request>,
 ) -> Result<check_registration_token_validity::v1::Response> {
-	let Some(reg_token) = services().globals.config.registration_token.clone() else {
+	let Some(reg_token) = services.globals.config.registration_token.clone() else {
 		return Err(Error::BadRequest(
 			ErrorKind::forbidden(),
 			"Server does not allow token registration.",

src/api/client/alias.rs

@@ -1,3 +1,5 @@
+use axum::extract::State;
+use conduit::{debug, Error, Result};
 use rand::seq::SliceRandom;
 use ruma::{
 	api::client::{
@@ -6,21 +8,27 @@ use ruma::{
 	},
 	OwnedServerName, RoomAliasId, RoomId,
 };
-use tracing::debug;
+use service::Services;
 
-use crate::{service::server_is_ours, services, Error, Result, Ruma};
+use crate::Ruma;
 
 /// # `PUT /_matrix/client/v3/directory/room/{roomAlias}`
 ///
 /// Creates a new room alias on this server.
-pub(crate) async fn create_alias_route(body: Ruma<create_alias::v3::Request>) -> Result<create_alias::v3::Response> {
+pub(crate) async fn create_alias_route(
+	State(services): State<crate::State>, body: Ruma<create_alias::v3::Request>,
+) -> Result<create_alias::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	service::rooms::alias::appservice_checks(&body.room_alias, &body.appservice_info).await?;
+	services
+		.rooms
+		.alias
+		.appservice_checks(&body.room_alias, &body.appservice_info)
+		.await?;
 
 	// this isn't apart of alias_checks or delete alias route because we should
 	// allow removing forbidden room aliases
-	if services()
+	if services
 		.globals
 		.forbidden_alias_names()
 		.is_match(body.room_alias.alias())
@@ -28,7 +36,7 @@ pub(crate) async fn create_alias_route(body: Ruma<create_alias::v3::Request>) ->
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Room alias is forbidden."));
 	}
 
-	if services()
+	if services
 		.rooms
 		.alias
 		.resolve_local_alias(&body.room_alias)?
@@ -37,7 +45,7 @@ pub(crate) async fn create_alias_route(body: Ruma<create_alias::v3::Request>) ->
 		return Err(Error::Conflict("Alias already exists."));
 	}
 
-	services()
+	services
 		.rooms
 		.alias
 		.set_alias(&body.room_alias, &body.room_id, sender_user)?;
@@ -50,12 +58,18 @@ pub(crate) async fn create_alias_route(body: Ruma<create_alias::v3::Request>) ->
 /// Deletes a room alias from this server.
 ///
 /// - TODO: Update canonical alias event
-pub(crate) async fn delete_alias_route(body: Ruma<delete_alias::v3::Request>) -> Result<delete_alias::v3::Response> {
+pub(crate) async fn delete_alias_route(
+	State(services): State<crate::State>, body: Ruma<delete_alias::v3::Request>,
+) -> Result<delete_alias::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	service::rooms::alias::appservice_checks(&body.room_alias, &body.appservice_info).await?;
+	services
+		.rooms
+		.alias
+		.appservice_checks(&body.room_alias, &body.appservice_info)
+		.await?;
 
-	if services()
+	if services
 		.rooms
 		.alias
 		.resolve_local_alias(&body.room_alias)?
@@ -64,7 +78,7 @@ pub(crate) async fn delete_alias_route(body: Ruma<delete_alias::v3::Request>) ->
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Alias does not exist."));
 	}
 
-	services()
+	services
 		.rooms
 		.alias
 		.remove_alias(&body.room_alias, sender_user)
@@ -78,11 +92,13 @@ pub(crate) async fn delete_alias_route(body: Ruma<delete_alias::v3::Request>) ->
 /// # `GET /_matrix/client/v3/directory/room/{roomAlias}`
 ///
 /// Resolve an alias locally or over federation.
-pub(crate) async fn get_alias_route(body: Ruma<get_alias::v3::Request>) -> Result<get_alias::v3::Response> {
+pub(crate) async fn get_alias_route(
+	State(services): State<crate::State>, body: Ruma<get_alias::v3::Request>,
+) -> Result<get_alias::v3::Response> {
 	let room_alias = body.body.room_alias;
 	let servers = None;
 
-	let Ok((room_id, pre_servers)) = services()
+	let Ok((room_id, pre_servers)) = services
 		.rooms
 		.alias
 		.resolve_alias(&room_alias, servers.as_ref())
@@ -91,17 +107,17 @@ pub(crate) async fn get_alias_route(body: Ruma<get_alias::v3::Request>) -> Resul
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Room with alias not found."));
 	};
 
-	let servers = room_available_servers(&room_id, &room_alias, &pre_servers);
+	let servers = room_available_servers(&services, &room_id, &room_alias, &pre_servers);
 	debug!(?room_alias, ?room_id, "available servers: {servers:?}");
 
 	Ok(get_alias::v3::Response::new(room_id, servers))
 }
 
 fn room_available_servers(
-	room_id: &RoomId, room_alias: &RoomAliasId, pre_servers: &Option<Vec<OwnedServerName>>,
+	services: &Services, room_id: &RoomId, room_alias: &RoomAliasId, pre_servers: &Option<Vec<OwnedServerName>>,
 ) -> Vec<OwnedServerName> {
 	// find active servers in room state cache to suggest
-	let mut servers: Vec<OwnedServerName> = services()
+	let mut servers: Vec<OwnedServerName> = services
 		.rooms
 		.state_cache
 		.room_servers(room_id)
@@ -124,10 +140,10 @@ fn room_available_servers(
 	// prefer the room alias server first
 	if let Some(server_index) = servers
 		.iter()
-		.position(|server_name| server_is_ours(server_name))
+		.position(|server_name| services.globals.server_is_ours(server_name))
 	{
 		servers.swap_remove(server_index);
-		servers.insert(0, services().globals.server_name().to_owned());
+		servers.insert(0, services.globals.server_name().to_owned());
 	} else if let Some(alias_server_index) = servers
 		.iter()
 		.position(|server| server == room_alias.server_name())

src/api/client/backup.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use ruma::{
 	api::client::{
 		backup::{
@@ -11,16 +12,16 @@ use ruma::{
 	UInt,
 };
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `POST /_matrix/client/r0/room_keys/version`
 ///
 /// Creates a new backup.
 pub(crate) async fn create_backup_version_route(
-	body: Ruma<create_backup_version::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<create_backup_version::v3::Request>,
 ) -> Result<create_backup_version::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-	let version = services()
+	let version = services
 		.key_backups
 		.create_backup(sender_user, &body.algorithm)?;
 
@@ -34,10 +35,10 @@ pub(crate) async fn create_backup_version_route(
 /// Update information about an existing backup. Only `auth_data` can be
 /// modified.
 pub(crate) async fn update_backup_version_route(
-	body: Ruma<update_backup_version::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<update_backup_version::v3::Request>,
 ) -> Result<update_backup_version::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-	services()
+	services
 		.key_backups
 		.update_backup(sender_user, &body.version, &body.algorithm)?;
 
@@ -48,20 +49,20 @@ pub(crate) async fn update_backup_version_route(
 ///
 /// Get information about the latest backup version.
 pub(crate) async fn get_latest_backup_info_route(
-	body: Ruma<get_latest_backup_info::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_latest_backup_info::v3::Request>,
 ) -> Result<get_latest_backup_info::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let (version, algorithm) = services()
+	let (version, algorithm) = services
 		.key_backups
 		.get_latest_backup(sender_user)?
 		.ok_or_else(|| Error::BadRequest(ErrorKind::NotFound, "Key backup does not exist."))?;
 
 	Ok(get_latest_backup_info::v3::Response {
 		algorithm,
-		count: (UInt::try_from(services().key_backups.count_keys(sender_user, &version)?)
+		count: (UInt::try_from(services.key_backups.count_keys(sender_user, &version)?)
 			.expect("user backup keys count should not be that high")),
-		etag: services().key_backups.get_etag(sender_user, &version)?,
+		etag: services.key_backups.get_etag(sender_user, &version)?,
 		version,
 	})
 }
@@ -70,10 +71,10 @@ pub(crate) async fn get_latest_backup_info_route(
 ///
 /// Get information about an existing backup.
 pub(crate) async fn get_backup_info_route(
-	body: Ruma<get_backup_info::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_backup_info::v3::Request>,
 ) -> Result<get_backup_info::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-	let algorithm = services()
+	let algorithm = services
 		.key_backups
 		.get_backup(sender_user, &body.version)?
 		.ok_or_else(|| Error::BadRequest(ErrorKind::NotFound, "Key backup does not exist."))?;
@@ -81,14 +82,12 @@ pub(crate) async fn get_backup_info_route(
 	Ok(get_backup_info::v3::Response {
 		algorithm,
 		count: (UInt::try_from(
-			services()
+			services
 				.key_backups
 				.count_keys(sender_user, &body.version)?,
 		)
 		.expect("user backup keys count should not be that high")),
-		etag: services()
-			.key_backups
-			.get_etag(sender_user, &body.version)?,
+		etag: services.key_backups.get_etag(sender_user, &body.version)?,
 		version: body.version.clone(),
 	})
 }
@@ -100,11 +99,11 @@ pub(crate) async fn get_backup_info_route(
 /// - Deletes both information about the backup, as well as all key data related
 ///   to the backup
 pub(crate) async fn delete_backup_version_route(
-	body: Ruma<delete_backup_version::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<delete_backup_version::v3::Request>,
 ) -> Result<delete_backup_version::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	services()
+	services
 		.key_backups
 		.delete_backup(sender_user, &body.version)?;
 
@@ -120,12 +119,12 @@ pub(crate) async fn delete_backup_version_route(
 /// - Adds the keys to the backup
 /// - Returns the new number of keys in this backup and the etag
 pub(crate) async fn add_backup_keys_route(
-	body: Ruma<add_backup_keys::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<add_backup_keys::v3::Request>,
 ) -> Result<add_backup_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if Some(&body.version)
-		!= services()
+		!= services
 			.key_backups
 			.get_latest_backup_version(sender_user)?
 			.as_ref()
@@ -138,7 +137,7 @@ pub(crate) async fn add_backup_keys_route(
 
 	for (room_id, room) in &body.rooms {
 		for (session_id, key_data) in &room.sessions {
-			services()
+			services
 				.key_backups
 				.add_key(sender_user, &body.version, room_id, session_id, key_data)?;
 		}
@@ -146,14 +145,12 @@ pub(crate) async fn add_backup_keys_route(
 
 	Ok(add_backup_keys::v3::Response {
 		count: (UInt::try_from(
-			services()
+			services
 				.key_backups
 				.count_keys(sender_user, &body.version)?,
 		)
 		.expect("user backup keys count should not be that high")),
-		etag: services()
-			.key_backups
-			.get_etag(sender_user, &body.version)?,
+		etag: services.key_backups.get_etag(sender_user, &body.version)?,
 	})
 }
 
@@ -166,12 +163,12 @@ pub(crate) async fn add_backup_keys_route(
 /// - Adds the keys to the backup
 /// - Returns the new number of keys in this backup and the etag
 pub(crate) async fn add_backup_keys_for_room_route(
-	body: Ruma<add_backup_keys_for_room::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<add_backup_keys_for_room::v3::Request>,
 ) -> Result<add_backup_keys_for_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if Some(&body.version)
-		!= services()
+		!= services
 			.key_backups
 			.get_latest_backup_version(sender_user)?
 			.as_ref()
@@ -183,21 +180,19 @@ pub(crate) async fn add_backup_keys_for_room_route(
 	}
 
 	for (session_id, key_data) in &body.sessions {
-		services()
+		services
 			.key_backups
 			.add_key(sender_user, &body.version, &body.room_id, session_id, key_data)?;
 	}
 
 	Ok(add_backup_keys_for_room::v3::Response {
 		count: (UInt::try_from(
-			services()
+			services
 				.key_backups
 				.count_keys(sender_user, &body.version)?,
 		)
 		.expect("user backup keys count should not be that high")),
-		etag: services()
-			.key_backups
-			.get_etag(sender_user, &body.version)?,
+		etag: services.key_backups.get_etag(sender_user, &body.version)?,
 	})
 }
 
@@ -210,12 +205,12 @@ pub(crate) async fn add_backup_keys_for_room_route(
 /// - Adds the keys to the backup
 /// - Returns the new number of keys in this backup and the etag
 pub(crate) async fn add_backup_keys_for_session_route(
-	body: Ruma<add_backup_keys_for_session::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<add_backup_keys_for_session::v3::Request>,
 ) -> Result<add_backup_keys_for_session::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	if Some(&body.version)
-		!= services()
+		!= services
 			.key_backups
 			.get_latest_backup_version(sender_user)?
 			.as_ref()
@@ -226,20 +221,18 @@ pub(crate) async fn add_backup_keys_for_session_route(
 		));
 	}
 
-	services()
+	services
 		.key_backups
 		.add_key(sender_user, &body.version, &body.room_id, &body.session_id, &body.session_data)?;
 
 	Ok(add_backup_keys_for_session::v3::Response {
 		count: (UInt::try_from(
-			services()
+			services
 				.key_backups
 				.count_keys(sender_user, &body.version)?,
 		)
 		.expect("user backup keys count should not be that high")),
-		etag: services()
-			.key_backups
-			.get_etag(sender_user, &body.version)?,
+		etag: services.key_backups.get_etag(sender_user, &body.version)?,
 	})
 }
 
@@ -247,11 +240,11 @@ pub(crate) async fn add_backup_keys_for_session_route(
 ///
 /// Retrieves all keys from the backup.
 pub(crate) async fn get_backup_keys_route(
-	body: Ruma<get_backup_keys::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_backup_keys::v3::Request>,
 ) -> Result<get_backup_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let rooms = services().key_backups.get_all(sender_user, &body.version)?;
+	let rooms = services.key_backups.get_all(sender_user, &body.version)?;
 
 	Ok(get_backup_keys::v3::Response {
 		rooms,
@@ -262,11 +255,11 @@ pub(crate) async fn get_backup_keys_route(
 ///
 /// Retrieves all keys from the backup for a given room.
 pub(crate) async fn get_backup_keys_for_room_route(
-	body: Ruma<get_backup_keys_for_room::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_backup_keys_for_room::v3::Request>,
 ) -> Result<get_backup_keys_for_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let sessions = services()
+	let sessions = services
 		.key_backups
 		.get_room(sender_user, &body.version, &body.room_id)?;
 
@@ -279,11 +272,11 @@ pub(crate) async fn get_backup_keys_for_room_route(
 ///
 /// Retrieves a key from the backup.
 pub(crate) async fn get_backup_keys_for_session_route(
-	body: Ruma<get_backup_keys_for_session::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_backup_keys_for_session::v3::Request>,
 ) -> Result<get_backup_keys_for_session::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let key_data = services()
+	let key_data = services
 		.key_backups
 		.get_session(sender_user, &body.version, &body.room_id, &body.session_id)?
 		.ok_or_else(|| Error::BadRequest(ErrorKind::NotFound, "Backup key not found for this user's session."))?;
@@ -297,24 +290,22 @@ pub(crate) async fn get_backup_keys_for_session_route(
 ///
 /// Delete the keys from the backup.
 pub(crate) async fn delete_backup_keys_route(
-	body: Ruma<delete_backup_keys::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<delete_backup_keys::v3::Request>,
 ) -> Result<delete_backup_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	services()
+	services
 		.key_backups
 		.delete_all_keys(sender_user, &body.version)?;
 
 	Ok(delete_backup_keys::v3::Response {
 		count: (UInt::try_from(
-			services()
+			services
 				.key_backups
 				.count_keys(sender_user, &body.version)?,
 		)
 		.expect("user backup keys count should not be that high")),
-		etag: services()
-			.key_backups
-			.get_etag(sender_user, &body.version)?,
+		etag: services.key_backups.get_etag(sender_user, &body.version)?,
 	})
 }
 
@@ -322,24 +313,22 @@ pub(crate) async fn delete_backup_keys_route(
 ///
 /// Delete the keys from the backup for a given room.
 pub(crate) async fn delete_backup_keys_for_room_route(
-	body: Ruma<delete_backup_keys_for_room::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<delete_backup_keys_for_room::v3::Request>,
 ) -> Result<delete_backup_keys_for_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	services()
+	services
 		.key_backups
 		.delete_room_keys(sender_user, &body.version, &body.room_id)?;
 
 	Ok(delete_backup_keys_for_room::v3::Response {
 		count: (UInt::try_from(
-			services()
+			services
 				.key_backups
 				.count_keys(sender_user, &body.version)?,
 		)
 		.expect("user backup keys count should not be that high")),
-		etag: services()
-			.key_backups
-			.get_etag(sender_user, &body.version)?,
+		etag: services.key_backups.get_etag(sender_user, &body.version)?,
 	})
 }
 
@@ -347,23 +336,21 @@ pub(crate) async fn delete_backup_keys_for_room_route(
 ///
 /// Delete a key from the backup.
 pub(crate) async fn delete_backup_keys_for_session_route(
-	body: Ruma<delete_backup_keys_for_session::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<delete_backup_keys_for_session::v3::Request>,
 ) -> Result<delete_backup_keys_for_session::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	services()
+	services
 		.key_backups
 		.delete_room_key(sender_user, &body.version, &body.room_id, &body.session_id)?;
 
 	Ok(delete_backup_keys_for_session::v3::Response {
 		count: (UInt::try_from(
-			services()
+			services
 				.key_backups
 				.count_keys(sender_user, &body.version)?,
 		)
 		.expect("user backup keys count should not be that high")),
-		etag: services()
-			.key_backups
-			.get_etag(sender_user, &body.version)?,
+		etag: services.key_backups.get_etag(sender_user, &body.version)?,
 	})
 }

src/api/client/capabilities.rs

@@ -1,29 +1,30 @@
 use std::collections::BTreeMap;
 
+use axum::extract::State;
 use ruma::api::client::discovery::get_capabilities::{
 	self, Capabilities, RoomVersionStability, RoomVersionsCapability, ThirdPartyIdChangesCapability,
 };
 
-use crate::{services, Result, Ruma};
+use crate::{Result, Ruma};
 
 /// # `GET /_matrix/client/v3/capabilities`
 ///
 /// Get information on the supported feature set and other relevent capabilities
 /// of this server.
 pub(crate) async fn get_capabilities_route(
-	_body: Ruma<get_capabilities::v3::Request>,
+	State(services): State<crate::State>, _body: Ruma<get_capabilities::v3::Request>,
 ) -> Result<get_capabilities::v3::Response> {
 	let mut available = BTreeMap::new();
-	for room_version in &services().globals.unstable_room_versions {
+	for room_version in &services.globals.unstable_room_versions {
 		available.insert(room_version.clone(), RoomVersionStability::Unstable);
 	}
-	for room_version in &services().globals.stable_room_versions {
+	for room_version in &services.globals.stable_room_versions {
 		available.insert(room_version.clone(), RoomVersionStability::Stable);
 	}
 
 	let mut capabilities = Capabilities::default();
 	capabilities.room_versions = RoomVersionsCapability {
-		default: services().globals.default_room_version(),
+		default: services.globals.default_room_version(),
 		available,
 	};
 

src/api/client/config.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use ruma::{
 	api::client::{
 		config::{get_global_account_data, get_room_account_data, set_global_account_data, set_room_account_data},
@@ -10,15 +11,21 @@ use ruma::{
 use serde::Deserialize;
 use serde_json::{json, value::RawValue as RawJsonValue};
 
-use crate::{services, Error, Result, Ruma};
+use crate::{service::Services, Error, Result, Ruma};
 
 /// # `PUT /_matrix/client/r0/user/{userId}/account_data/{type}`
 ///
 /// Sets some account data for the sender user.
 pub(crate) async fn set_global_account_data_route(
-	body: Ruma<set_global_account_data::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<set_global_account_data::v3::Request>,
 ) -> Result<set_global_account_data::v3::Response> {
-	set_account_data(None, &body.sender_user, &body.event_type.to_string(), body.data.json())?;
+	set_account_data(
+		&services,
+		None,
+		&body.sender_user,
+		&body.event_type.to_string(),
+		body.data.json(),
+	)?;
 
 	Ok(set_global_account_data::v3::Response {})
 }
@@ -27,9 +34,10 @@ pub(crate) async fn set_global_account_data_route(
 ///
 /// Sets some room account data for the sender user.
 pub(crate) async fn set_room_account_data_route(
-	body: Ruma<set_room_account_data::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<set_room_account_data::v3::Request>,
 ) -> Result<set_room_account_data::v3::Response> {
 	set_account_data(
+		&services,
 		Some(&body.room_id),
 		&body.sender_user,
 		&body.event_type.to_string(),
@@ -43,11 +51,11 @@ pub(crate) async fn set_room_account_data_route(
 ///
 /// Gets some account data for the sender user.
 pub(crate) async fn get_global_account_data_route(
-	body: Ruma<get_global_account_data::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_global_account_data::v3::Request>,
 ) -> Result<get_global_account_data::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let event: Box<RawJsonValue> = services()
+	let event: Box<RawJsonValue> = services
 		.account_data
 		.get(None, sender_user, body.event_type.to_string().into())?
 		.ok_or_else(|| Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
@@ -65,11 +73,11 @@ pub(crate) async fn get_global_account_data_route(
 ///
 /// Gets some room account data for the sender user.
 pub(crate) async fn get_room_account_data_route(
-	body: Ruma<get_room_account_data::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_room_account_data::v3::Request>,
 ) -> Result<get_room_account_data::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let event: Box<RawJsonValue> = services()
+	let event: Box<RawJsonValue> = services
 		.account_data
 		.get(Some(&body.room_id), sender_user, body.event_type.clone())?
 		.ok_or_else(|| Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
@@ -84,14 +92,15 @@ pub(crate) async fn get_room_account_data_route(
 }
 
 fn set_account_data(
-	room_id: Option<&RoomId>, sender_user: &Option<OwnedUserId>, event_type: &str, data: &RawJsonValue,
+	services: &Services, room_id: Option<&RoomId>, sender_user: &Option<OwnedUserId>, event_type: &str,
+	data: &RawJsonValue,
 ) -> Result<()> {
 	let sender_user = sender_user.as_ref().expect("user is authenticated");
 
 	let data: serde_json::Value =
 		serde_json::from_str(data.get()).map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?;
 
-	services().account_data.update(
+	services.account_data.update(
 		room_id,
 		sender_user,
 		event_type.into(),

src/api/client/context.rs

@@ -1,12 +1,13 @@
 use std::collections::HashSet;
 
+use axum::extract::State;
 use ruma::{
 	api::client::{context::get_context, error::ErrorKind, filter::LazyLoadOptions},
 	events::StateEventType,
 };
 use tracing::error;
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/context`
 ///
@@ -14,7 +15,9 @@ use crate::{services, Error, Result, Ruma};
 ///
 /// - Only works if the user is joined (TODO: always allow, but only show events
 ///   if the user was joined, depending on history_visibility)
-pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> Result<get_context::v3::Response> {
+pub(crate) async fn get_context_route(
+	State(services): State<crate::State>, body: Ruma<get_context::v3::Request>,
+) -> Result<get_context::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
@@ -27,13 +30,13 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 
 	let mut lazy_loaded = HashSet::new();
 
-	let base_token = services()
+	let base_token = services
 		.rooms
 		.timeline
 		.get_pdu_count(&body.event_id)?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "Base event id not found."))?;
 
-	let base_event = services()
+	let base_event = services
 		.rooms
 		.timeline
 		.get_pdu(&body.event_id)?
@@ -41,7 +44,7 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 
 	let room_id = base_event.room_id.clone();
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.user_can_see_event(sender_user, &room_id, &body.event_id)?
@@ -52,7 +55,7 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 		));
 	}
 
-	if !services().rooms.lazy_loading.lazy_load_was_sent_before(
+	if !services.rooms.lazy_loading.lazy_load_was_sent_before(
 		sender_user,
 		sender_device,
 		&room_id,
@@ -67,14 +70,14 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 
 	let base_event = base_event.to_room_event();
 
-	let events_before: Vec<_> = services()
+	let events_before: Vec<_> = services
 		.rooms
 		.timeline
 		.pdus_until(sender_user, &room_id, base_token)?
 		.take(limit / 2)
 		.filter_map(Result::ok) // Remove buggy events
 		.filter(|(_, pdu)| {
-			services()
+			services
 				.rooms
 				.state_accessor
 				.user_can_see_event(sender_user, &room_id, &pdu.event_id)
@@ -83,7 +86,7 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 		.collect();
 
 	for (_, event) in &events_before {
-		if !services().rooms.lazy_loading.lazy_load_was_sent_before(
+		if !services.rooms.lazy_loading.lazy_load_was_sent_before(
 			sender_user,
 			sender_device,
 			&room_id,
@@ -103,14 +106,14 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 		.map(|(_, pdu)| pdu.to_room_event())
 		.collect();
 
-	let events_after: Vec<_> = services()
+	let events_after: Vec<_> = services
 		.rooms
 		.timeline
 		.pdus_after(sender_user, &room_id, base_token)?
 		.take(limit / 2)
 		.filter_map(Result::ok) // Remove buggy events
 		.filter(|(_, pdu)| {
-			services()
+			services
 				.rooms
 				.state_accessor
 				.user_can_see_event(sender_user, &room_id, &pdu.event_id)
@@ -119,7 +122,7 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 		.collect();
 
 	for (_, event) in &events_after {
-		if !services().rooms.lazy_loading.lazy_load_was_sent_before(
+		if !services.rooms.lazy_loading.lazy_load_was_sent_before(
 			sender_user,
 			sender_device,
 			&room_id,
@@ -130,7 +133,7 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 		}
 	}
 
-	let shortstatehash = services()
+	let shortstatehash = services
 		.rooms
 		.state_accessor
 		.pdu_shortstatehash(
@@ -139,7 +142,7 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 				.map_or(&*body.event_id, |(_, e)| &*e.event_id),
 		)?
 		.map_or(
-			services()
+			services
 				.rooms
 				.state
 				.get_room_shortstatehash(&room_id)?
@@ -147,7 +150,7 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 			|hash| hash,
 		);
 
-	let state_ids = services()
+	let state_ids = services
 		.rooms
 		.state_accessor
 		.state_full_ids(shortstatehash)
@@ -165,20 +168,20 @@ pub(crate) async fn get_context_route(body: Ruma<get_context::v3::Request>) -> R
 	let mut state = Vec::with_capacity(state_ids.len());
 
 	for (shortstatekey, id) in state_ids {
-		let (event_type, state_key) = services()
+		let (event_type, state_key) = services
 			.rooms
 			.short
 			.get_statekey_from_short(shortstatekey)?;
 
 		if event_type != StateEventType::RoomMember {
-			let Some(pdu) = services().rooms.timeline.get_pdu(&id)? else {
+			let Some(pdu) = services.rooms.timeline.get_pdu(&id)? else {
 				error!("Pdu in state not found: {}", id);
 				continue;
 			};
 
 			state.push(pdu.to_state_event());
 		} else if !lazy_load_enabled || lazy_loaded.contains(&state_key) {
-			let Some(pdu) = services().rooms.timeline.get_pdu(&id)? else {
+			let Some(pdu) = services.rooms.timeline.get_pdu(&id)? else {
 				error!("Pdu in state not found: {}", id);
 				continue;
 			};

src/api/client/device.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use ruma::api::client::{
 	device::{self, delete_device, delete_devices, get_device, get_devices, update_device},
 	error::ErrorKind,
@@ -5,15 +6,17 @@ use ruma::api::client::{
 };
 
 use super::SESSION_ID_LENGTH;
-use crate::{services, utils, Error, Result, Ruma};
+use crate::{utils, Error, Result, Ruma};
 
 /// # `GET /_matrix/client/r0/devices`
 ///
 /// Get metadata on all devices of the sender user.
-pub(crate) async fn get_devices_route(body: Ruma<get_devices::v3::Request>) -> Result<get_devices::v3::Response> {
+pub(crate) async fn get_devices_route(
+	State(services): State<crate::State>, body: Ruma<get_devices::v3::Request>,
+) -> Result<get_devices::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let devices: Vec<device::Device> = services()
+	let devices: Vec<device::Device> = services
 		.users
 		.all_devices_metadata(sender_user)
 		.filter_map(Result::ok) // Filter out buggy devices
@@ -27,10 +30,12 @@ pub(crate) async fn get_devices_route(body: Ruma<get_devices::v3::Request>) -> R
 /// # `GET /_matrix/client/r0/devices/{deviceId}`
 ///
 /// Get metadata on a single device of the sender user.
-pub(crate) async fn get_device_route(body: Ruma<get_device::v3::Request>) -> Result<get_device::v3::Response> {
+pub(crate) async fn get_device_route(
+	State(services): State<crate::State>, body: Ruma<get_device::v3::Request>,
+) -> Result<get_device::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let device = services()
+	let device = services
 		.users
 		.get_device_metadata(sender_user, &body.body.device_id)?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;
@@ -43,17 +48,19 @@ pub(crate) async fn get_device_route(body: Ruma<get_device::v3::Request>) -> Res
 /// # `PUT /_matrix/client/r0/devices/{deviceId}`
 ///
 /// Updates the metadata on a given device of the sender user.
-pub(crate) async fn update_device_route(body: Ruma<update_device::v3::Request>) -> Result<update_device::v3::Response> {
+pub(crate) async fn update_device_route(
+	State(services): State<crate::State>, body: Ruma<update_device::v3::Request>,
+) -> Result<update_device::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let mut device = services()
+	let mut device = services
 		.users
 		.get_device_metadata(sender_user, &body.device_id)?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;
 
 	device.display_name.clone_from(&body.display_name);
 
-	services()
+	services
 		.users
 		.update_device_metadata(sender_user, &body.device_id, &device)?;
 
@@ -70,7 +77,9 @@ pub(crate) async fn update_device_route(body: Ruma<update_device::v3::Request>)
 ///   last seen ts)
 /// - Forgets to-device events
 /// - Triggers device list updates
-pub(crate) async fn delete_device_route(body: Ruma<delete_device::v3::Request>) -> Result<delete_device::v3::Response> {
+pub(crate) async fn delete_device_route(
+	State(services): State<crate::State>, body: Ruma<delete_device::v3::Request>,
+) -> Result<delete_device::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
@@ -86,7 +95,7 @@ pub(crate) async fn delete_device_route(body: Ruma<delete_device::v3::Request>)
 	};
 
 	if let Some(auth) = &body.auth {
-		let (worked, uiaainfo) = services()
+		let (worked, uiaainfo) = services
 			.uiaa
 			.try_auth(sender_user, sender_device, auth, &uiaainfo)?;
 		if !worked {
@@ -95,7 +104,7 @@ pub(crate) async fn delete_device_route(body: Ruma<delete_device::v3::Request>)
 	// Success!
 	} else if let Some(json) = body.json_body {
 		uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-		services()
+		services
 			.uiaa
 			.create(sender_user, sender_device, &uiaainfo, &json)?;
 		return Err(Error::Uiaa(uiaainfo));
@@ -103,9 +112,7 @@ pub(crate) async fn delete_device_route(body: Ruma<delete_device::v3::Request>)
 		return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
 	}
 
-	services()
-		.users
-		.remove_device(sender_user, &body.device_id)?;
+	services.users.remove_device(sender_user, &body.device_id)?;
 
 	Ok(delete_device::v3::Response {})
 }
@@ -123,7 +130,7 @@ pub(crate) async fn delete_device_route(body: Ruma<delete_device::v3::Request>)
 /// - Forgets to-device events
 /// - Triggers device list updates
 pub(crate) async fn delete_devices_route(
-	body: Ruma<delete_devices::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<delete_devices::v3::Request>,
 ) -> Result<delete_devices::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
@@ -140,7 +147,7 @@ pub(crate) async fn delete_devices_route(
 	};
 
 	if let Some(auth) = &body.auth {
-		let (worked, uiaainfo) = services()
+		let (worked, uiaainfo) = services
 			.uiaa
 			.try_auth(sender_user, sender_device, auth, &uiaainfo)?;
 		if !worked {
@@ -149,7 +156,7 @@ pub(crate) async fn delete_devices_route(
 	// Success!
 	} else if let Some(json) = body.json_body {
 		uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-		services()
+		services
 			.uiaa
 			.create(sender_user, sender_device, &uiaainfo, &json)?;
 		return Err(Error::Uiaa(uiaainfo));
@@ -158,7 +165,7 @@ pub(crate) async fn delete_devices_route(
 	}
 
 	for device_id in &body.devices {
-		services().users.remove_device(sender_user, device_id)?;
+		services.users.remove_device(sender_user, device_id)?;
 	}
 
 	Ok(delete_devices::v3::Response {})

src/api/client/directory.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use axum_client_ip::InsecureClientIp;
 use conduit::{err, info, warn, Error, Result};
 use ruma::{
@@ -19,8 +20,9 @@ use ruma::{
 	},
 	uint, RoomId, ServerName, UInt, UserId,
 };
+use service::Services;
 
-use crate::{service::server_is_ours, services, Ruma};
+use crate::Ruma;
 
 /// # `POST /_matrix/client/v3/publicRooms`
 ///
@@ -29,10 +31,11 @@ use crate::{service::server_is_ours, services, Ruma};
 /// - Rooms are ordered by the number of joined members
 #[tracing::instrument(skip_all, fields(%client), name = "publicrooms")]
 pub(crate) async fn get_public_rooms_filtered_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_public_rooms_filtered::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_public_rooms_filtered::v3::Request>,
 ) -> Result<get_public_rooms_filtered::v3::Response> {
 	if let Some(server) = &body.server {
-		if services()
+		if services
 			.globals
 			.forbidden_remote_room_directory_server_names()
 			.contains(server)
@@ -45,6 +48,7 @@ pub(crate) async fn get_public_rooms_filtered_route(
 	}
 
 	let response = get_public_rooms_filtered_helper(
+		&services,
 		body.server.as_deref(),
 		body.limit,
 		body.since.as_deref(),
@@ -67,10 +71,11 @@ pub(crate) async fn get_public_rooms_filtered_route(
 /// - Rooms are ordered by the number of joined members
 #[tracing::instrument(skip_all, fields(%client), name = "publicrooms")]
 pub(crate) async fn get_public_rooms_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_public_rooms::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_public_rooms::v3::Request>,
 ) -> Result<get_public_rooms::v3::Response> {
 	if let Some(server) = &body.server {
-		if services()
+		if services
 			.globals
 			.forbidden_remote_room_directory_server_names()
 			.contains(server)
@@ -83,6 +88,7 @@ pub(crate) async fn get_public_rooms_route(
 	}
 
 	let response = get_public_rooms_filtered_helper(
+		&services,
 		body.server.as_deref(),
 		body.limit,
 		body.since.as_deref(),
@@ -108,16 +114,17 @@ pub(crate) async fn get_public_rooms_route(
 /// Sets the visibility of a given room in the room directory.
 #[tracing::instrument(skip_all, fields(%client), name = "room_directory")]
 pub(crate) async fn set_room_visibility_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<set_room_visibility::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<set_room_visibility::v3::Request>,
 ) -> Result<set_room_visibility::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	if !services().rooms.metadata.exists(&body.room_id)? {
+	if !services.rooms.metadata.exists(&body.room_id)? {
 		// Return 404 if the room doesn't exist
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Room not found"));
 	}
 
-	if !user_can_publish_room(sender_user, &body.room_id)? {
+	if !user_can_publish_room(&services, sender_user, &body.room_id)? {
 		return Err(Error::BadRequest(
 			ErrorKind::forbidden(),
 			"User is not allowed to publish this room",
@@ -126,7 +133,7 @@ pub(crate) async fn set_room_visibility_route(
 
 	match &body.visibility {
 		room::Visibility::Public => {
-			if services().globals.config.lockdown_public_room_directory && !services().users.is_admin(sender_user)? {
+			if services.globals.config.lockdown_public_room_directory && !services.users.is_admin(sender_user)? {
 				info!(
 					"Non-admin user {sender_user} tried to publish {0} to the room directory while \
 					 \"lockdown_public_room_directory\" is enabled",
@@ -139,10 +146,10 @@ pub(crate) async fn set_room_visibility_route(
 				));
 			}
 
-			services().rooms.directory.set_public(&body.room_id)?;
+			services.rooms.directory.set_public(&body.room_id)?;
 			info!("{sender_user} made {0} public", body.room_id);
 		},
-		room::Visibility::Private => services().rooms.directory.set_not_public(&body.room_id)?,
+		room::Visibility::Private => services.rooms.directory.set_not_public(&body.room_id)?,
 		_ => {
 			return Err(Error::BadRequest(
 				ErrorKind::InvalidParam,
@@ -158,15 +165,15 @@ pub(crate) async fn set_room_visibility_route(
 ///
 /// Gets the visibility of a given room in the room directory.
 pub(crate) async fn get_room_visibility_route(
-	body: Ruma<get_room_visibility::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_room_visibility::v3::Request>,
 ) -> Result<get_room_visibility::v3::Response> {
-	if !services().rooms.metadata.exists(&body.room_id)? {
+	if !services.rooms.metadata.exists(&body.room_id)? {
 		// Return 404 if the room doesn't exist
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Room not found"));
 	}
 
 	Ok(get_room_visibility::v3::Response {
-		visibility: if services().rooms.directory.is_public_room(&body.room_id)? {
+		visibility: if services.rooms.directory.is_public_room(&body.room_id)? {
 			room::Visibility::Public
 		} else {
 			room::Visibility::Private
@@ -175,10 +182,11 @@ pub(crate) async fn get_room_visibility_route(
 }
 
 pub(crate) async fn get_public_rooms_filtered_helper(
-	server: Option<&ServerName>, limit: Option<UInt>, since: Option<&str>, filter: &Filter, _network: &RoomNetwork,
+	services: &Services, server: Option<&ServerName>, limit: Option<UInt>, since: Option<&str>, filter: &Filter,
+	_network: &RoomNetwork,
 ) -> Result<get_public_rooms_filtered::v3::Response> {
-	if let Some(other_server) = server.filter(|server_name| !server_is_ours(server_name)) {
-		let response = services()
+	if let Some(other_server) = server.filter(|server_name| !services.globals.server_is_ours(server_name)) {
+		let response = services
 			.sending
 			.send_federation_request(
 				other_server,
@@ -224,7 +232,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 		}
 	}
 
-	let mut all_rooms: Vec<_> = services()
+	let mut all_rooms: Vec<_> = services
 		.rooms
 		.directory
 		.public_rooms()
@@ -232,12 +240,12 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 			let room_id = room_id?;
 
 			let chunk = PublicRoomsChunk {
-				canonical_alias: services()
+				canonical_alias: services
 					.rooms
 					.state_accessor
 					.get_canonical_alias(&room_id)?,
-				name: services().rooms.state_accessor.get_name(&room_id)?,
-				num_joined_members: services()
+				name: services.rooms.state_accessor.get_name(&room_id)?,
+				num_joined_members: services
 					.rooms
 					.state_cache
 					.room_joined_count(&room_id)?
@@ -247,24 +255,24 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 					})
 					.try_into()
 					.expect("user count should not be that big"),
-				topic: services()
+				topic: services
 					.rooms
 					.state_accessor
 					.get_room_topic(&room_id)
 					.unwrap_or(None),
-				world_readable: services().rooms.state_accessor.is_world_readable(&room_id)?,
-				guest_can_join: services()
+				world_readable: services.rooms.state_accessor.is_world_readable(&room_id)?,
+				guest_can_join: services
 					.rooms
 					.state_accessor
 					.guest_can_join(&room_id)?,
-				avatar_url: services()
+				avatar_url: services
 					.rooms
 					.state_accessor
 					.get_avatar(&room_id)?
 					.into_option()
 					.unwrap_or_default()
 					.url,
-				join_rule: services()
+				join_rule: services
 					.rooms
 					.state_accessor
 					.room_state_get(&room_id, &StateEventType::RoomJoinRules, "")?
@@ -282,7 +290,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 					.transpose()?
 					.flatten()
 					.ok_or_else(|| Error::bad_database("Missing room join rule event for room."))?,
-				room_type: services()
+				room_type: services
 					.rooms
 					.state_accessor
 					.get_room_type(&room_id)?,
@@ -361,12 +369,11 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 
 /// Check whether the user can publish to the room directory via power levels of
 /// room history visibility event or room creator
-fn user_can_publish_room(user_id: &UserId, room_id: &RoomId) -> Result<bool> {
-	if let Some(event) =
-		services()
-			.rooms
-			.state_accessor
-			.room_state_get(room_id, &StateEventType::RoomPowerLevels, "")?
+fn user_can_publish_room(services: &Services, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+	if let Some(event) = services
+		.rooms
+		.state_accessor
+		.room_state_get(room_id, &StateEventType::RoomPowerLevels, "")?
 	{
 		serde_json::from_str(event.content.get())
 			.map_err(|_| Error::bad_database("Invalid event content for m.room.power_levels"))
@@ -374,7 +381,7 @@ fn user_can_publish_room(user_id: &UserId, room_id: &RoomId) -> Result<bool> {
 				RoomPowerLevels::from(content).user_can_send_state(user_id, StateEventType::RoomHistoryVisibility)
 			})
 	} else if let Some(event) =
-		services()
+		services
 			.rooms
 			.state_accessor
 			.room_state_get(room_id, &StateEventType::RoomCreate, "")?

src/api/client/filter.rs

@@ -1,18 +1,21 @@
+use axum::extract::State;
 use ruma::api::client::{
 	error::ErrorKind,
 	filter::{create_filter, get_filter},
 };
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `GET /_matrix/client/r0/user/{userId}/filter/{filterId}`
 ///
 /// Loads a filter that was previously created.
 ///
 /// - A user can only access their own filters
-pub(crate) async fn get_filter_route(body: Ruma<get_filter::v3::Request>) -> Result<get_filter::v3::Response> {
+pub(crate) async fn get_filter_route(
+	State(services): State<crate::State>, body: Ruma<get_filter::v3::Request>,
+) -> Result<get_filter::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-	let Some(filter) = services().users.get_filter(sender_user, &body.filter_id)? else {
+	let Some(filter) = services.users.get_filter(sender_user, &body.filter_id)? else {
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Filter not found."));
 	};
 
@@ -22,9 +25,11 @@ pub(crate) async fn get_filter_route(body: Ruma<get_filter::v3::Request>) -> Res
 /// # `PUT /_matrix/client/r0/user/{userId}/filter`
 ///
 /// Creates a new filter to be used by other endpoints.
-pub(crate) async fn create_filter_route(body: Ruma<create_filter::v3::Request>) -> Result<create_filter::v3::Response> {
+pub(crate) async fn create_filter_route(
+	State(services): State<crate::State>, body: Ruma<create_filter::v3::Request>,
+) -> Result<create_filter::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	Ok(create_filter::v3::Response::new(
-		services().users.create_filter(sender_user, &body.filter)?,
+		services.users.create_filter(sender_user, &body.filter)?,
 	))
 }

src/api/client/keys.rs

@@ -3,7 +3,8 @@ use std::{
 	time::Instant,
 };
 
-use conduit::{utils, utils::math::continue_exponential_backoff_secs, Error, Result};
+use axum::extract::State;
+use conduit::{debug, utils, utils::math::continue_exponential_backoff_secs, Error, Result};
 use futures_util::{stream::FuturesUnordered, StreamExt};
 use ruma::{
 	api::{
@@ -18,11 +19,9 @@ use ruma::{
 	DeviceKeyAlgorithm, OwnedDeviceId, OwnedUserId, UserId,
 };
 use serde_json::json;
-use service::user_is_local;
-use tracing::debug;
 
 use super::SESSION_ID_LENGTH;
-use crate::{services, Ruma};
+use crate::{service::Services, Ruma};
 
 /// # `POST /_matrix/client/r0/keys/upload`
 ///
@@ -31,12 +30,14 @@ use crate::{services, Ruma};
 /// - Adds one time keys
 /// - If there are no device keys yet: Adds device keys (TODO: merge with
 ///   existing keys?)
-pub(crate) async fn upload_keys_route(body: Ruma<upload_keys::v3::Request>) -> Result<upload_keys::v3::Response> {
+pub(crate) async fn upload_keys_route(
+	State(services): State<crate::State>, body: Ruma<upload_keys::v3::Request>,
+) -> Result<upload_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
 	for (key_key, key_value) in &body.one_time_keys {
-		services()
+		services
 			.users
 			.add_one_time_key(sender_user, sender_device, key_key, key_value)?;
 	}
@@ -44,19 +45,19 @@ pub(crate) async fn upload_keys_route(body: Ruma<upload_keys::v3::Request>) -> R
 	if let Some(device_keys) = &body.device_keys {
 		// TODO: merge this and the existing event?
 		// This check is needed to assure that signatures are kept
-		if services()
+		if services
 			.users
 			.get_device_keys(sender_user, sender_device)?
 			.is_none()
 		{
-			services()
+			services
 				.users
 				.add_device_keys(sender_user, sender_device, device_keys)?;
 		}
 	}
 
 	Ok(upload_keys::v3::Response {
-		one_time_key_counts: services()
+		one_time_key_counts: services
 			.users
 			.count_one_time_keys(sender_user, sender_device)?,
 	})
@@ -70,10 +71,13 @@ pub(crate) async fn upload_keys_route(body: Ruma<upload_keys::v3::Request>) -> R
 /// - Gets master keys, self-signing keys, user signing keys and device keys.
 /// - The master and self-signing keys contain signatures that the user is
 ///   allowed to see
-pub(crate) async fn get_keys_route(body: Ruma<get_keys::v3::Request>) -> Result<get_keys::v3::Response> {
+pub(crate) async fn get_keys_route(
+	State(services): State<crate::State>, body: Ruma<get_keys::v3::Request>,
+) -> Result<get_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	get_keys_helper(
+		&services,
 		Some(sender_user),
 		&body.device_keys,
 		|u| u == sender_user,
@@ -85,8 +89,10 @@ pub(crate) async fn get_keys_route(body: Ruma<get_keys::v3::Request>) -> Result<
 /// # `POST /_matrix/client/r0/keys/claim`
 ///
 /// Claims one-time keys
-pub(crate) async fn claim_keys_route(body: Ruma<claim_keys::v3::Request>) -> Result<claim_keys::v3::Response> {
-	claim_keys_helper(&body.one_time_keys).await
+pub(crate) async fn claim_keys_route(
+	State(services): State<crate::State>, body: Ruma<claim_keys::v3::Request>,
+) -> Result<claim_keys::v3::Response> {
+	claim_keys_helper(&services, &body.one_time_keys).await
 }
 
 /// # `POST /_matrix/client/r0/keys/device_signing/upload`
@@ -95,7 +101,7 @@ pub(crate) async fn claim_keys_route(body: Ruma<claim_keys::v3::Request>) -> Res
 ///
 /// - Requires UIAA to verify password
 pub(crate) async fn upload_signing_keys_route(
-	body: Ruma<upload_signing_keys::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<upload_signing_keys::v3::Request>,
 ) -> Result<upload_signing_keys::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
@@ -112,7 +118,7 @@ pub(crate) async fn upload_signing_keys_route(
 	};
 
 	if let Some(auth) = &body.auth {
-		let (worked, uiaainfo) = services()
+		let (worked, uiaainfo) = services
 			.uiaa
 			.try_auth(sender_user, sender_device, auth, &uiaainfo)?;
 		if !worked {
@@ -121,7 +127,7 @@ pub(crate) async fn upload_signing_keys_route(
 	// Success!
 	} else if let Some(json) = body.json_body {
 		uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-		services()
+		services
 			.uiaa
 			.create(sender_user, sender_device, &uiaainfo, &json)?;
 		return Err(Error::Uiaa(uiaainfo));
@@ -130,7 +136,7 @@ pub(crate) async fn upload_signing_keys_route(
 	}
 
 	if let Some(master_key) = &body.master_key {
-		services().users.add_cross_signing_keys(
+		services.users.add_cross_signing_keys(
 			sender_user,
 			master_key,
 			&body.self_signing_key,
@@ -146,7 +152,7 @@ pub(crate) async fn upload_signing_keys_route(
 ///
 /// Uploads end-to-end key signatures from the sender user.
 pub(crate) async fn upload_signatures_route(
-	body: Ruma<upload_signatures::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<upload_signatures::v3::Request>,
 ) -> Result<upload_signatures::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -173,7 +179,7 @@ pub(crate) async fn upload_signatures_route(
 						.ok_or(Error::BadRequest(ErrorKind::InvalidParam, "Invalid signature value."))?
 						.to_owned(),
 				);
-				services()
+				services
 					.users
 					.sign_key(user_id, key_id, signature, sender_user)?;
 			}
@@ -192,14 +198,14 @@ pub(crate) async fn upload_signatures_route(
 ///
 /// - TODO: left users
 pub(crate) async fn get_key_changes_route(
-	body: Ruma<get_key_changes::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_key_changes::v3::Request>,
 ) -> Result<get_key_changes::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let mut device_list_updates = HashSet::new();
 
 	device_list_updates.extend(
-		services()
+		services
 			.users
 			.keys_changed(
 				sender_user.as_str(),
@@ -215,14 +221,14 @@ pub(crate) async fn get_key_changes_route(
 			.filter_map(Result::ok),
 	);
 
-	for room_id in services()
+	for room_id in services
 		.rooms
 		.state_cache
 		.rooms_joined(sender_user)
 		.filter_map(Result::ok)
 	{
 		device_list_updates.extend(
-			services()
+			services
 				.users
 				.keys_changed(
 					room_id.as_ref(),
@@ -245,8 +251,8 @@ pub(crate) async fn get_key_changes_route(
 }
 
 pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool + Send>(
-	sender_user: Option<&UserId>, device_keys_input: &BTreeMap<OwnedUserId, Vec<OwnedDeviceId>>, allowed_signatures: F,
-	include_display_names: bool,
+	services: &Services, sender_user: Option<&UserId>, device_keys_input: &BTreeMap<OwnedUserId, Vec<OwnedDeviceId>>,
+	allowed_signatures: F, include_display_names: bool,
 ) -> Result<get_keys::v3::Response> {
 	let mut master_keys = BTreeMap::new();
 	let mut self_signing_keys = BTreeMap::new();
@@ -258,7 +264,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool + Send>(
 	for (user_id, device_ids) in device_keys_input {
 		let user_id: &UserId = user_id;
 
-		if !user_is_local(user_id) {
+		if !services.globals.user_is_local(user_id) {
 			get_over_federation
 				.entry(user_id.server_name())
 				.or_insert_with(Vec::new)
@@ -268,10 +274,10 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool + Send>(
 
 		if device_ids.is_empty() {
 			let mut container = BTreeMap::new();
-			for device_id in services().users.all_device_ids(user_id) {
+			for device_id in services.users.all_device_ids(user_id) {
 				let device_id = device_id?;
-				if let Some(mut keys) = services().users.get_device_keys(user_id, &device_id)? {
-					let metadata = services()
+				if let Some(mut keys) = services.users.get_device_keys(user_id, &device_id)? {
+					let metadata = services
 						.users
 						.get_device_metadata(user_id, &device_id)?
 						.ok_or_else(|| Error::bad_database("all_device_keys contained nonexistent device."))?;
@@ -286,8 +292,8 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool + Send>(
 		} else {
 			for device_id in device_ids {
 				let mut container = BTreeMap::new();
-				if let Some(mut keys) = services().users.get_device_keys(user_id, device_id)? {
-					let metadata = services()
+				if let Some(mut keys) = services.users.get_device_keys(user_id, device_id)? {
+					let metadata = services
 						.users
 						.get_device_metadata(user_id, device_id)?
 						.ok_or(Error::BadRequest(
@@ -303,21 +309,21 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool + Send>(
 			}
 		}
 
-		if let Some(master_key) = services()
+		if let Some(master_key) = services
 			.users
 			.get_master_key(sender_user, user_id, &allowed_signatures)?
 		{
 			master_keys.insert(user_id.to_owned(), master_key);
 		}
 		if let Some(self_signing_key) =
-			services()
+			services
 				.users
 				.get_self_signing_key(sender_user, user_id, &allowed_signatures)?
 		{
 			self_signing_keys.insert(user_id.to_owned(), self_signing_key);
 		}
 		if Some(user_id) == sender_user {
-			if let Some(user_signing_key) = services().users.get_user_signing_key(user_id)? {
+			if let Some(user_signing_key) = services.users.get_user_signing_key(user_id)? {
 				user_signing_keys.insert(user_id.to_owned(), user_signing_key);
 			}
 		}
@@ -326,7 +332,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool + Send>(
 	let mut failures = BTreeMap::new();
 
 	let back_off = |id| async {
-		match services()
+		match services
 			.globals
 			.bad_query_ratelimiter
 			.write()
@@ -345,7 +351,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool + Send>(
 	let mut futures: FuturesUnordered<_> = get_over_federation
 		.into_iter()
 		.map(|(server, vec)| async move {
-			if let Some((time, tries)) = services()
+			if let Some((time, tries)) = services
 				.globals
 				.bad_query_ratelimiter
 				.read()
@@ -369,7 +375,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool + Send>(
 			let request = federation::keys::get_keys::v1::Request {
 				device_keys: device_keys_input_fed,
 			};
-			let response = services()
+			let response = services
 				.sending
 				.send_federation_request(server, request)
 				.await;
@@ -381,19 +387,19 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool + Send>(
 	while let Some((server, response)) = futures.next().await {
 		if let Ok(Ok(response)) = response {
 			for (user, masterkey) in response.master_keys {
-				let (master_key_id, mut master_key) = services().users.parse_master_key(&user, &masterkey)?;
+				let (master_key_id, mut master_key) = services.users.parse_master_key(&user, &masterkey)?;
 
 				if let Some(our_master_key) =
-					services()
+					services
 						.users
 						.get_key(&master_key_id, sender_user, &user, &allowed_signatures)?
 				{
-					let (_, our_master_key) = services().users.parse_master_key(&user, &our_master_key)?;
+					let (_, our_master_key) = services.users.parse_master_key(&user, &our_master_key)?;
 					master_key.signatures.extend(our_master_key.signatures);
 				}
 				let json = serde_json::to_value(master_key).expect("to_value always works");
 				let raw = serde_json::from_value(json).expect("Raw::from_value always works");
-				services().users.add_cross_signing_keys(
+				services.users.add_cross_signing_keys(
 					&user, &raw, &None, &None,
 					false, /* Dont notify. A notification would trigger another key request resulting in an
 					       * endless loop */
@@ -444,14 +450,14 @@ fn add_unsigned_device_display_name(
 }
 
 pub(crate) async fn claim_keys_helper(
-	one_time_keys_input: &BTreeMap<OwnedUserId, BTreeMap<OwnedDeviceId, DeviceKeyAlgorithm>>,
+	services: &Services, one_time_keys_input: &BTreeMap<OwnedUserId, BTreeMap<OwnedDeviceId, DeviceKeyAlgorithm>>,
 ) -> Result<claim_keys::v3::Response> {
 	let mut one_time_keys = BTreeMap::new();
 
 	let mut get_over_federation = BTreeMap::new();
 
 	for (user_id, map) in one_time_keys_input {
-		if !user_is_local(user_id) {
+		if !services.globals.user_is_local(user_id) {
 			get_over_federation
 				.entry(user_id.server_name())
 				.or_insert_with(Vec::new)
@@ -460,7 +466,7 @@ pub(crate) async fn claim_keys_helper(
 
 		let mut container = BTreeMap::new();
 		for (device_id, key_algorithm) in map {
-			if let Some(one_time_keys) = services()
+			if let Some(one_time_keys) = services
 				.users
 				.take_one_time_key(user_id, device_id, key_algorithm)?
 			{
@@ -483,7 +489,7 @@ pub(crate) async fn claim_keys_helper(
 			}
 			(
 				server,
-				services()
+				services
 					.sending
 					.send_federation_request(
 						server,

src/api/client/media.rs

@@ -1,9 +1,18 @@
 #![allow(deprecated)]
 
-use std::{io::Cursor, sync::Arc, time::Duration};
+use std::{io::Cursor, time::Duration};
 
+use axum::extract::State;
 use axum_client_ip::InsecureClientIp;
-use conduit::{debug, error, utils::math::ruma_from_usize, warn};
+use conduit::{
+	debug, debug_warn, error,
+	utils::{
+		self,
+		content_disposition::{content_disposition_type, make_content_disposition, sanitise_filename},
+		math::ruma_from_usize,
+	},
+	warn, Error, Result,
+};
 use image::io::Reader as ImgReader;
 use ipaddress::IPAddress;
 use reqwest::Url;
@@ -14,21 +23,13 @@ use ruma::api::client::{
 		get_media_preview,
 	},
 };
+use service::{
+	media::{FileMeta, UrlPreviewData},
+	Services,
+};
 use webpage::HTML;
 
-use crate::{
-	debug_warn,
-	service::{
-		media::{FileMeta, UrlPreviewData},
-		server_is_ours,
-	},
-	services,
-	utils::{
-		self,
-		content_disposition::{content_disposition_type, make_content_disposition, sanitise_filename},
-	},
-	Error, Result, Ruma, RumaResponse,
-};
+use crate::{Ruma, RumaResponse};
 
 /// generated MXC ID (`media-id`) length
 const MXC_LENGTH: usize = 32;
@@ -42,10 +43,10 @@ const CORP_CROSS_ORIGIN: &str = "cross-origin";
 ///
 /// Returns max upload size.
 pub(crate) async fn get_media_config_route(
-	_body: Ruma<get_media_config::v3::Request>,
+	State(services): State<crate::State>, _body: Ruma<get_media_config::v3::Request>,
 ) -> Result<get_media_config::v3::Response> {
 	Ok(get_media_config::v3::Response {
-		upload_size: ruma_from_usize(services().globals.config.max_request_size),
+		upload_size: ruma_from_usize(services.globals.config.max_request_size),
 	})
 }
 
@@ -57,9 +58,11 @@ pub(crate) async fn get_media_config_route(
 ///
 /// Returns max upload size.
 pub(crate) async fn get_media_config_v1_route(
-	body: Ruma<get_media_config::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_media_config::v3::Request>,
 ) -> Result<RumaResponse<get_media_config::v3::Response>> {
-	get_media_config_route(body).await.map(RumaResponse)
+	get_media_config_route(State(services), body)
+		.await
+		.map(RumaResponse)
 }
 
 /// # `GET /_matrix/media/v3/preview_url`
@@ -67,17 +70,18 @@ pub(crate) async fn get_media_config_v1_route(
 /// Returns URL preview.
 #[tracing::instrument(skip_all, fields(%client), name = "url_preview")]
 pub(crate) async fn get_media_preview_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_media_preview::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_media_preview::v3::Request>,
 ) -> Result<get_media_preview::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let url = &body.url;
-	if !url_preview_allowed(url) {
+	if !url_preview_allowed(&services, url) {
 		warn!(%sender_user, "URL is not allowed to be previewed: {url}");
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "URL is not allowed to be previewed"));
 	}
 
-	match get_url_preview(url).await {
+	match get_url_preview(&services, url).await {
 		Ok(preview) => {
 			let res = serde_json::value::to_raw_value(&preview).map_err(|e| {
 				error!(%sender_user, "Failed to convert UrlPreviewData into a serde json value: {e}");
@@ -115,9 +119,10 @@ pub(crate) async fn get_media_preview_route(
 /// Returns URL preview.
 #[tracing::instrument(skip_all, fields(%client), name = "url_preview")]
 pub(crate) async fn get_media_preview_v1_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_media_preview::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_media_preview::v3::Request>,
 ) -> Result<RumaResponse<get_media_preview::v3::Response>> {
-	get_media_preview_route(InsecureClientIp(client), body)
+	get_media_preview_route(State(services), InsecureClientIp(client), body)
 		.await
 		.map(RumaResponse)
 }
@@ -130,17 +135,14 @@ pub(crate) async fn get_media_preview_v1_route(
 /// - Media will be saved in the media/ directory
 #[tracing::instrument(skip_all, fields(%client), name = "media_upload")]
 pub(crate) async fn create_content_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<create_content::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<create_content::v3::Request>,
 ) -> Result<create_content::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let mxc = format!(
-		"mxc://{}/{}",
-		services().globals.server_name(),
-		utils::random_string(MXC_LENGTH)
-	);
+	let mxc = format!("mxc://{}/{}", services.globals.server_name(), utils::random_string(MXC_LENGTH));
 
-	services()
+	services
 		.media
 		.create(
 			Some(sender_user.clone()),
@@ -178,9 +180,10 @@ pub(crate) async fn create_content_route(
 /// - Media will be saved in the media/ directory
 #[tracing::instrument(skip_all, fields(%client), name = "media_upload")]
 pub(crate) async fn create_content_v1_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<create_content::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<create_content::v3::Request>,
 ) -> Result<RumaResponse<create_content::v3::Response>> {
-	create_content_route(InsecureClientIp(client), body)
+	create_content_route(State(services), InsecureClientIp(client), body)
 		.await
 		.map(RumaResponse)
 }
@@ -195,7 +198,8 @@ pub(crate) async fn create_content_v1_route(
 ///   seconds
 #[tracing::instrument(skip_all, fields(%client), name = "media_get")]
 pub(crate) async fn get_content_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_content::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_content::v3::Request>,
 ) -> Result<get_content::v3::Response> {
 	let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
 
@@ -203,7 +207,7 @@ pub(crate) async fn get_content_route(
 		content,
 		content_type,
 		content_disposition,
-	}) = services().media.get(&mxc).await?
+	}) = services.media.get(&mxc).await?
 	{
 		let content_disposition = Some(make_content_disposition(&content_type, content_disposition, None));
 		let file = content.expect("content");
@@ -215,8 +219,9 @@ pub(crate) async fn get_content_route(
 			cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.to_owned()),
 			cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
 		})
-	} else if !server_is_ours(&body.server_name) && body.allow_remote {
+	} else if !services.globals.server_is_ours(&body.server_name) && body.allow_remote {
 		let response = get_remote_content(
+			&services,
 			&mxc,
 			&body.server_name,
 			body.media_id.clone(),
@@ -261,9 +266,10 @@ pub(crate) async fn get_content_route(
 ///   seconds
 #[tracing::instrument(skip_all, fields(%client), name = "media_get")]
 pub(crate) async fn get_content_v1_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_content::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_content::v3::Request>,
 ) -> Result<RumaResponse<get_content::v3::Response>> {
-	get_content_route(InsecureClientIp(client), body)
+	get_content_route(State(services), InsecureClientIp(client), body)
 		.await
 		.map(RumaResponse)
 }
@@ -278,7 +284,8 @@ pub(crate) async fn get_content_v1_route(
 ///   seconds
 #[tracing::instrument(skip_all, fields(%client), name = "media_get")]
 pub(crate) async fn get_content_as_filename_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_content_as_filename::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_content_as_filename::v3::Request>,
 ) -> Result<get_content_as_filename::v3::Response> {
 	let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
 
@@ -286,7 +293,7 @@ pub(crate) async fn get_content_as_filename_route(
 		content,
 		content_type,
 		content_disposition,
-	}) = services().media.get(&mxc).await?
+	}) = services.media.get(&mxc).await?
 	{
 		let content_disposition = Some(make_content_disposition(
 			&content_type,
@@ -302,8 +309,9 @@ pub(crate) async fn get_content_as_filename_route(
 			cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.to_owned()),
 			cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
 		})
-	} else if !server_is_ours(&body.server_name) && body.allow_remote {
+	} else if !services.globals.server_is_ours(&body.server_name) && body.allow_remote {
 		match get_remote_content(
+			&services,
 			&mxc,
 			&body.server_name,
 			body.media_id.clone(),
@@ -351,9 +359,10 @@ pub(crate) async fn get_content_as_filename_route(
 ///   seconds
 #[tracing::instrument(skip_all, fields(%client), name = "media_get")]
 pub(crate) async fn get_content_as_filename_v1_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_content_as_filename::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_content_as_filename::v3::Request>,
 ) -> Result<RumaResponse<get_content_as_filename::v3::Response>> {
-	get_content_as_filename_route(InsecureClientIp(client), body)
+	get_content_as_filename_route(State(services), InsecureClientIp(client), body)
 		.await
 		.map(RumaResponse)
 }
@@ -368,7 +377,8 @@ pub(crate) async fn get_content_as_filename_v1_route(
 ///   seconds
 #[tracing::instrument(skip_all, fields(%client), name = "media_thumbnail_get")]
 pub(crate) async fn get_content_thumbnail_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_content_thumbnail::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_content_thumbnail::v3::Request>,
 ) -> Result<get_content_thumbnail::v3::Response> {
 	let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
 
@@ -376,7 +386,7 @@ pub(crate) async fn get_content_thumbnail_route(
 		content,
 		content_type,
 		content_disposition,
-	}) = services()
+	}) = services
 		.media
 		.get_thumbnail(
 			&mxc,
@@ -399,8 +409,8 @@ pub(crate) async fn get_content_thumbnail_route(
 			cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
 			content_disposition,
 		})
-	} else if !server_is_ours(&body.server_name) && body.allow_remote {
-		if services()
+	} else if !services.globals.server_is_ours(&body.server_name) && body.allow_remote {
+		if services
 			.globals
 			.prevent_media_downloads_from()
 			.contains(&body.server_name)
@@ -411,7 +421,7 @@ pub(crate) async fn get_content_thumbnail_route(
 			return Err(Error::BadRequest(ErrorKind::NotFound, "Media not found."));
 		}
 
-		match services()
+		match services
 			.sending
 			.send_federation_request(
 				&body.server_name,
@@ -430,7 +440,7 @@ pub(crate) async fn get_content_thumbnail_route(
 			.await
 		{
 			Ok(get_thumbnail_response) => {
-				services()
+				services
 					.media
 					.upload_thumbnail(
 						None,
@@ -481,17 +491,19 @@ pub(crate) async fn get_content_thumbnail_route(
 ///   seconds
 #[tracing::instrument(skip_all, fields(%client), name = "media_thumbnail_get")]
 pub(crate) async fn get_content_thumbnail_v1_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_content_thumbnail::v3::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_content_thumbnail::v3::Request>,
 ) -> Result<RumaResponse<get_content_thumbnail::v3::Response>> {
-	get_content_thumbnail_route(InsecureClientIp(client), body)
+	get_content_thumbnail_route(State(services), InsecureClientIp(client), body)
 		.await
 		.map(RumaResponse)
 }
 
 async fn get_remote_content(
-	mxc: &str, server_name: &ruma::ServerName, media_id: String, allow_redirect: bool, timeout_ms: Duration,
+	services: &Services, mxc: &str, server_name: &ruma::ServerName, media_id: String, allow_redirect: bool,
+	timeout_ms: Duration,
 ) -> Result<get_content::v3::Response, Error> {
-	if services()
+	if services
 		.globals
 		.prevent_media_downloads_from()
 		.contains(&server_name.to_owned())
@@ -502,7 +514,7 @@ async fn get_remote_content(
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Media not found."));
 	}
 
-	let content_response = services()
+	let content_response = services
 		.sending
 		.send_federation_request(
 			server_name,
@@ -522,7 +534,7 @@ async fn get_remote_content(
 		None,
 	));
 
-	services()
+	services
 		.media
 		.create(
 			None,
@@ -542,15 +554,11 @@ async fn get_remote_content(
 	})
 }
 
-async fn download_image(client: &reqwest::Client, url: &str) -> Result<UrlPreviewData> {
+async fn download_image(services: &Services, client: &reqwest::Client, url: &str) -> Result<UrlPreviewData> {
 	let image = client.get(url).send().await?.bytes().await?;
-	let mxc = format!(
-		"mxc://{}/{}",
-		services().globals.server_name(),
-		utils::random_string(MXC_LENGTH)
-	);
+	let mxc = format!("mxc://{}/{}", services.globals.server_name(), utils::random_string(MXC_LENGTH));
 
-	services()
+	services
 		.media
 		.create(None, &mxc, None, None, &image)
 		.await?;
@@ -572,18 +580,18 @@ async fn download_image(client: &reqwest::Client, url: &str) -> Result<UrlPrevie
 	})
 }
 
-async fn download_html(client: &reqwest::Client, url: &str) -> Result<UrlPreviewData> {
+async fn download_html(services: &Services, client: &reqwest::Client, url: &str) -> Result<UrlPreviewData> {
 	let mut response = client.get(url).send().await?;
 
 	let mut bytes: Vec<u8> = Vec::new();
 	while let Some(chunk) = response.chunk().await? {
 		bytes.extend_from_slice(&chunk);
-		if bytes.len() > services().globals.url_preview_max_spider_size() {
+		if bytes.len() > services.globals.url_preview_max_spider_size() {
 			debug!(
 				"Response body from URL {} exceeds url_preview_max_spider_size ({}), not processing the rest of the \
 				 response body and assuming our necessary data is in this range.",
 				url,
-				services().globals.url_preview_max_spider_size()
+				services.globals.url_preview_max_spider_size()
 			);
 			break;
 		}
@@ -595,7 +603,7 @@ async fn download_html(client: &reqwest::Client, url: &str) -> Result<UrlPreview
 
 	let mut data = match html.opengraph.images.first() {
 		None => UrlPreviewData::default(),
-		Some(obj) => download_image(client, &obj.url).await?,
+		Some(obj) => download_image(services, client, &obj.url).await?,
 	};
 
 	let props = html.opengraph.properties;
@@ -607,19 +615,19 @@ async fn download_html(client: &reqwest::Client, url: &str) -> Result<UrlPreview
 	Ok(data)
 }
 
-async fn request_url_preview(url: &str) -> Result<UrlPreviewData> {
+async fn request_url_preview(services: &Services, url: &str) -> Result<UrlPreviewData> {
 	if let Ok(ip) = IPAddress::parse(url) {
-		if !services().globals.valid_cidr_range(&ip) {
+		if !services.globals.valid_cidr_range(&ip) {
 			return Err(Error::BadServerResponse("Requesting from this address is forbidden"));
 		}
 	}
 
-	let client = &services().globals.client.url_preview;
+	let client = &services.client.url_preview;
 	let response = client.head(url).send().await?;
 
 	if let Some(remote_addr) = response.remote_addr() {
 		if let Ok(ip) = IPAddress::parse(remote_addr.ip().to_string()) {
-			if !services().globals.valid_cidr_range(&ip) {
+			if !services.globals.valid_cidr_range(&ip) {
 				return Err(Error::BadServerResponse("Requesting from this address is forbidden"));
 			}
 		}
@@ -633,40 +641,31 @@ async fn request_url_preview(url: &str) -> Result<UrlPreviewData> {
 		return Err(Error::BadRequest(ErrorKind::Unknown, "Unknown Content-Type"));
 	};
 	let data = match content_type {
-		html if html.starts_with("text/html") => download_html(client, url).await?,
-		img if img.starts_with("image/") => download_image(client, url).await?,
+		html if html.starts_with("text/html") => download_html(services, client, url).await?,
+		img if img.starts_with("image/") => download_image(services, client, url).await?,
 		_ => return Err(Error::BadRequest(ErrorKind::Unknown, "Unsupported Content-Type")),
 	};
 
-	services().media.set_url_preview(url, &data).await?;
+	services.media.set_url_preview(url, &data).await?;
 
 	Ok(data)
 }
 
-async fn get_url_preview(url: &str) -> Result<UrlPreviewData> {
-	if let Some(preview) = services().media.get_url_preview(url).await {
+async fn get_url_preview(services: &Services, url: &str) -> Result<UrlPreviewData> {
+	if let Some(preview) = services.media.get_url_preview(url).await {
 		return Ok(preview);
 	}
 
 	// ensure that only one request is made per URL
-	let mutex_request = Arc::clone(
-		services()
-			.media
-			.url_preview_mutex
-			.write()
-			.await
-			.entry(url.to_owned())
-			.or_default(),
-	);
-	let _request_lock = mutex_request.lock().await;
+	let _request_lock = services.media.url_preview_mutex.lock(url).await;
 
-	match services().media.get_url_preview(url).await {
+	match services.media.get_url_preview(url).await {
 		Some(preview) => Ok(preview),
-		None => request_url_preview(url).await,
+		None => request_url_preview(services, url).await,
 	}
 }
 
-fn url_preview_allowed(url_str: &str) -> bool {
+fn url_preview_allowed(services: &Services, url_str: &str) -> bool {
 	let url: Url = match Url::parse(url_str) {
 		Ok(u) => u,
 		Err(e) => {
@@ -691,10 +690,10 @@ fn url_preview_allowed(url_str: &str) -> bool {
 		Some(h) => h.to_owned(),
 	};
 
-	let allowlist_domain_contains = services().globals.url_preview_domain_contains_allowlist();
-	let allowlist_domain_explicit = services().globals.url_preview_domain_explicit_allowlist();
-	let denylist_domain_explicit = services().globals.url_preview_domain_explicit_denylist();
-	let allowlist_url_contains = services().globals.url_preview_url_contains_allowlist();
+	let allowlist_domain_contains = services.globals.url_preview_domain_contains_allowlist();
+	let allowlist_domain_explicit = services.globals.url_preview_domain_explicit_allowlist();
+	let denylist_domain_explicit = services.globals.url_preview_domain_explicit_denylist();
+	let allowlist_url_contains = services.globals.url_preview_url_contains_allowlist();
 
 	if allowlist_domain_contains.contains(&"*".to_owned())
 		|| allowlist_domain_explicit.contains(&"*".to_owned())
@@ -735,7 +734,7 @@ fn url_preview_allowed(url_str: &str) -> bool {
 		}
 
 		// check root domain if available and if user has root domain checks
-		if services().globals.url_preview_check_root_domain() {
+		if services.globals.url_preview_check_root_domain() {
 			debug!("Checking root domain");
 			match host.split_once('.') {
 				None => return false,

src/api/client/message.rs

@@ -1,5 +1,6 @@
 use std::collections::{BTreeMap, HashSet};
 
+use axum::extract::State;
 use conduit::PduCount;
 use ruma::{
 	api::client::{
@@ -12,7 +13,10 @@ use ruma::{
 };
 use serde_json::{from_str, Value};
 
-use crate::{service::pdu::PduBuilder, services, utils, Error, PduEvent, Result, Ruma};
+use crate::{
+	service::{pdu::PduBuilder, Services},
+	utils, Error, PduEvent, Result, Ruma,
+};
 
 /// # `PUT /_matrix/client/v3/rooms/{roomId}/send/{eventType}/{txnId}`
 ///
@@ -24,21 +28,19 @@ use crate::{service::pdu::PduBuilder, services, utils, Error, PduEvent, Result,
 /// - Tries to send the event into the room, auth rules will determine if it is
 ///   allowed
 pub(crate) async fn send_message_event_route(
-	body: Ruma<send_message_event::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<send_message_event::v3::Request>,
 ) -> Result<send_message_event::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_deref();
 
-	let state_lock = services().rooms.state.mutex.lock(&body.room_id).await;
+	let state_lock = services.rooms.state.mutex.lock(&body.room_id).await;
 
 	// Forbid m.room.encrypted if encryption is disabled
-	if MessageLikeEventType::RoomEncrypted == body.event_type && !services().globals.allow_encryption() {
+	if MessageLikeEventType::RoomEncrypted == body.event_type && !services.globals.allow_encryption() {
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Encryption has been disabled"));
 	}
 
-	if body.event_type == MessageLikeEventType::CallInvite
-		&& services().rooms.directory.is_public_room(&body.room_id)?
-	{
+	if body.event_type == MessageLikeEventType::CallInvite && services.rooms.directory.is_public_room(&body.room_id)? {
 		return Err(Error::BadRequest(
 			ErrorKind::forbidden(),
 			"Room call invites are not allowed in public rooms",
@@ -46,7 +48,7 @@ pub(crate) async fn send_message_event_route(
 	}
 
 	// Check if this is a new transaction id
-	if let Some(response) = services()
+	if let Some(response) = services
 		.transaction_ids
 		.existing_txnid(sender_user, sender_device, &body.txn_id)?
 	{
@@ -71,7 +73,7 @@ pub(crate) async fn send_message_event_route(
 	let mut unsigned = BTreeMap::new();
 	unsigned.insert("transaction_id".to_owned(), body.txn_id.to_string().into());
 
-	let event_id = services()
+	let event_id = services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -89,7 +91,7 @@ pub(crate) async fn send_message_event_route(
 		)
 		.await?;
 
-	services()
+	services
 		.transaction_ids
 		.add_txnid(sender_user, sender_device, &body.txn_id, event_id.as_bytes())?;
 
@@ -105,7 +107,7 @@ pub(crate) async fn send_message_event_route(
 /// - Only works if the user is joined (TODO: always allow, but only show events
 ///   where the user was joined, depending on `history_visibility`)
 pub(crate) async fn get_message_events_route(
-	body: Ruma<get_message_events::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_message_events::v3::Request>,
 ) -> Result<get_message_events::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
@@ -123,7 +125,7 @@ pub(crate) async fn get_message_events_route(
 		.as_ref()
 		.and_then(|t| PduCount::try_from_string(t).ok());
 
-	services()
+	services
 		.rooms
 		.lazy_loading
 		.lazy_load_confirm_delivery(sender_user, sender_device, &body.room_id, from)
@@ -139,12 +141,12 @@ pub(crate) async fn get_message_events_route(
 
 	match body.dir {
 		ruma::api::Direction::Forward => {
-			let events_after: Vec<_> = services()
+			let events_after: Vec<_> = services
 				.rooms
 				.timeline
 				.pdus_after(sender_user, &body.room_id, from)?
 				.filter_map(Result::ok) // Filter out buggy events
-				.filter(|(_, pdu)| { contains_url_filter(pdu, &body.filter) && visibility_filter(pdu, sender_user, &body.room_id)
+				.filter(|(_, pdu)| { contains_url_filter(pdu, &body.filter) && visibility_filter(&services, pdu, sender_user, &body.room_id)
 
 				})
 				.take_while(|&(k, _)| Some(k) != to) // Stop at `to`
@@ -157,7 +159,7 @@ pub(crate) async fn get_message_events_route(
 				 * https://github.com/vector-im/element-web/issues/21034
 				 */
 				if !cfg!(feature = "element_hacks")
-					&& !services().rooms.lazy_loading.lazy_load_was_sent_before(
+					&& !services.rooms.lazy_loading.lazy_load_was_sent_before(
 						sender_user,
 						sender_device,
 						&body.room_id,
@@ -181,17 +183,17 @@ pub(crate) async fn get_message_events_route(
 			resp.chunk = events_after;
 		},
 		ruma::api::Direction::Backward => {
-			services()
+			services
 				.rooms
 				.timeline
 				.backfill_if_required(&body.room_id, from)
 				.await?;
-			let events_before: Vec<_> = services()
+			let events_before: Vec<_> = services
 				.rooms
 				.timeline
 				.pdus_until(sender_user, &body.room_id, from)?
 				.filter_map(Result::ok) // Filter out buggy events
-				.filter(|(_, pdu)| {contains_url_filter(pdu, &body.filter) && visibility_filter(pdu, sender_user, &body.room_id)})
+				.filter(|(_, pdu)| {contains_url_filter(pdu, &body.filter) && visibility_filter(&services, pdu, sender_user, &body.room_id)})
 				.take_while(|&(k, _)| Some(k) != to) // Stop at `to`
 				.take(limit)
 				.collect();
@@ -202,7 +204,7 @@ pub(crate) async fn get_message_events_route(
 				 * https://github.com/vector-im/element-web/issues/21034
 				 */
 				if !cfg!(feature = "element_hacks")
-					&& !services().rooms.lazy_loading.lazy_load_was_sent_before(
+					&& !services.rooms.lazy_loading.lazy_load_was_sent_before(
 						sender_user,
 						sender_device,
 						&body.room_id,
@@ -229,11 +231,12 @@ pub(crate) async fn get_message_events_route(
 
 	resp.state = Vec::new();
 	for ll_id in &lazy_loaded {
-		if let Some(member_event) = services().rooms.state_accessor.room_state_get(
-			&body.room_id,
-			&StateEventType::RoomMember,
-			ll_id.as_str(),
-		)? {
+		if let Some(member_event) =
+			services
+				.rooms
+				.state_accessor
+				.room_state_get(&body.room_id, &StateEventType::RoomMember, ll_id.as_str())?
+		{
 			resp.state.push(member_event.to_state_event());
 		}
 	}
@@ -241,7 +244,7 @@ pub(crate) async fn get_message_events_route(
 	// remove the feature check when we are sure clients like element can handle it
 	if !cfg!(feature = "element_hacks") {
 		if let Some(next_token) = next_token {
-			services()
+			services
 				.rooms
 				.lazy_loading
 				.lazy_load_mark_sent(sender_user, sender_device, &body.room_id, lazy_loaded, next_token)
@@ -252,8 +255,8 @@ pub(crate) async fn get_message_events_route(
 	Ok(resp)
 }
 
-fn visibility_filter(pdu: &PduEvent, user_id: &UserId, room_id: &RoomId) -> bool {
-	services()
+fn visibility_filter(services: &Services, pdu: &PduEvent, user_id: &UserId, room_id: &RoomId) -> bool {
+	services
 		.rooms
 		.state_accessor
 		.user_can_see_event(user_id, room_id, &pdu.event_id)

src/api/client/openid.rs

@@ -1,5 +1,6 @@
 use std::time::Duration;
 
+use axum::extract::State;
 use conduit::utils;
 use ruma::{
 	api::client::{account, error::ErrorKind},
@@ -7,7 +8,7 @@ use ruma::{
 };
 
 use super::TOKEN_LENGTH;
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `POST /_matrix/client/v3/user/{userId}/openid/request_token`
 ///
@@ -15,7 +16,7 @@ use crate::{services, Error, Result, Ruma};
 ///
 /// - The token generated is only valid for the OpenID API
 pub(crate) async fn create_openid_token_route(
-	body: Ruma<account::request_openid_token::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<account::request_openid_token::v3::Request>,
 ) -> Result<account::request_openid_token::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -28,14 +29,14 @@ pub(crate) async fn create_openid_token_route(
 
 	let access_token = utils::random_string(TOKEN_LENGTH);
 
-	let expires_in = services()
+	let expires_in = services
 		.users
 		.create_openid_token(&body.user_id, &access_token)?;
 
 	Ok(account::request_openid_token::v3::Response {
 		access_token,
 		token_type: TokenType::Bearer,
-		matrix_server_name: services().globals.config.server_name.clone(),
+		matrix_server_name: services.globals.config.server_name.clone(),
 		expires_in: Duration::from_secs(expires_in),
 	})
 }

src/api/client/presence.rs

@@ -1,22 +1,24 @@
 use std::time::Duration;
 
+use axum::extract::State;
 use ruma::api::client::{
 	error::ErrorKind,
 	presence::{get_presence, set_presence},
 };
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `PUT /_matrix/client/r0/presence/{userId}/status`
 ///
 /// Sets the presence state of the sender user.
-pub(crate) async fn set_presence_route(body: Ruma<set_presence::v3::Request>) -> Result<set_presence::v3::Response> {
-	if !services().globals.allow_local_presence() {
+pub(crate) async fn set_presence_route(
+	State(services): State<crate::State>, body: Ruma<set_presence::v3::Request>,
+) -> Result<set_presence::v3::Response> {
+	if !services.globals.allow_local_presence() {
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Presence is disabled on this server"));
 	}
 
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-
 	if sender_user != &body.user_id && body.appservice_info.is_none() {
 		return Err(Error::BadRequest(
 			ErrorKind::InvalidParam,
@@ -24,7 +26,7 @@ pub(crate) async fn set_presence_route(body: Ruma<set_presence::v3::Request>) ->
 		));
 	}
 
-	services()
+	services
 		.presence
 		.set_presence(sender_user, &body.presence, None, None, body.status_msg.clone())?;
 
@@ -36,8 +38,10 @@ pub(crate) async fn set_presence_route(body: Ruma<set_presence::v3::Request>) ->
 /// Gets the presence state of the given user.
 ///
 /// - Only works if you share a room with the user
-pub(crate) async fn get_presence_route(body: Ruma<get_presence::v3::Request>) -> Result<get_presence::v3::Response> {
-	if !services().globals.allow_local_presence() {
+pub(crate) async fn get_presence_route(
+	State(services): State<crate::State>, body: Ruma<get_presence::v3::Request>,
+) -> Result<get_presence::v3::Response> {
+	if !services.globals.allow_local_presence() {
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Presence is disabled on this server"));
 	}
 
@@ -45,12 +49,12 @@ pub(crate) async fn get_presence_route(body: Ruma<get_presence::v3::Request>) ->
 
 	let mut presence_event = None;
 
-	for _room_id in services()
+	for _room_id in services
 		.rooms
 		.user
 		.get_shared_rooms(vec![sender_user.clone(), body.user_id.clone()])?
 	{
-		if let Some(presence) = services().presence.get_presence(&body.user_id)? {
+		if let Some(presence) = services.presence.get_presence(&body.user_id)? {
 			presence_event = Some(presence);
 			break;
 		}

src/api/client/profile.rs

@@ -1,3 +1,5 @@
+use axum::extract::State;
+use conduit::{pdu::PduBuilder, warn, Error, Result};
 use ruma::{
 	api::{
 		client::{
@@ -11,12 +13,9 @@ use ruma::{
 	OwnedMxcUri, OwnedRoomId, OwnedUserId,
 };
 use serde_json::value::to_raw_value;
-use tracing::warn;
+use service::Services;
 
-use crate::{
-	service::{pdu::PduBuilder, user_is_local},
-	services, Error, Result, Ruma,
-};
+use crate::Ruma;
 
 /// # `PUT /_matrix/client/r0/profile/{userId}/displayname`
 ///
@@ -24,21 +23,21 @@ use crate::{
 ///
 /// - Also makes sure other users receive the update using presence EDUs
 pub(crate) async fn set_displayname_route(
-	body: Ruma<set_display_name::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<set_display_name::v3::Request>,
 ) -> Result<set_display_name::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-	let all_joined_rooms: Vec<OwnedRoomId> = services()
+	let all_joined_rooms: Vec<OwnedRoomId> = services
 		.rooms
 		.state_cache
 		.rooms_joined(sender_user)
 		.filter_map(Result::ok)
 		.collect();
 
-	update_displayname(sender_user.clone(), body.displayname.clone(), all_joined_rooms).await?;
+	update_displayname(&services, sender_user.clone(), body.displayname.clone(), all_joined_rooms).await?;
 
-	if services().globals.allow_local_presence() {
+	if services.globals.allow_local_presence() {
 		// Presence update
-		services()
+		services
 			.presence
 			.ping_presence(sender_user, &PresenceState::Online)?;
 	}
@@ -53,11 +52,11 @@ pub(crate) async fn set_displayname_route(
 /// - If user is on another server and we do not have a local copy already fetch
 ///   displayname over federation
 pub(crate) async fn get_displayname_route(
-	body: Ruma<get_display_name::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_display_name::v3::Request>,
 ) -> Result<get_display_name::v3::Response> {
-	if !user_is_local(&body.user_id) {
+	if !services.globals.user_is_local(&body.user_id) {
 		// Create and update our local copy of the user
-		if let Ok(response) = services()
+		if let Ok(response) = services
 			.sending
 			.send_federation_request(
 				body.user_id.server_name(),
@@ -68,19 +67,19 @@ pub(crate) async fn get_displayname_route(
 			)
 			.await
 		{
-			if !services().users.exists(&body.user_id)? {
-				services().users.create(&body.user_id, None)?;
+			if !services.users.exists(&body.user_id)? {
+				services.users.create(&body.user_id, None)?;
 			}
 
-			services()
+			services
 				.users
 				.set_displayname(&body.user_id, response.displayname.clone())
 				.await?;
-			services()
+			services
 				.users
 				.set_avatar_url(&body.user_id, response.avatar_url.clone())
 				.await?;
-			services()
+			services
 				.users
 				.set_blurhash(&body.user_id, response.blurhash.clone())
 				.await?;
@@ -91,14 +90,14 @@ pub(crate) async fn get_displayname_route(
 		}
 	}
 
-	if !services().users.exists(&body.user_id)? {
+	if !services.users.exists(&body.user_id)? {
 		// Return 404 if this user doesn't exist and we couldn't fetch it over
 		// federation
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Profile was not found."));
 	}
 
 	Ok(get_display_name::v3::Response {
-		displayname: services().users.displayname(&body.user_id)?,
+		displayname: services.users.displayname(&body.user_id)?,
 	})
 }
 
@@ -108,10 +107,10 @@ pub(crate) async fn get_displayname_route(
 ///
 /// - Also makes sure other users receive the update using presence EDUs
 pub(crate) async fn set_avatar_url_route(
-	body: Ruma<set_avatar_url::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<set_avatar_url::v3::Request>,
 ) -> Result<set_avatar_url::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-	let all_joined_rooms: Vec<OwnedRoomId> = services()
+	let all_joined_rooms: Vec<OwnedRoomId> = services
 		.rooms
 		.state_cache
 		.rooms_joined(sender_user)
@@ -119,6 +118,7 @@ pub(crate) async fn set_avatar_url_route(
 		.collect();
 
 	update_avatar_url(
+		&services,
 		sender_user.clone(),
 		body.avatar_url.clone(),
 		body.blurhash.clone(),
@@ -126,9 +126,9 @@ pub(crate) async fn set_avatar_url_route(
 	)
 	.await?;
 
-	if services().globals.allow_local_presence() {
+	if services.globals.allow_local_presence() {
 		// Presence update
-		services()
+		services
 			.presence
 			.ping_presence(sender_user, &PresenceState::Online)?;
 	}
@@ -143,11 +143,11 @@ pub(crate) async fn set_avatar_url_route(
 /// - If user is on another server and we do not have a local copy already fetch
 ///   `avatar_url` and blurhash over federation
 pub(crate) async fn get_avatar_url_route(
-	body: Ruma<get_avatar_url::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_avatar_url::v3::Request>,
 ) -> Result<get_avatar_url::v3::Response> {
-	if !user_is_local(&body.user_id) {
+	if !services.globals.user_is_local(&body.user_id) {
 		// Create and update our local copy of the user
-		if let Ok(response) = services()
+		if let Ok(response) = services
 			.sending
 			.send_federation_request(
 				body.user_id.server_name(),
@@ -158,19 +158,19 @@ pub(crate) async fn get_avatar_url_route(
 			)
 			.await
 		{
-			if !services().users.exists(&body.user_id)? {
-				services().users.create(&body.user_id, None)?;
+			if !services.users.exists(&body.user_id)? {
+				services.users.create(&body.user_id, None)?;
 			}
 
-			services()
+			services
 				.users
 				.set_displayname(&body.user_id, response.displayname.clone())
 				.await?;
-			services()
+			services
 				.users
 				.set_avatar_url(&body.user_id, response.avatar_url.clone())
 				.await?;
-			services()
+			services
 				.users
 				.set_blurhash(&body.user_id, response.blurhash.clone())
 				.await?;
@@ -182,15 +182,15 @@ pub(crate) async fn get_avatar_url_route(
 		}
 	}
 
-	if !services().users.exists(&body.user_id)? {
+	if !services.users.exists(&body.user_id)? {
 		// Return 404 if this user doesn't exist and we couldn't fetch it over
 		// federation
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Profile was not found."));
 	}
 
 	Ok(get_avatar_url::v3::Response {
-		avatar_url: services().users.avatar_url(&body.user_id)?,
-		blurhash: services().users.blurhash(&body.user_id)?,
+		avatar_url: services.users.avatar_url(&body.user_id)?,
+		blurhash: services.users.blurhash(&body.user_id)?,
 	})
 }
 
@@ -200,10 +200,12 @@ pub(crate) async fn get_avatar_url_route(
 ///
 /// - If user is on another server and we do not have a local copy already,
 ///   fetch profile over federation.
-pub(crate) async fn get_profile_route(body: Ruma<get_profile::v3::Request>) -> Result<get_profile::v3::Response> {
-	if !user_is_local(&body.user_id) {
+pub(crate) async fn get_profile_route(
+	State(services): State<crate::State>, body: Ruma<get_profile::v3::Request>,
+) -> Result<get_profile::v3::Response> {
+	if !services.globals.user_is_local(&body.user_id) {
 		// Create and update our local copy of the user
-		if let Ok(response) = services()
+		if let Ok(response) = services
 			.sending
 			.send_federation_request(
 				body.user_id.server_name(),
@@ -214,19 +216,19 @@ pub(crate) async fn get_profile_route(body: Ruma<get_profile::v3::Request>) -> R
 			)
 			.await
 		{
-			if !services().users.exists(&body.user_id)? {
-				services().users.create(&body.user_id, None)?;
+			if !services.users.exists(&body.user_id)? {
+				services.users.create(&body.user_id, None)?;
 			}
 
-			services()
+			services
 				.users
 				.set_displayname(&body.user_id, response.displayname.clone())
 				.await?;
-			services()
+			services
 				.users
 				.set_avatar_url(&body.user_id, response.avatar_url.clone())
 				.await?;
-			services()
+			services
 				.users
 				.set_blurhash(&body.user_id, response.blurhash.clone())
 				.await?;
@@ -239,23 +241,23 @@ pub(crate) async fn get_profile_route(body: Ruma<get_profile::v3::Request>) -> R
 		}
 	}
 
-	if !services().users.exists(&body.user_id)? {
+	if !services.users.exists(&body.user_id)? {
 		// Return 404 if this user doesn't exist and we couldn't fetch it over
 		// federation
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Profile was not found."));
 	}
 
 	Ok(get_profile::v3::Response {
-		avatar_url: services().users.avatar_url(&body.user_id)?,
-		blurhash: services().users.blurhash(&body.user_id)?,
-		displayname: services().users.displayname(&body.user_id)?,
+		avatar_url: services.users.avatar_url(&body.user_id)?,
+		blurhash: services.users.blurhash(&body.user_id)?,
+		displayname: services.users.displayname(&body.user_id)?,
 	})
 }
 
 pub async fn update_displayname(
-	user_id: OwnedUserId, displayname: Option<String>, all_joined_rooms: Vec<OwnedRoomId>,
+	services: &Services, user_id: OwnedUserId, displayname: Option<String>, all_joined_rooms: Vec<OwnedRoomId>,
 ) -> Result<()> {
-	services()
+	services
 		.users
 		.set_displayname(&user_id, displayname.clone())
 		.await?;
@@ -271,7 +273,7 @@ pub async fn update_displayname(
 						displayname: displayname.clone(),
 						join_authorized_via_users_server: None,
 						..serde_json::from_str(
-							services()
+							services
 								.rooms
 								.state_accessor
 								.room_state_get(room_id, &StateEventType::RoomMember, user_id.as_str())?
@@ -294,19 +296,20 @@ pub async fn update_displayname(
 		.filter_map(Result::ok)
 		.collect();
 
-	update_all_rooms(all_joined_rooms, user_id).await;
+	update_all_rooms(services, all_joined_rooms, user_id).await;
 
 	Ok(())
 }
 
 pub async fn update_avatar_url(
-	user_id: OwnedUserId, avatar_url: Option<OwnedMxcUri>, blurhash: Option<String>, all_joined_rooms: Vec<OwnedRoomId>,
+	services: &Services, user_id: OwnedUserId, avatar_url: Option<OwnedMxcUri>, blurhash: Option<String>,
+	all_joined_rooms: Vec<OwnedRoomId>,
 ) -> Result<()> {
-	services()
+	services
 		.users
 		.set_avatar_url(&user_id, avatar_url.clone())
 		.await?;
-	services()
+	services
 		.users
 		.set_blurhash(&user_id, blurhash.clone())
 		.await?;
@@ -323,7 +326,7 @@ pub async fn update_avatar_url(
 						blurhash: blurhash.clone(),
 						join_authorized_via_users_server: None,
 						..serde_json::from_str(
-							services()
+							services
 								.rooms
 								.state_accessor
 								.room_state_get(room_id, &StateEventType::RoomMember, user_id.as_str())?
@@ -346,15 +349,17 @@ pub async fn update_avatar_url(
 		.filter_map(Result::ok)
 		.collect();
 
-	update_all_rooms(all_joined_rooms, user_id).await;
+	update_all_rooms(services, all_joined_rooms, user_id).await;
 
 	Ok(())
 }
 
-pub async fn update_all_rooms(all_joined_rooms: Vec<(PduBuilder, &OwnedRoomId)>, user_id: OwnedUserId) {
+pub async fn update_all_rooms(
+	services: &Services, all_joined_rooms: Vec<(PduBuilder, &OwnedRoomId)>, user_id: OwnedUserId,
+) {
 	for (pdu_builder, room_id) in all_joined_rooms {
-		let state_lock = services().rooms.state.mutex.lock(room_id).await;
-		if let Err(e) = services()
+		let state_lock = services.rooms.state.mutex.lock(room_id).await;
+		if let Err(e) = services
 			.rooms
 			.timeline
 			.build_and_append_pdu(pdu_builder, &user_id, room_id, &state_lock)

src/api/client/push.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use ruma::{
 	api::client::{
 		error::ErrorKind,
@@ -10,18 +11,18 @@ use ruma::{
 	push::{InsertPushRuleError, RemovePushRuleError, Ruleset},
 };
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `GET /_matrix/client/r0/pushrules/`
 ///
 /// Retrieves the push rules event for this user.
 pub(crate) async fn get_pushrules_all_route(
-	body: Ruma<get_pushrules_all::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_pushrules_all::v3::Request>,
 ) -> Result<get_pushrules_all::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let event =
-		services()
+		services
 			.account_data
 			.get(None, sender_user, GlobalAccountDataEventType::PushRules.to_string().into())?;
 
@@ -34,7 +35,7 @@ pub(crate) async fn get_pushrules_all_route(
 			global: account_data.global,
 		})
 	} else {
-		services().account_data.update(
+		services.account_data.update(
 			None,
 			sender_user,
 			GlobalAccountDataEventType::PushRules.to_string().into(),
@@ -55,10 +56,12 @@ pub(crate) async fn get_pushrules_all_route(
 /// # `GET /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}`
 ///
 /// Retrieves a single specified push rule for this user.
-pub(crate) async fn get_pushrule_route(body: Ruma<get_pushrule::v3::Request>) -> Result<get_pushrule::v3::Response> {
+pub(crate) async fn get_pushrule_route(
+	State(services): State<crate::State>, body: Ruma<get_pushrule::v3::Request>,
+) -> Result<get_pushrule::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(None, sender_user, GlobalAccountDataEventType::PushRules.to_string().into())?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "PushRules event not found."))?;
@@ -84,7 +87,9 @@ pub(crate) async fn get_pushrule_route(body: Ruma<get_pushrule::v3::Request>) ->
 /// # `PUT /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}`
 ///
 /// Creates a single specified push rule for this user.
-pub(crate) async fn set_pushrule_route(body: Ruma<set_pushrule::v3::Request>) -> Result<set_pushrule::v3::Response> {
+pub(crate) async fn set_pushrule_route(
+	State(services): State<crate::State>, body: Ruma<set_pushrule::v3::Request>,
+) -> Result<set_pushrule::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let body = body.body;
 
@@ -95,7 +100,7 @@ pub(crate) async fn set_pushrule_route(body: Ruma<set_pushrule::v3::Request>) ->
 		));
 	}
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(None, sender_user, GlobalAccountDataEventType::PushRules.to_string().into())?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "PushRules event not found."))?;
@@ -134,7 +139,7 @@ pub(crate) async fn set_pushrule_route(body: Ruma<set_pushrule::v3::Request>) ->
 		return Err(err);
 	}
 
-	services().account_data.update(
+	services.account_data.update(
 		None,
 		sender_user,
 		GlobalAccountDataEventType::PushRules.to_string().into(),
@@ -148,7 +153,7 @@ pub(crate) async fn set_pushrule_route(body: Ruma<set_pushrule::v3::Request>) ->
 ///
 /// Gets the actions of a single specified push rule for this user.
 pub(crate) async fn get_pushrule_actions_route(
-	body: Ruma<get_pushrule_actions::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_pushrule_actions::v3::Request>,
 ) -> Result<get_pushrule_actions::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -159,7 +164,7 @@ pub(crate) async fn get_pushrule_actions_route(
 		));
 	}
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(None, sender_user, GlobalAccountDataEventType::PushRules.to_string().into())?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "PushRules event not found."))?;
@@ -183,7 +188,7 @@ pub(crate) async fn get_pushrule_actions_route(
 ///
 /// Sets the actions of a single specified push rule for this user.
 pub(crate) async fn set_pushrule_actions_route(
-	body: Ruma<set_pushrule_actions::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<set_pushrule_actions::v3::Request>,
 ) -> Result<set_pushrule_actions::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -194,7 +199,7 @@ pub(crate) async fn set_pushrule_actions_route(
 		));
 	}
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(None, sender_user, GlobalAccountDataEventType::PushRules.to_string().into())?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "PushRules event not found."))?;
@@ -211,7 +216,7 @@ pub(crate) async fn set_pushrule_actions_route(
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Push rule not found."));
 	}
 
-	services().account_data.update(
+	services.account_data.update(
 		None,
 		sender_user,
 		GlobalAccountDataEventType::PushRules.to_string().into(),
@@ -225,7 +230,7 @@ pub(crate) async fn set_pushrule_actions_route(
 ///
 /// Gets the enabled status of a single specified push rule for this user.
 pub(crate) async fn get_pushrule_enabled_route(
-	body: Ruma<get_pushrule_enabled::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_pushrule_enabled::v3::Request>,
 ) -> Result<get_pushrule_enabled::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -236,7 +241,7 @@ pub(crate) async fn get_pushrule_enabled_route(
 		));
 	}
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(None, sender_user, GlobalAccountDataEventType::PushRules.to_string().into())?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "PushRules event not found."))?;
@@ -259,7 +264,7 @@ pub(crate) async fn get_pushrule_enabled_route(
 ///
 /// Sets the enabled status of a single specified push rule for this user.
 pub(crate) async fn set_pushrule_enabled_route(
-	body: Ruma<set_pushrule_enabled::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<set_pushrule_enabled::v3::Request>,
 ) -> Result<set_pushrule_enabled::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -270,7 +275,7 @@ pub(crate) async fn set_pushrule_enabled_route(
 		));
 	}
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(None, sender_user, GlobalAccountDataEventType::PushRules.to_string().into())?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "PushRules event not found."))?;
@@ -287,7 +292,7 @@ pub(crate) async fn set_pushrule_enabled_route(
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Push rule not found."));
 	}
 
-	services().account_data.update(
+	services.account_data.update(
 		None,
 		sender_user,
 		GlobalAccountDataEventType::PushRules.to_string().into(),
@@ -301,7 +306,7 @@ pub(crate) async fn set_pushrule_enabled_route(
 ///
 /// Deletes a single specified push rule for this user.
 pub(crate) async fn delete_pushrule_route(
-	body: Ruma<delete_pushrule::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<delete_pushrule::v3::Request>,
 ) -> Result<delete_pushrule::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -312,7 +317,7 @@ pub(crate) async fn delete_pushrule_route(
 		));
 	}
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(None, sender_user, GlobalAccountDataEventType::PushRules.to_string().into())?
 		.ok_or(Error::BadRequest(ErrorKind::NotFound, "PushRules event not found."))?;
@@ -336,7 +341,7 @@ pub(crate) async fn delete_pushrule_route(
 		return Err(err);
 	}
 
-	services().account_data.update(
+	services.account_data.update(
 		None,
 		sender_user,
 		GlobalAccountDataEventType::PushRules.to_string().into(),
@@ -349,11 +354,13 @@ pub(crate) async fn delete_pushrule_route(
 /// # `GET /_matrix/client/r0/pushers`
 ///
 /// Gets all currently active pushers for the sender user.
-pub(crate) async fn get_pushers_route(body: Ruma<get_pushers::v3::Request>) -> Result<get_pushers::v3::Response> {
+pub(crate) async fn get_pushers_route(
+	State(services): State<crate::State>, body: Ruma<get_pushers::v3::Request>,
+) -> Result<get_pushers::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	Ok(get_pushers::v3::Response {
-		pushers: services().pusher.get_pushers(sender_user)?,
+		pushers: services.pusher.get_pushers(sender_user)?,
 	})
 }
 
@@ -362,10 +369,12 @@ pub(crate) async fn get_pushers_route(body: Ruma<get_pushers::v3::Request>) -> R
 /// Adds a pusher for the sender user.
 ///
 /// - TODO: Handle `append`
-pub(crate) async fn set_pushers_route(body: Ruma<set_pusher::v3::Request>) -> Result<set_pusher::v3::Response> {
+pub(crate) async fn set_pushers_route(
+	State(services): State<crate::State>, body: Ruma<set_pusher::v3::Request>,
+) -> Result<set_pusher::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	services().pusher.set_pusher(sender_user, &body.action)?;
+	services.pusher.set_pusher(sender_user, &body.action)?;
 
 	Ok(set_pusher::v3::Response::default())
 }

src/api/client/read_marker.rs

@@ -1,5 +1,6 @@
 use std::collections::BTreeMap;
 
+use axum::extract::State;
 use conduit::PduCount;
 use ruma::{
 	api::client::{error::ErrorKind, read_marker::set_read_marker, receipt::create_receipt},
@@ -10,7 +11,7 @@ use ruma::{
 	MilliSecondsSinceUnixEpoch,
 };
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `POST /_matrix/client/r0/rooms/{roomId}/read_markers`
 ///
@@ -20,7 +21,7 @@ use crate::{services, Error, Result, Ruma};
 /// - If `read_receipt` is set: Update private marker and public read receipt
 ///   EDU
 pub(crate) async fn set_read_marker_route(
-	body: Ruma<set_read_marker::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<set_read_marker::v3::Request>,
 ) -> Result<set_read_marker::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -30,7 +31,7 @@ pub(crate) async fn set_read_marker_route(
 				event_id: fully_read.clone(),
 			},
 		};
-		services().account_data.update(
+		services.account_data.update(
 			Some(&body.room_id),
 			sender_user,
 			RoomAccountDataEventType::FullyRead,
@@ -39,14 +40,14 @@ pub(crate) async fn set_read_marker_route(
 	}
 
 	if body.private_read_receipt.is_some() || body.read_receipt.is_some() {
-		services()
+		services
 			.rooms
 			.user
 			.reset_notification_counts(sender_user, &body.room_id)?;
 	}
 
 	if let Some(event) = &body.private_read_receipt {
-		let count = services()
+		let count = services
 			.rooms
 			.timeline
 			.get_pdu_count(event)?
@@ -60,7 +61,7 @@ pub(crate) async fn set_read_marker_route(
 			},
 			PduCount::Normal(c) => c,
 		};
-		services()
+		services
 			.rooms
 			.read_receipt
 			.private_read_set(&body.room_id, sender_user, count)?;
@@ -82,7 +83,7 @@ pub(crate) async fn set_read_marker_route(
 		let mut receipt_content = BTreeMap::new();
 		receipt_content.insert(event.to_owned(), receipts);
 
-		services().rooms.read_receipt.readreceipt_update(
+		services.rooms.read_receipt.readreceipt_update(
 			sender_user,
 			&body.room_id,
 			&ruma::events::receipt::ReceiptEvent {
@@ -99,7 +100,7 @@ pub(crate) async fn set_read_marker_route(
 ///
 /// Sets private read marker and public read receipt EDU.
 pub(crate) async fn create_receipt_route(
-	body: Ruma<create_receipt::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<create_receipt::v3::Request>,
 ) -> Result<create_receipt::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -107,7 +108,7 @@ pub(crate) async fn create_receipt_route(
 		&body.receipt_type,
 		create_receipt::v3::ReceiptType::Read | create_receipt::v3::ReceiptType::ReadPrivate
 	) {
-		services()
+		services
 			.rooms
 			.user
 			.reset_notification_counts(sender_user, &body.room_id)?;
@@ -120,7 +121,7 @@ pub(crate) async fn create_receipt_route(
 					event_id: body.event_id.clone(),
 				},
 			};
-			services().account_data.update(
+			services.account_data.update(
 				Some(&body.room_id),
 				sender_user,
 				RoomAccountDataEventType::FullyRead,
@@ -142,7 +143,7 @@ pub(crate) async fn create_receipt_route(
 			let mut receipt_content = BTreeMap::new();
 			receipt_content.insert(body.event_id.clone(), receipts);
 
-			services().rooms.read_receipt.readreceipt_update(
+			services.rooms.read_receipt.readreceipt_update(
 				sender_user,
 				&body.room_id,
 				&ruma::events::receipt::ReceiptEvent {
@@ -152,7 +153,7 @@ pub(crate) async fn create_receipt_route(
 			)?;
 		},
 		create_receipt::v3::ReceiptType::ReadPrivate => {
-			let count = services()
+			let count = services
 				.rooms
 				.timeline
 				.get_pdu_count(&body.event_id)?
@@ -166,7 +167,7 @@ pub(crate) async fn create_receipt_route(
 				},
 				PduCount::Normal(c) => c,
 			};
-			services()
+			services
 				.rooms
 				.read_receipt
 				.private_read_set(&body.room_id, sender_user, count)?;

src/api/client/redact.rs

@@ -1,23 +1,26 @@
+use axum::extract::State;
 use ruma::{
 	api::client::redact::redact_event,
 	events::{room::redaction::RoomRedactionEventContent, TimelineEventType},
 };
 use serde_json::value::to_raw_value;
 
-use crate::{service::pdu::PduBuilder, services, Result, Ruma};
+use crate::{service::pdu::PduBuilder, Result, Ruma};
 
 /// # `PUT /_matrix/client/r0/rooms/{roomId}/redact/{eventId}/{txnId}`
 ///
 /// Tries to send a redaction event into the room.
 ///
 /// - TODO: Handle txn id
-pub(crate) async fn redact_event_route(body: Ruma<redact_event::v3::Request>) -> Result<redact_event::v3::Response> {
+pub(crate) async fn redact_event_route(
+	State(services): State<crate::State>, body: Ruma<redact_event::v3::Request>,
+) -> Result<redact_event::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let body = body.body;
 
-	let state_lock = services().rooms.state.mutex.lock(&body.room_id).await;
+	let state_lock = services.rooms.state.mutex.lock(&body.room_id).await;
 
-	let event_id = services()
+	let event_id = services
 		.rooms
 		.timeline
 		.build_and_append_pdu(

src/api/client/relations.rs

@@ -1,30 +1,28 @@
+use axum::extract::State;
 use ruma::api::client::relations::{
 	get_relating_events, get_relating_events_with_rel_type, get_relating_events_with_rel_type_and_event_type,
 };
 
-use crate::{services, Result, Ruma};
+use crate::{Result, Ruma};
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}/{relType}/{eventType}`
 pub(crate) async fn get_relating_events_with_rel_type_and_event_type_route(
-	body: Ruma<get_relating_events_with_rel_type_and_event_type::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_relating_events_with_rel_type_and_event_type::v1::Request>,
 ) -> Result<get_relating_events_with_rel_type_and_event_type::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let res = services()
-		.rooms
-		.pdu_metadata
-		.paginate_relations_with_filter(
-			sender_user,
-			&body.room_id,
-			&body.event_id,
-			&Some(body.event_type.clone()),
-			&Some(body.rel_type.clone()),
-			&body.from,
-			&body.to,
-			&body.limit,
-			body.recurse,
-			body.dir,
-		)?;
+	let res = services.rooms.pdu_metadata.paginate_relations_with_filter(
+		sender_user,
+		&body.room_id,
+		&body.event_id,
+		&Some(body.event_type.clone()),
+		&Some(body.rel_type.clone()),
+		&body.from,
+		&body.to,
+		&body.limit,
+		body.recurse,
+		body.dir,
+	)?;
 
 	Ok(get_relating_events_with_rel_type_and_event_type::v1::Response {
 		chunk: res.chunk,
@@ -36,25 +34,22 @@ pub(crate) async fn get_relating_events_with_rel_type_and_event_type_route(
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}/{relType}`
 pub(crate) async fn get_relating_events_with_rel_type_route(
-	body: Ruma<get_relating_events_with_rel_type::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_relating_events_with_rel_type::v1::Request>,
 ) -> Result<get_relating_events_with_rel_type::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let res = services()
-		.rooms
-		.pdu_metadata
-		.paginate_relations_with_filter(
-			sender_user,
-			&body.room_id,
-			&body.event_id,
-			&None,
-			&Some(body.rel_type.clone()),
-			&body.from,
-			&body.to,
-			&body.limit,
-			body.recurse,
-			body.dir,
-		)?;
+	let res = services.rooms.pdu_metadata.paginate_relations_with_filter(
+		sender_user,
+		&body.room_id,
+		&body.event_id,
+		&None,
+		&Some(body.rel_type.clone()),
+		&body.from,
+		&body.to,
+		&body.limit,
+		body.recurse,
+		body.dir,
+	)?;
 
 	Ok(get_relating_events_with_rel_type::v1::Response {
 		chunk: res.chunk,
@@ -66,23 +61,20 @@ pub(crate) async fn get_relating_events_with_rel_type_route(
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}`
 pub(crate) async fn get_relating_events_route(
-	body: Ruma<get_relating_events::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_relating_events::v1::Request>,
 ) -> Result<get_relating_events::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	services()
-		.rooms
-		.pdu_metadata
-		.paginate_relations_with_filter(
-			sender_user,
-			&body.room_id,
-			&body.event_id,
-			&None,
-			&None,
-			&body.from,
-			&body.to,
-			&body.limit,
-			body.recurse,
-			body.dir,
-		)
+	services.rooms.pdu_metadata.paginate_relations_with_filter(
+		sender_user,
+		&body.room_id,
+		&body.event_id,
+		&None,
+		&None,
+		&body.from,
+		&body.to,
+		&body.limit,
+		body.recurse,
+		body.dir,
+	)
 }

src/api/client/report.rs

@@ -1,5 +1,6 @@
 use std::time::Duration;
 
+use axum::extract::State;
 use rand::Rng;
 use ruma::{
 	api::client::{error::ErrorKind, room::report_content},
@@ -9,13 +10,18 @@ use ruma::{
 use tokio::time::sleep;
 use tracing::info;
 
-use crate::{debug_info, service::pdu::PduEvent, services, utils::HtmlEscape, Error, Result, Ruma};
+use crate::{
+	debug_info,
+	service::{pdu::PduEvent, Services},
+	utils::HtmlEscape,
+	Error, Result, Ruma,
+};
 
 /// # `POST /_matrix/client/v3/rooms/{roomId}/report/{eventId}`
 ///
 /// Reports an inappropriate event to homeserver admins
 pub(crate) async fn report_event_route(
-	body: Ruma<report_content::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<report_content::v3::Request>,
 ) -> Result<report_content::v3::Response> {
 	// user authentication
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@@ -26,18 +32,26 @@ pub(crate) async fn report_event_route(
 	);
 
 	// check if we know about the reported event ID or if it's invalid
-	let Some(pdu) = services().rooms.timeline.get_pdu(&body.event_id)? else {
+	let Some(pdu) = services.rooms.timeline.get_pdu(&body.event_id)? else {
 		return Err(Error::BadRequest(
 			ErrorKind::NotFound,
 			"Event ID is not known to us or Event ID is invalid",
 		));
 	};
 
-	is_report_valid(&pdu.event_id, &body.room_id, sender_user, &body.reason, body.score, &pdu)?;
+	is_report_valid(
+		&services,
+		&pdu.event_id,
+		&body.room_id,
+		sender_user,
+		&body.reason,
+		body.score,
+		&pdu,
+	)?;
 
 	// send admin room message that we received the report with an @room ping for
 	// urgency
-	services()
+	services
 		.admin
 		.send_message(message::RoomMessageEventContent::text_html(
 			format!(
@@ -79,8 +93,8 @@ pub(crate) async fn report_event_route(
 /// check if score is in valid range
 /// check if report reasoning is less than or equal to 750 characters
 fn is_report_valid(
-	event_id: &EventId, room_id: &RoomId, sender_user: &UserId, reason: &Option<String>, score: Option<ruma::Int>,
-	pdu: &std::sync::Arc<PduEvent>,
+	services: &Services, event_id: &EventId, room_id: &RoomId, sender_user: &UserId, reason: &Option<String>,
+	score: Option<ruma::Int>, pdu: &std::sync::Arc<PduEvent>,
 ) -> Result<bool> {
 	debug_info!("Checking if report from user {sender_user} for event {event_id} in room {room_id} is valid");
 
@@ -91,7 +105,7 @@ fn is_report_valid(
 		));
 	}
 
-	if !services()
+	if !services
 		.rooms
 		.state_cache
 		.room_members(&pdu.room_id)

src/api/client/room.rs

@@ -1,5 +1,6 @@
 use std::{cmp::max, collections::BTreeMap};
 
+use axum::extract::State;
 use conduit::{debug_info, debug_warn};
 use ruma::{
 	api::client::{
@@ -30,8 +31,8 @@ use tracing::{error, info, warn};
 
 use super::invite_helper;
 use crate::{
-	service::{appservice::RegistrationInfo, pdu::PduBuilder},
-	services, Error, Result, Ruma,
+	service::{appservice::RegistrationInfo, pdu::PduBuilder, Services},
+	Error, Result, Ruma,
 };
 
 /// Recommended transferable state events list from the spec
@@ -63,44 +64,46 @@ const TRANSFERABLE_STATE_EVENTS: &[StateEventType; 9] = &[
 /// - Send events listed in initial state
 /// - Send events implied by `name` and `topic`
 /// - Send invite events
-pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> Result<create_room::v3::Response> {
+pub(crate) async fn create_room_route(
+	State(services): State<crate::State>, body: Ruma<create_room::v3::Request>,
+) -> Result<create_room::v3::Response> {
 	use create_room::v3::RoomPreset;
 
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	if !services().globals.allow_room_creation()
+	if !services.globals.allow_room_creation()
 		&& body.appservice_info.is_none()
-		&& !services().users.is_admin(sender_user)?
+		&& !services.users.is_admin(sender_user)?
 	{
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Room creation has been disabled."));
 	}
 
 	let room_id: OwnedRoomId = if let Some(custom_room_id) = &body.room_id {
-		custom_room_id_check(custom_room_id)?
+		custom_room_id_check(&services, custom_room_id)?
 	} else {
-		RoomId::new(&services().globals.config.server_name)
+		RoomId::new(&services.globals.config.server_name)
 	};
 
 	// check if room ID doesn't already exist instead of erroring on auth check
-	if services().rooms.short.get_shortroomid(&room_id)?.is_some() {
+	if services.rooms.short.get_shortroomid(&room_id)?.is_some() {
 		return Err(Error::BadRequest(
 			ErrorKind::RoomInUse,
 			"Room with that custom room ID already exists",
 		));
 	}
 
-	let _short_id = services().rooms.short.get_or_create_shortroomid(&room_id)?;
-	let state_lock = services().rooms.state.mutex.lock(&room_id).await;
+	let _short_id = services.rooms.short.get_or_create_shortroomid(&room_id)?;
+	let state_lock = services.rooms.state.mutex.lock(&room_id).await;
 
 	let alias: Option<OwnedRoomAliasId> = if let Some(alias) = &body.room_alias_name {
-		Some(room_alias_check(alias, &body.appservice_info).await?)
+		Some(room_alias_check(&services, alias, &body.appservice_info).await?)
 	} else {
 		None
 	};
 
 	let room_version = match body.room_version.clone() {
 		Some(room_version) => {
-			if services()
+			if services
 				.globals
 				.supported_room_versions()
 				.contains(&room_version)
@@ -113,7 +116,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 				));
 			}
 		},
-		None => services().globals.default_room_version(),
+		None => services.globals.default_room_version(),
 	};
 
 	let content = match &body.creation_content {
@@ -184,7 +187,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 	};
 
 	// 1. The room create event
-	services()
+	services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -202,7 +205,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 		.await?;
 
 	// 2. Let the room creator join
-	services()
+	services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -210,11 +213,11 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 				event_type: TimelineEventType::RoomMember,
 				content: to_raw_value(&RoomMemberEventContent {
 					membership: MembershipState::Join,
-					displayname: services().users.displayname(sender_user)?,
-					avatar_url: services().users.avatar_url(sender_user)?,
+					displayname: services.users.displayname(sender_user)?,
+					avatar_url: services.users.avatar_url(sender_user)?,
 					is_direct: Some(body.is_direct),
 					third_party_invite: None,
-					blurhash: services().users.blurhash(sender_user)?,
+					blurhash: services.users.blurhash(sender_user)?,
 					reason: None,
 					join_authorized_via_users_server: None,
 				})
@@ -249,7 +252,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 	let power_levels_content =
 		default_power_levels_content(&body.power_level_content_override, &body.visibility, users)?;
 
-	services()
+	services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -268,7 +271,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 
 	// 4. Canonical room alias
 	if let Some(room_alias_id) = &alias {
-		services()
+		services
 			.rooms
 			.timeline
 			.build_and_append_pdu(
@@ -293,7 +296,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 	// 5. Events set by preset
 
 	// 5.1 Join Rules
-	services()
+	services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -316,7 +319,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 		.await?;
 
 	// 5.2 History Visibility
-	services()
+	services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -335,7 +338,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 		.await?;
 
 	// 5.3 Guest Access
-	services()
+	services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -378,11 +381,11 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 		pdu_builder.state_key.get_or_insert_with(String::new);
 
 		// Silently skip encryption events if they are not allowed
-		if pdu_builder.event_type == TimelineEventType::RoomEncryption && !services().globals.allow_encryption() {
+		if pdu_builder.event_type == TimelineEventType::RoomEncryption && !services.globals.allow_encryption() {
 			continue;
 		}
 
-		services()
+		services
 			.rooms
 			.timeline
 			.build_and_append_pdu(pdu_builder, sender_user, &room_id, &state_lock)
@@ -391,7 +394,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 
 	// 7. Events implied by name and topic
 	if let Some(name) = &body.name {
-		services()
+		services
 			.rooms
 			.timeline
 			.build_and_append_pdu(
@@ -411,7 +414,7 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 	}
 
 	if let Some(topic) = &body.topic {
-		services()
+		services
 			.rooms
 			.timeline
 			.build_and_append_pdu(
@@ -435,21 +438,21 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 	// 8. Events implied by invite (and TODO: invite_3pid)
 	drop(state_lock);
 	for user_id in &body.invite {
-		if let Err(e) = invite_helper(sender_user, user_id, &room_id, None, body.is_direct).await {
+		if let Err(e) = invite_helper(&services, sender_user, user_id, &room_id, None, body.is_direct).await {
 			warn!(%e, "Failed to send invite");
 		}
 	}
 
 	// Homeserver specific stuff
 	if let Some(alias) = alias {
-		services()
+		services
 			.rooms
 			.alias
 			.set_alias(&alias, &room_id, sender_user)?;
 	}
 
 	if body.visibility == room::Visibility::Public {
-		services().rooms.directory.set_public(&room_id)?;
+		services.rooms.directory.set_public(&room_id)?;
 	}
 
 	info!("{sender_user} created a room with room ID {room_id}");
@@ -464,11 +467,11 @@ pub(crate) async fn create_room_route(body: Ruma<create_room::v3::Request>) -> R
 /// - You have to currently be joined to the room (TODO: Respect history
 ///   visibility)
 pub(crate) async fn get_room_event_route(
-	body: Ruma<get_room_event::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_room_event::v3::Request>,
 ) -> Result<get_room_event::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let event = services()
+	let event = services
 		.rooms
 		.timeline
 		.get_pdu(&body.event_id)?
@@ -477,7 +480,7 @@ pub(crate) async fn get_room_event_route(
 			Error::BadRequest(ErrorKind::NotFound, "Event not found.")
 		})?;
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.user_can_see_event(sender_user, &event.room_id, &body.event_id)?
@@ -502,10 +505,12 @@ pub(crate) async fn get_room_event_route(
 ///
 /// - Only users joined to the room are allowed to call this, or if
 ///   `history_visibility` is world readable in the room
-pub(crate) async fn get_room_aliases_route(body: Ruma<aliases::v3::Request>) -> Result<aliases::v3::Response> {
+pub(crate) async fn get_room_aliases_route(
+	State(services): State<crate::State>, body: Ruma<aliases::v3::Request>,
+) -> Result<aliases::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.user_can_see_state_events(sender_user, &body.room_id)?
@@ -517,7 +522,7 @@ pub(crate) async fn get_room_aliases_route(body: Ruma<aliases::v3::Request>) ->
 	}
 
 	Ok(aliases::v3::Response {
-		aliases: services()
+		aliases: services
 			.rooms
 			.alias
 			.local_aliases_for_room(&body.room_id)
@@ -536,10 +541,12 @@ pub(crate) async fn get_room_aliases_route(body: Ruma<aliases::v3::Request>) ->
 /// - Transfers some state events
 /// - Moves local aliases
 /// - Modifies old room power levels to prevent users from speaking
-pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) -> Result<upgrade_room::v3::Response> {
+pub(crate) async fn upgrade_room_route(
+	State(services): State<crate::State>, body: Ruma<upgrade_room::v3::Request>,
+) -> Result<upgrade_room::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	if !services()
+	if !services
 		.globals
 		.supported_room_versions()
 		.contains(&body.new_version)
@@ -551,19 +558,19 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 	}
 
 	// Create a replacement room
-	let replacement_room = RoomId::new(services().globals.server_name());
+	let replacement_room = RoomId::new(services.globals.server_name());
 
-	let _short_id = services()
+	let _short_id = services
 		.rooms
 		.short
 		.get_or_create_shortroomid(&replacement_room)?;
 
-	let state_lock = services().rooms.state.mutex.lock(&body.room_id).await;
+	let state_lock = services.rooms.state.mutex.lock(&body.room_id).await;
 
 	// Send a m.room.tombstone event to the old room to indicate that it is not
 	// intended to be used any further Fail if the sender does not have the required
 	// permissions
-	let tombstone_event_id = services()
+	let tombstone_event_id = services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -586,11 +593,11 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 
 	// Change lock to replacement room
 	drop(state_lock);
-	let state_lock = services().rooms.state.mutex.lock(&replacement_room).await;
+	let state_lock = services.rooms.state.mutex.lock(&replacement_room).await;
 
 	// Get the old room creation event
 	let mut create_event_content = serde_json::from_str::<CanonicalJsonObject>(
-		services()
+		services
 			.rooms
 			.state_accessor
 			.room_state_get(&body.room_id, &StateEventType::RoomCreate, "")?
@@ -658,7 +665,7 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 		return Err(Error::BadRequest(ErrorKind::BadJson, "Error forming creation event"));
 	}
 
-	services()
+	services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -676,7 +683,7 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 		.await?;
 
 	// Join the new room
-	services()
+	services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -684,11 +691,11 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 				event_type: TimelineEventType::RoomMember,
 				content: to_raw_value(&RoomMemberEventContent {
 					membership: MembershipState::Join,
-					displayname: services().users.displayname(sender_user)?,
-					avatar_url: services().users.avatar_url(sender_user)?,
+					displayname: services.users.displayname(sender_user)?,
+					avatar_url: services.users.avatar_url(sender_user)?,
 					is_direct: None,
 					third_party_invite: None,
-					blurhash: services().users.blurhash(sender_user)?,
+					blurhash: services.users.blurhash(sender_user)?,
 					reason: None,
 					join_authorized_via_users_server: None,
 				})
@@ -705,7 +712,7 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 
 	// Replicate transferable state events to the new room
 	for event_type in TRANSFERABLE_STATE_EVENTS {
-		let event_content = match services()
+		let event_content = match services
 			.rooms
 			.state_accessor
 			.room_state_get(&body.room_id, event_type, "")?
@@ -714,7 +721,7 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 			None => continue, // Skipping missing events.
 		};
 
-		services()
+		services
 			.rooms
 			.timeline
 			.build_and_append_pdu(
@@ -733,13 +740,13 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 	}
 
 	// Moves any local aliases to the new room
-	for alias in services()
+	for alias in services
 		.rooms
 		.alias
 		.local_aliases_for_room(&body.room_id)
 		.filter_map(Result::ok)
 	{
-		services()
+		services
 			.rooms
 			.alias
 			.set_alias(&alias, &replacement_room, sender_user)?;
@@ -747,7 +754,7 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 
 	// Get the old room power levels
 	let mut power_levels_event_content: RoomPowerLevelsEventContent = serde_json::from_str(
-		services()
+		services
 			.rooms
 			.state_accessor
 			.room_state_get(&body.room_id, &StateEventType::RoomPowerLevels, "")?
@@ -772,7 +779,7 @@ pub(crate) async fn upgrade_room_route(body: Ruma<upgrade_room::v3::Request>) ->
 
 	// Modify the power levels in the old room to prevent sending of events and
 	// inviting new users
-	services()
+	services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -841,7 +848,7 @@ fn default_power_levels_content(
 
 /// if a room is being created with a room alias, run our checks
 async fn room_alias_check(
-	room_alias_name: &str, appservice_info: &Option<RegistrationInfo>,
+	services: &Services, room_alias_name: &str, appservice_info: &Option<RegistrationInfo>,
 ) -> Result<OwnedRoomAliasId> {
 	// Basic checks on the room alias validity
 	if room_alias_name.contains(':') {
@@ -858,7 +865,7 @@ async fn room_alias_check(
 	}
 
 	// check if room alias is forbidden
-	if services()
+	if services
 		.globals
 		.forbidden_alias_names()
 		.is_match(room_alias_name)
@@ -866,13 +873,13 @@ async fn room_alias_check(
 		return Err(Error::BadRequest(ErrorKind::Unknown, "Room alias name is forbidden."));
 	}
 
-	let full_room_alias = RoomAliasId::parse(format!("#{}:{}", room_alias_name, services().globals.config.server_name))
+	let full_room_alias = RoomAliasId::parse(format!("#{}:{}", room_alias_name, services.globals.config.server_name))
 		.map_err(|e| {
-			info!("Failed to parse room alias {room_alias_name}: {e}");
-			Error::BadRequest(ErrorKind::InvalidParam, "Invalid room alias specified.")
-		})?;
+		info!("Failed to parse room alias {room_alias_name}: {e}");
+		Error::BadRequest(ErrorKind::InvalidParam, "Invalid room alias specified.")
+	})?;
 
-	if services()
+	if services
 		.rooms
 		.alias
 		.resolve_local_alias(&full_room_alias)?
@@ -885,7 +892,7 @@ async fn room_alias_check(
 		if !info.aliases.is_match(full_room_alias.as_str()) {
 			return Err(Error::BadRequest(ErrorKind::Exclusive, "Room alias is not in namespace."));
 		}
-	} else if services()
+	} else if services
 		.appservice
 		.is_exclusive_alias(&full_room_alias)
 		.await
@@ -899,9 +906,9 @@ async fn room_alias_check(
 }
 
 /// if a room is being created with a custom room ID, run our checks against it
-fn custom_room_id_check(custom_room_id: &str) -> Result<OwnedRoomId> {
+fn custom_room_id_check(services: &Services, custom_room_id: &str) -> Result<OwnedRoomId> {
 	// apply forbidden room alias checks to custom room IDs too
-	if services()
+	if services
 		.globals
 		.forbidden_alias_names()
 		.is_match(custom_room_id)
@@ -922,7 +929,7 @@ fn custom_room_id_check(custom_room_id: &str) -> Result<OwnedRoomId> {
 		));
 	}
 
-	let full_room_id = format!("!{}:{}", custom_room_id, services().globals.config.server_name);
+	let full_room_id = format!("!{}:{}", custom_room_id, services.globals.config.server_name);
 
 	debug_info!("Full custom room ID: {full_room_id}");
 

src/api/client/search.rs

@@ -1,5 +1,6 @@
 use std::collections::BTreeMap;
 
+use axum::extract::State;
 use ruma::{
 	api::client::{
 		error::ErrorKind,
@@ -14,7 +15,7 @@ use ruma::{
 };
 use tracing::debug;
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `POST /_matrix/client/r0/search`
 ///
@@ -22,7 +23,9 @@ use crate::{services, Error, Result, Ruma};
 ///
 /// - Only works if the user is currently joined to the room (TODO: Respect
 ///   history visibility)
-pub(crate) async fn search_events_route(body: Ruma<search_events::v3::Request>) -> Result<search_events::v3::Response> {
+pub(crate) async fn search_events_route(
+	State(services): State<crate::State>, body: Ruma<search_events::v3::Request>,
+) -> Result<search_events::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let search_criteria = body.search_categories.room_events.as_ref().unwrap();
@@ -30,7 +33,7 @@ pub(crate) async fn search_events_route(body: Ruma<search_events::v3::Request>)
 	let include_state = &search_criteria.include_state;
 
 	let room_ids = filter.rooms.clone().unwrap_or_else(|| {
-		services()
+		services
 			.rooms
 			.state_cache
 			.rooms_joined(sender_user)
@@ -50,11 +53,7 @@ pub(crate) async fn search_events_route(body: Ruma<search_events::v3::Request>)
 
 	if include_state.is_some_and(|include_state| include_state) {
 		for room_id in &room_ids {
-			if !services()
-				.rooms
-				.state_cache
-				.is_joined(sender_user, room_id)?
-			{
+			if !services.rooms.state_cache.is_joined(sender_user, room_id)? {
 				return Err(Error::BadRequest(
 					ErrorKind::forbidden(),
 					"You don't have permission to view this room.",
@@ -62,12 +61,12 @@ pub(crate) async fn search_events_route(body: Ruma<search_events::v3::Request>)
 			}
 
 			// check if sender_user can see state events
-			if services()
+			if services
 				.rooms
 				.state_accessor
 				.user_can_see_state_events(sender_user, room_id)?
 			{
-				let room_state = services()
+				let room_state = services
 					.rooms
 					.state_accessor
 					.room_state_full(room_id)
@@ -91,18 +90,14 @@ pub(crate) async fn search_events_route(body: Ruma<search_events::v3::Request>)
 	let mut searches = Vec::new();
 
 	for room_id in &room_ids {
-		if !services()
-			.rooms
-			.state_cache
-			.is_joined(sender_user, room_id)?
-		{
+		if !services.rooms.state_cache.is_joined(sender_user, room_id)? {
 			return Err(Error::BadRequest(
 				ErrorKind::forbidden(),
 				"You don't have permission to view this room.",
 			));
 		}
 
-		if let Some(search) = services()
+		if let Some(search) = services
 			.rooms
 			.search
 			.search_pdus(room_id, &search_criteria.search_term)?
@@ -135,14 +130,14 @@ pub(crate) async fn search_events_route(body: Ruma<search_events::v3::Request>)
 		.iter()
 		.skip(skip)
 		.filter_map(|result| {
-			services()
+			services
 				.rooms
 				.timeline
 				.get_pdu_from_id(result)
 				.ok()?
 				.filter(|pdu| {
 					!pdu.is_redacted()
-						&& services()
+						&& services
 							.rooms
 							.state_accessor
 							.user_can_see_event(sender_user, &pdu.room_id, &pdu.event_id)

src/api/client/session.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use ruma::{
 	api::client::{
 		error::ErrorKind,
@@ -20,7 +21,7 @@ use serde::Deserialize;
 use tracing::{debug, info, warn};
 
 use super::{DEVICE_ID_LENGTH, TOKEN_LENGTH};
-use crate::{services, utils, utils::hash, Error, Result, Ruma};
+use crate::{utils, utils::hash, Error, Result, Ruma};
 
 #[derive(Debug, Deserialize)]
 struct Claims {
@@ -55,7 +56,9 @@ pub(crate) async fn get_login_types_route(
 /// Note: You can use [`GET
 /// /_matrix/client/r0/login`](fn.get_supported_versions_route.html) to see
 /// supported login types.
-pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login::v3::Response> {
+pub(crate) async fn login_route(
+	State(services): State<crate::State>, body: Ruma<login::v3::Request>,
+) -> Result<login::v3::Response> {
 	// Validate login method
 	// TODO: Other login methods
 	let user_id = match &body.login_info {
@@ -68,7 +71,7 @@ pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login:
 		}) => {
 			debug!("Got password login type");
 			let user_id = if let Some(UserIdentifier::UserIdOrLocalpart(user_id)) = identifier {
-				UserId::parse_with_server_name(user_id.to_lowercase(), services().globals.server_name())
+				UserId::parse_with_server_name(user_id.to_lowercase(), services.globals.server_name())
 			} else if let Some(user) = user {
 				UserId::parse(user)
 			} else {
@@ -77,7 +80,7 @@ pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login:
 			}
 			.map_err(|_| Error::BadRequest(ErrorKind::InvalidUsername, "Username is invalid."))?;
 
-			let hash = services()
+			let hash = services
 				.users
 				.password_hash(&user_id)?
 				.ok_or(Error::BadRequest(ErrorKind::forbidden(), "Wrong username or password."))?;
@@ -96,7 +99,7 @@ pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login:
 			token,
 		}) => {
 			debug!("Got token login type");
-			if let Some(jwt_decoding_key) = services().globals.jwt_decoding_key() {
+			if let Some(jwt_decoding_key) = services.globals.jwt_decoding_key() {
 				let token =
 					jsonwebtoken::decode::<Claims>(token, jwt_decoding_key, &jsonwebtoken::Validation::default())
 						.map_err(|e| {
@@ -106,7 +109,7 @@ pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login:
 
 				let username = token.claims.sub.to_lowercase();
 
-				UserId::parse_with_server_name(username, services().globals.server_name()).map_err(|e| {
+				UserId::parse_with_server_name(username, services.globals.server_name()).map_err(|e| {
 					warn!("Failed to parse username from user logging in: {e}");
 					Error::BadRequest(ErrorKind::InvalidUsername, "Username is invalid.")
 				})?
@@ -124,7 +127,7 @@ pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login:
 		}) => {
 			debug!("Got appservice login type");
 			let user_id = if let Some(UserIdentifier::UserIdOrLocalpart(user_id)) = identifier {
-				UserId::parse_with_server_name(user_id.to_lowercase(), services().globals.server_name())
+				UserId::parse_with_server_name(user_id.to_lowercase(), services.globals.server_name())
 			} else if let Some(user) = user {
 				UserId::parse(user)
 			} else {
@@ -164,22 +167,22 @@ pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login:
 
 	// Determine if device_id was provided and exists in the db for this user
 	let device_exists = body.device_id.as_ref().map_or(false, |device_id| {
-		services()
+		services
 			.users
 			.all_device_ids(&user_id)
 			.any(|x| x.as_ref().map_or(false, |v| v == device_id))
 	});
 
 	if device_exists {
-		services().users.set_token(&user_id, &device_id, &token)?;
+		services.users.set_token(&user_id, &device_id, &token)?;
 	} else {
-		services()
+		services
 			.users
 			.create_device(&user_id, &device_id, &token, body.initial_device_display_name.clone())?;
 	}
 
 	// send client well-known if specified so the client knows to reconfigure itself
-	let client_discovery_info: Option<DiscoveryInfo> = services()
+	let client_discovery_info: Option<DiscoveryInfo> = services
 		.globals
 		.well_known_client()
 		.as_ref()
@@ -197,7 +200,7 @@ pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login:
 		device_id,
 		well_known: client_discovery_info,
 		expires_in: None,
-		home_server: Some(services().globals.server_name().to_owned()),
+		home_server: Some(services.globals.server_name().to_owned()),
 		refresh_token: None,
 	})
 }
@@ -211,14 +214,16 @@ pub(crate) async fn login_route(body: Ruma<login::v3::Request>) -> Result<login:
 ///   last seen ts)
 /// - Forgets to-device events
 /// - Triggers device list updates
-pub(crate) async fn logout_route(body: Ruma<logout::v3::Request>) -> Result<logout::v3::Response> {
+pub(crate) async fn logout_route(
+	State(services): State<crate::State>, body: Ruma<logout::v3::Request>,
+) -> Result<logout::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
-	services().users.remove_device(sender_user, sender_device)?;
+	services.users.remove_device(sender_user, sender_device)?;
 
 	// send device list update for user after logout
-	services().users.mark_device_key_update(sender_user)?;
+	services.users.mark_device_key_update(sender_user)?;
 
 	Ok(logout::v3::Response::new())
 }
@@ -236,15 +241,17 @@ pub(crate) async fn logout_route(body: Ruma<logout::v3::Request>) -> Result<logo
 /// Note: This is equivalent to calling [`GET
 /// /_matrix/client/r0/logout`](fn.logout_route.html) from each device of this
 /// user.
-pub(crate) async fn logout_all_route(body: Ruma<logout_all::v3::Request>) -> Result<logout_all::v3::Response> {
+pub(crate) async fn logout_all_route(
+	State(services): State<crate::State>, body: Ruma<logout_all::v3::Request>,
+) -> Result<logout_all::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	for device_id in services().users.all_device_ids(sender_user).flatten() {
-		services().users.remove_device(sender_user, &device_id)?;
+	for device_id in services.users.all_device_ids(sender_user).flatten() {
+		services.users.remove_device(sender_user, &device_id)?;
 	}
 
 	// send device list update for user after logout
-	services().users.mark_device_key_update(sender_user)?;
+	services.users.mark_device_key_update(sender_user)?;
 
 	Ok(logout_all::v3::Response::new())
 }

src/api/client/space.rs

@@ -1,17 +1,20 @@
 use std::str::FromStr;
 
+use axum::extract::State;
 use ruma::{
 	api::client::{error::ErrorKind, space::get_hierarchy},
 	UInt,
 };
 
-use crate::{service::rooms::spaces::PaginationToken, services, Error, Result, Ruma};
+use crate::{service::rooms::spaces::PaginationToken, Error, Result, Ruma};
 
 /// # `GET /_matrix/client/v1/rooms/{room_id}/hierarchy`
 ///
 /// Paginates over the space tree in a depth-first manner to locate child rooms
 /// of a given space.
-pub(crate) async fn get_hierarchy_route(body: Ruma<get_hierarchy::v1::Request>) -> Result<get_hierarchy::v1::Response> {
+pub(crate) async fn get_hierarchy_route(
+	State(services): State<crate::State>, body: Ruma<get_hierarchy::v1::Request>,
+) -> Result<get_hierarchy::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	let limit = body
@@ -39,7 +42,7 @@ pub(crate) async fn get_hierarchy_route(body: Ruma<get_hierarchy::v1::Request>)
 		}
 	}
 
-	services()
+	services
 		.rooms
 		.spaces
 		.get_client_hierarchy(

src/api/client/state.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
-use conduit::{debug_info, error};
+use axum::extract::State;
+use conduit::{debug_info, error, pdu::PduBuilder, Error, Result};
 use ruma::{
 	api::client::{
 		error::ErrorKind,
@@ -17,11 +18,9 @@ use ruma::{
 	serde::Raw,
 	EventId, RoomId, UserId,
 };
+use service::Services;
 
-use crate::{
-	service::{pdu::PduBuilder, server_is_ours},
-	services, Error, Result, Ruma, RumaResponse,
-};
+use crate::{Ruma, RumaResponse};
 
 /// # `PUT /_matrix/client/*/rooms/{roomId}/state/{eventType}/{stateKey}`
 ///
@@ -32,12 +31,13 @@ use crate::{
 ///   allowed
 /// - If event is new `canonical_alias`: Rejects if alias is incorrect
 pub(crate) async fn send_state_event_for_key_route(
-	body: Ruma<send_state_event::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<send_state_event::v3::Request>,
 ) -> Result<send_state_event::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	Ok(send_state_event::v3::Response {
 		event_id: send_state_event_for_key_helper(
+			&services,
 			sender_user,
 			&body.room_id,
 			&body.event_type,
@@ -58,9 +58,11 @@ pub(crate) async fn send_state_event_for_key_route(
 ///   allowed
 /// - If event is new `canonical_alias`: Rejects if alias is incorrect
 pub(crate) async fn send_state_event_for_empty_key_route(
-	body: Ruma<send_state_event::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<send_state_event::v3::Request>,
 ) -> Result<RumaResponse<send_state_event::v3::Response>> {
-	send_state_event_for_key_route(body).await.map(RumaResponse)
+	send_state_event_for_key_route(State(services), body)
+		.await
+		.map(RumaResponse)
 }
 
 /// # `GET /_matrix/client/v3/rooms/{roomid}/state`
@@ -70,11 +72,11 @@ pub(crate) async fn send_state_event_for_empty_key_route(
 /// - If not joined: Only works if current room history visibility is world
 ///   readable
 pub(crate) async fn get_state_events_route(
-	body: Ruma<get_state_events::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_state_events::v3::Request>,
 ) -> Result<get_state_events::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.user_can_see_state_events(sender_user, &body.room_id)?
@@ -86,7 +88,7 @@ pub(crate) async fn get_state_events_route(
 	}
 
 	Ok(get_state_events::v3::Response {
-		room_state: services()
+		room_state: services
 			.rooms
 			.state_accessor
 			.room_state_full(&body.room_id)
@@ -106,11 +108,11 @@ pub(crate) async fn get_state_events_route(
 /// - If not joined: Only works if current room history visibility is world
 ///   readable
 pub(crate) async fn get_state_events_for_key_route(
-	body: Ruma<get_state_events_for_key::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_state_events_for_key::v3::Request>,
 ) -> Result<get_state_events_for_key::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.user_can_see_state_events(sender_user, &body.room_id)?
@@ -121,7 +123,7 @@ pub(crate) async fn get_state_events_for_key_route(
 		));
 	}
 
-	let event = services()
+	let event = services
 		.rooms
 		.state_accessor
 		.room_state_get(&body.room_id, &body.event_type, &body.state_key)?
@@ -161,17 +163,20 @@ pub(crate) async fn get_state_events_for_key_route(
 /// - If not joined: Only works if current room history visibility is world
 ///   readable
 pub(crate) async fn get_state_events_for_empty_key_route(
-	body: Ruma<get_state_events_for_key::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_state_events_for_key::v3::Request>,
 ) -> Result<RumaResponse<get_state_events_for_key::v3::Response>> {
-	get_state_events_for_key_route(body).await.map(RumaResponse)
+	get_state_events_for_key_route(State(services), body)
+		.await
+		.map(RumaResponse)
 }
 
 async fn send_state_event_for_key_helper(
-	sender: &UserId, room_id: &RoomId, event_type: &StateEventType, json: &Raw<AnyStateEventContent>, state_key: String,
+	services: &Services, sender: &UserId, room_id: &RoomId, event_type: &StateEventType,
+	json: &Raw<AnyStateEventContent>, state_key: String,
 ) -> Result<Arc<EventId>> {
-	allowed_to_send_state_event(room_id, event_type, json).await?;
-	let state_lock = services().rooms.state.mutex.lock(room_id).await;
-	let event_id = services()
+	allowed_to_send_state_event(services, room_id, event_type, json).await?;
+	let state_lock = services.rooms.state.mutex.lock(room_id).await;
+	let event_id = services
 		.rooms
 		.timeline
 		.build_and_append_pdu(
@@ -192,18 +197,18 @@ async fn send_state_event_for_key_helper(
 }
 
 async fn allowed_to_send_state_event(
-	room_id: &RoomId, event_type: &StateEventType, json: &Raw<AnyStateEventContent>,
+	services: &Services, room_id: &RoomId, event_type: &StateEventType, json: &Raw<AnyStateEventContent>,
 ) -> Result<()> {
 	match event_type {
 		// Forbid m.room.encryption if encryption is disabled
 		StateEventType::RoomEncryption => {
-			if !services().globals.allow_encryption() {
+			if !services.globals.allow_encryption() {
 				return Err(Error::BadRequest(ErrorKind::forbidden(), "Encryption has been disabled"));
 			}
 		},
 		// admin room is a sensitive room, it should not ever be made public
 		StateEventType::RoomJoinRules => {
-			if let Some(admin_room_id) = service::admin::Service::get_admin_room()? {
+			if let Some(admin_room_id) = services.admin.get_admin_room()? {
 				if admin_room_id == room_id {
 					if let Ok(join_rule) = serde_json::from_str::<RoomJoinRulesEventContent>(json.json().get()) {
 						if join_rule.join_rule == JoinRule::Public {
@@ -218,7 +223,7 @@ async fn allowed_to_send_state_event(
 		},
 		// admin room is a sensitive room, it should not ever be made world readable
 		StateEventType::RoomHistoryVisibility => {
-			if let Some(admin_room_id) = service::admin::Service::get_admin_room()? {
+			if let Some(admin_room_id) = services.admin.get_admin_room()? {
 				if admin_room_id == room_id {
 					if let Ok(visibility_content) =
 						serde_json::from_str::<RoomHistoryVisibilityEventContent>(json.json().get())
@@ -243,8 +248,8 @@ async fn allowed_to_send_state_event(
 				}
 
 				for alias in aliases {
-					if !server_is_ours(alias.server_name())
-						|| services()
+					if !services.globals.server_is_ours(alias.server_name())
+						|| services
                            .rooms
                            .alias
                            .resolve_local_alias(&alias)?

src/api/client/sync.rs

@@ -5,6 +5,7 @@ use std::{
 	time::Duration,
 };
 
+use axum::extract::State;
 use conduit::{
 	error,
 	utils::math::{ruma_from_u64, ruma_from_usize, usize_from_ruma, usize_from_u64_truncated},
@@ -17,7 +18,7 @@ use ruma::{
 			self,
 			v3::{
 				Ephemeral, Filter, GlobalAccountData, InviteState, InvitedRoom, JoinedRoom, LeftRoom, Presence,
-				RoomAccountData, RoomSummary, Rooms, State, Timeline, ToDevice,
+				RoomAccountData, RoomSummary, Rooms, State as RoomState, Timeline, ToDevice,
 			},
 			v4::SlidingOp,
 			DeviceLists, UnreadNotificationsCount,
@@ -34,7 +35,10 @@ use ruma::{
 };
 use tracing::{Instrument as _, Span};
 
-use crate::{service::pdu::EventHash, services, utils, Error, PduEvent, Result, Ruma, RumaResponse};
+use crate::{
+	service::{pdu::EventHash, Services},
+	utils, Error, PduEvent, Result, Ruma, RumaResponse,
+};
 
 /// # `GET /_matrix/client/r0/sync`
 ///
@@ -72,23 +76,23 @@ use crate::{service::pdu::EventHash, services, utils, Error, PduEvent, Result, R
 /// - If the user left after `since`: `prev_batch` token, empty state (TODO:
 ///   subset of the state at the point of the leave)
 pub(crate) async fn sync_events_route(
-	body: Ruma<sync_events::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<sync_events::v3::Request>,
 ) -> Result<sync_events::v3::Response, RumaResponse<UiaaResponse>> {
 	let sender_user = body.sender_user.expect("user is authenticated");
 	let sender_device = body.sender_device.expect("user is authenticated");
 	let body = body.body;
 
 	// Presence update
-	if services().globals.allow_local_presence() {
-		services()
+	if services.globals.allow_local_presence() {
+		services
 			.presence
 			.ping_presence(&sender_user, &body.set_presence)?;
 	}
 
 	// Setup watchers, so if there's no response, we can wait for them
-	let watcher = services().globals.watch(&sender_user, &sender_device);
+	let watcher = services.globals.watch(&sender_user, &sender_device);
 
-	let next_batch = services().globals.current_count()?;
+	let next_batch = services.globals.current_count()?;
 	let next_batchcount = PduCount::Normal(next_batch);
 	let next_batch_string = next_batch.to_string();
 
@@ -96,7 +100,7 @@ pub(crate) async fn sync_events_route(
 	let filter = match body.filter {
 		None => FilterDefinition::default(),
 		Some(Filter::FilterDefinition(filter)) => filter,
-		Some(Filter::FilterId(filter_id)) => services()
+		Some(Filter::FilterId(filter_id)) => services
 			.users
 			.get_filter(&sender_user, &filter_id)?
 			.unwrap_or_default(),
@@ -126,28 +130,29 @@ pub(crate) async fn sync_events_route(
 
 	// Look for device list updates of this account
 	device_list_updates.extend(
-		services()
+		services
 			.users
 			.keys_changed(sender_user.as_ref(), since, None)
 			.filter_map(Result::ok),
 	);
 
-	if services().globals.allow_local_presence() {
-		process_presence_updates(&mut presence_updates, since, &sender_user).await?;
+	if services.globals.allow_local_presence() {
+		process_presence_updates(&services, &mut presence_updates, since, &sender_user).await?;
 	}
 
-	let all_joined_rooms = services()
+	let all_joined_rooms = services
 		.rooms
 		.state_cache
 		.rooms_joined(&sender_user)
 		.collect::<Vec<_>>();
 
 	// Coalesce database writes for the remainder of this scope.
-	let _cork = services().db.cork_and_flush();
+	let _cork = services.db.cork_and_flush();
 
 	for room_id in all_joined_rooms {
 		let room_id = room_id?;
 		if let Ok(joined_room) = load_joined_room(
+			&services,
 			&sender_user,
 			&sender_device,
 			&room_id,
@@ -170,13 +175,14 @@ pub(crate) async fn sync_events_route(
 	}
 
 	let mut left_rooms = BTreeMap::new();
-	let all_left_rooms: Vec<_> = services()
+	let all_left_rooms: Vec<_> = services
 		.rooms
 		.state_cache
 		.rooms_left(&sender_user)
 		.collect();
 	for result in all_left_rooms {
 		handle_left_room(
+			&services,
 			since,
 			&result?.0,
 			&sender_user,
@@ -190,7 +196,7 @@ pub(crate) async fn sync_events_route(
 	}
 
 	let mut invited_rooms = BTreeMap::new();
-	let all_invited_rooms: Vec<_> = services()
+	let all_invited_rooms: Vec<_> = services
 		.rooms
 		.state_cache
 		.rooms_invited(&sender_user)
@@ -199,10 +205,10 @@ pub(crate) async fn sync_events_route(
 		let (room_id, invite_state_events) = result?;
 
 		// Get and drop the lock to wait for remaining operations to finish
-		let insert_lock = services().rooms.timeline.mutex_insert.lock(&room_id).await;
+		let insert_lock = services.rooms.timeline.mutex_insert.lock(&room_id).await;
 		drop(insert_lock);
 
-		let invite_count = services()
+		let invite_count = services
 			.rooms
 			.state_cache
 			.get_invite_count(&room_id, &sender_user)?;
@@ -223,14 +229,14 @@ pub(crate) async fn sync_events_route(
 	}
 
 	for user_id in left_encrypted_users {
-		let dont_share_encrypted_room = services()
+		let dont_share_encrypted_room = services
 			.rooms
 			.user
 			.get_shared_rooms(vec![sender_user.clone(), user_id.clone()])?
 			.filter_map(Result::ok)
 			.filter_map(|other_room_id| {
 				Some(
-					services()
+					services
 						.rooms
 						.state_accessor
 						.room_state_get(&other_room_id, &StateEventType::RoomEncryption, "")
@@ -247,7 +253,7 @@ pub(crate) async fn sync_events_route(
 	}
 
 	// Remove all to-device events the device received *last time*
-	services()
+	services
 		.users
 		.remove_to_device_events(&sender_user, &sender_device, since)?;
 
@@ -266,7 +272,7 @@ pub(crate) async fn sync_events_route(
 				.collect(),
 		},
 		account_data: GlobalAccountData {
-			events: services()
+			events: services
 				.account_data
 				.changes_since(None, &sender_user, since)?
 				.into_iter()
@@ -281,11 +287,11 @@ pub(crate) async fn sync_events_route(
 			changed: device_list_updates.into_iter().collect(),
 			left: device_list_left.into_iter().collect(),
 		},
-		device_one_time_keys_count: services()
+		device_one_time_keys_count: services
 			.users
 			.count_one_time_keys(&sender_user, &sender_device)?,
 		to_device: ToDevice {
-			events: services()
+			events: services
 				.users
 				.get_to_device_events(&sender_user, &sender_device)?,
 		},
@@ -311,16 +317,18 @@ pub(crate) async fn sync_events_route(
 	Ok(response)
 }
 
+#[allow(clippy::too_many_arguments)]
 #[tracing::instrument(skip_all, fields(user_id = %sender_user, room_id = %room_id), name = "left_room")]
 async fn handle_left_room(
-	since: u64, room_id: &RoomId, sender_user: &UserId, left_rooms: &mut BTreeMap<ruma::OwnedRoomId, LeftRoom>,
-	next_batch_string: &str, full_state: bool, lazy_load_enabled: bool,
+	services: &Services, since: u64, room_id: &RoomId, sender_user: &UserId,
+	left_rooms: &mut BTreeMap<ruma::OwnedRoomId, LeftRoom>, next_batch_string: &str, full_state: bool,
+	lazy_load_enabled: bool,
 ) -> Result<()> {
 	// Get and drop the lock to wait for remaining operations to finish
-	let insert_lock = services().rooms.timeline.mutex_insert.lock(room_id).await;
+	let insert_lock = services.rooms.timeline.mutex_insert.lock(room_id).await;
 	drop(insert_lock);
 
-	let left_count = services()
+	let left_count = services
 		.rooms
 		.state_cache
 		.get_left_count(room_id, sender_user)?;
@@ -330,11 +338,11 @@ async fn handle_left_room(
 		return Ok(());
 	}
 
-	if !services().rooms.metadata.exists(room_id)? {
+	if !services.rooms.metadata.exists(room_id)? {
 		// This is just a rejected invite, not a room we know
 		// Insert a leave event anyways
 		let event = PduEvent {
-			event_id: EventId::new(services().globals.server_name()).into(),
+			event_id: EventId::new(services.globals.server_name()).into(),
 			sender: sender_user.to_owned(),
 			origin: None,
 			origin_server_ts: utils::millis_since_unix_epoch()
@@ -367,7 +375,7 @@ async fn handle_left_room(
 					prev_batch: Some(next_batch_string.to_owned()),
 					events: Vec::new(),
 				},
-				state: State {
+				state: RoomState {
 					events: vec![event.to_sync_state_event()],
 				},
 			},
@@ -377,27 +385,27 @@ async fn handle_left_room(
 
 	let mut left_state_events = Vec::new();
 
-	let since_shortstatehash = services()
+	let since_shortstatehash = services
 		.rooms
 		.user
 		.get_token_shortstatehash(room_id, since)?;
 
 	let since_state_ids = match since_shortstatehash {
-		Some(s) => services().rooms.state_accessor.state_full_ids(s).await?,
+		Some(s) => services.rooms.state_accessor.state_full_ids(s).await?,
 		None => HashMap::new(),
 	};
 
-	let Some(left_event_id) = services().rooms.state_accessor.room_state_get_id(
-		room_id,
-		&StateEventType::RoomMember,
-		sender_user.as_str(),
-	)?
+	let Some(left_event_id) =
+		services
+			.rooms
+			.state_accessor
+			.room_state_get_id(room_id, &StateEventType::RoomMember, sender_user.as_str())?
 	else {
 		error!("Left room but no left state event");
 		return Ok(());
 	};
 
-	let Some(left_shortstatehash) = services()
+	let Some(left_shortstatehash) = services
 		.rooms
 		.state_accessor
 		.pdu_shortstatehash(&left_event_id)?
@@ -406,13 +414,13 @@ async fn handle_left_room(
 		return Ok(());
 	};
 
-	let mut left_state_ids = services()
+	let mut left_state_ids = services
 		.rooms
 		.state_accessor
 		.state_full_ids(left_shortstatehash)
 		.await?;
 
-	let leave_shortstatekey = services()
+	let leave_shortstatekey = services
 		.rooms
 		.short
 		.get_or_create_shortstatekey(&StateEventType::RoomMember, sender_user.as_str())?;
@@ -422,7 +430,7 @@ async fn handle_left_room(
 	let mut i: u8 = 0;
 	for (key, id) in left_state_ids {
 		if full_state || since_state_ids.get(&key) != Some(&id) {
-			let (event_type, state_key) = services().rooms.short.get_statekey_from_short(key)?;
+			let (event_type, state_key) = services.rooms.short.get_statekey_from_short(key)?;
 
 			if !lazy_load_enabled
                     || event_type != StateEventType::RoomMember
@@ -430,7 +438,7 @@ async fn handle_left_room(
                     // TODO: Delete the following line when this is resolved: https://github.com/vector-im/element-web/issues/22565
                     || (cfg!(feature = "element_hacks") && *sender_user == state_key)
 			{
-				let Some(pdu) = services().rooms.timeline.get_pdu(&id)? else {
+				let Some(pdu) = services.rooms.timeline.get_pdu(&id)? else {
 					error!("Pdu in state not found: {}", id);
 					continue;
 				};
@@ -456,7 +464,7 @@ async fn handle_left_room(
 				prev_batch: Some(next_batch_string.to_owned()),
 				events: Vec::new(),
 			},
-			state: State {
+			state: RoomState {
 				events: left_state_events,
 			},
 		},
@@ -465,13 +473,11 @@ async fn handle_left_room(
 }
 
 async fn process_presence_updates(
-	presence_updates: &mut HashMap<OwnedUserId, PresenceEvent>, since: u64, syncing_user: &UserId,
+	services: &Services, presence_updates: &mut HashMap<OwnedUserId, PresenceEvent>, since: u64, syncing_user: &UserId,
 ) -> Result<()> {
-	use crate::service::presence::Presence;
-
 	// Take presence updates
-	for (user_id, _, presence_bytes) in services().presence.presence_since(since) {
-		if !services()
+	for (user_id, _, presence_bytes) in services.presence.presence_since(since) {
+		if !services
 			.rooms
 			.state_cache
 			.user_sees_user(syncing_user, &user_id)?
@@ -479,7 +485,9 @@ async fn process_presence_updates(
 			continue;
 		}
 
-		let presence_event = Presence::from_json_bytes_to_event(&presence_bytes, &user_id)?;
+		let presence_event = services
+			.presence
+			.from_json_bytes_to_event(&presence_bytes, &user_id)?;
 		match presence_updates.entry(user_id) {
 			Entry::Vacant(slot) => {
 				slot.insert(presence_event);
@@ -513,19 +521,20 @@ async fn process_presence_updates(
 
 #[allow(clippy::too_many_arguments)]
 async fn load_joined_room(
-	sender_user: &UserId, sender_device: &DeviceId, room_id: &RoomId, since: u64, sincecount: PduCount,
-	next_batch: u64, next_batchcount: PduCount, lazy_load_enabled: bool, lazy_load_send_redundant: bool,
-	full_state: bool, device_list_updates: &mut HashSet<OwnedUserId>, left_encrypted_users: &mut HashSet<OwnedUserId>,
+	services: &Services, sender_user: &UserId, sender_device: &DeviceId, room_id: &RoomId, since: u64,
+	sincecount: PduCount, next_batch: u64, next_batchcount: PduCount, lazy_load_enabled: bool,
+	lazy_load_send_redundant: bool, full_state: bool, device_list_updates: &mut HashSet<OwnedUserId>,
+	left_encrypted_users: &mut HashSet<OwnedUserId>,
 ) -> Result<JoinedRoom> {
 	// Get and drop the lock to wait for remaining operations to finish
 	// This will make sure the we have all events until next_batch
-	let insert_lock = services().rooms.timeline.mutex_insert.lock(room_id).await;
+	let insert_lock = services.rooms.timeline.mutex_insert.lock(room_id).await;
 	drop(insert_lock);
 
-	let (timeline_pdus, limited) = load_timeline(sender_user, room_id, sincecount, 10)?;
+	let (timeline_pdus, limited) = load_timeline(services, sender_user, room_id, sincecount, 10)?;
 
 	let send_notification_counts = !timeline_pdus.is_empty()
-		|| services()
+		|| services
 			.rooms
 			.user
 			.last_notification_read(sender_user, room_id)?
@@ -536,7 +545,7 @@ async fn load_joined_room(
 		timeline_users.insert(event.sender.as_str().to_owned());
 	}
 
-	services()
+	services
 		.rooms
 		.lazy_loading
 		.lazy_load_confirm_delivery(sender_user, sender_device, room_id, sincecount)
@@ -544,11 +553,11 @@ async fn load_joined_room(
 
 	// Database queries:
 
-	let Some(current_shortstatehash) = services().rooms.state.get_room_shortstatehash(room_id)? else {
+	let Some(current_shortstatehash) = services.rooms.state.get_room_shortstatehash(room_id)? else {
 		return Err!(Database(error!("Room {room_id} has no state")));
 	};
 
-	let since_shortstatehash = services()
+	let since_shortstatehash = services
 		.rooms
 		.user
 		.get_token_shortstatehash(room_id, since)?;
@@ -560,12 +569,12 @@ async fn load_joined_room(
 		} else {
 			// Calculates joined_member_count, invited_member_count and heroes
 			let calculate_counts = || {
-				let joined_member_count = services()
+				let joined_member_count = services
 					.rooms
 					.state_cache
 					.room_joined_count(room_id)?
 					.unwrap_or(0);
-				let invited_member_count = services()
+				let invited_member_count = services
 					.rooms
 					.state_cache
 					.room_invited_count(room_id)?
@@ -578,7 +587,7 @@ async fn load_joined_room(
 					// Go through all PDUs and for each member event, check if the user is still
 					// joined or invited until we have 5 or we reach the end
 
-					for hero in services()
+					for hero in services
 					.rooms
 					.timeline
 					.all_pdus(sender_user, room_id)?
@@ -594,8 +603,8 @@ async fn load_joined_room(
 
 							// The membership was and still is invite or join
 							if matches!(content.membership, MembershipState::Join | MembershipState::Invite)
-								&& (services().rooms.state_cache.is_joined(&user_id, room_id)?
-									|| services().rooms.state_cache.is_invited(&user_id, room_id)?)
+								&& (services.rooms.state_cache.is_joined(&user_id, room_id)?
+									|| services.rooms.state_cache.is_invited(&user_id, room_id)?)
 							{
 								Ok::<_, Error>(Some(user_id))
 							} else {
@@ -622,7 +631,7 @@ async fn load_joined_room(
 
 			let since_sender_member: Option<RoomMemberEventContent> = since_shortstatehash
 				.and_then(|shortstatehash| {
-					services()
+					services
 						.rooms
 						.state_accessor
 						.state_get(shortstatehash, &StateEventType::RoomMember, sender_user.as_str())
@@ -643,7 +652,7 @@ async fn load_joined_room(
 
 				let (joined_member_count, invited_member_count, heroes) = calculate_counts()?;
 
-				let current_state_ids = services()
+				let current_state_ids = services
 					.rooms
 					.state_accessor
 					.state_full_ids(current_shortstatehash)
@@ -654,13 +663,13 @@ async fn load_joined_room(
 
 				let mut i: u8 = 0;
 				for (shortstatekey, id) in current_state_ids {
-					let (event_type, state_key) = services()
+					let (event_type, state_key) = services
 						.rooms
 						.short
 						.get_statekey_from_short(shortstatekey)?;
 
 					if event_type != StateEventType::RoomMember {
-						let Some(pdu) = services().rooms.timeline.get_pdu(&id)? else {
+						let Some(pdu) = services.rooms.timeline.get_pdu(&id)? else {
 							error!("Pdu in state not found: {}", id);
 							continue;
 						};
@@ -676,7 +685,7 @@ async fn load_joined_room(
                 // TODO: Delete the following line when this is resolved: https://github.com/vector-im/element-web/issues/22565
                 || (cfg!(feature = "element_hacks") && *sender_user == state_key)
 					{
-						let Some(pdu) = services().rooms.timeline.get_pdu(&id)? else {
+						let Some(pdu) = services.rooms.timeline.get_pdu(&id)? else {
 							error!("Pdu in state not found: {}", id);
 							continue;
 						};
@@ -695,14 +704,14 @@ async fn load_joined_room(
 				}
 
 				// Reset lazy loading because this is an initial sync
-				services()
+				services
 					.rooms
 					.lazy_loading
 					.lazy_load_reset(sender_user, sender_device, room_id)?;
 
 				// The state_events above should contain all timeline_users, let's mark them as
 				// lazy loaded.
-				services()
+				services
 					.rooms
 					.lazy_loading
 					.lazy_load_mark_sent(sender_user, sender_device, room_id, lazy_loaded, next_batchcount)
@@ -716,12 +725,12 @@ async fn load_joined_room(
 				let mut delta_state_events = Vec::new();
 
 				if since_shortstatehash != current_shortstatehash {
-					let current_state_ids = services()
+					let current_state_ids = services
 						.rooms
 						.state_accessor
 						.state_full_ids(current_shortstatehash)
 						.await?;
-					let since_state_ids = services()
+					let since_state_ids = services
 						.rooms
 						.state_accessor
 						.state_full_ids(since_shortstatehash)
@@ -729,7 +738,7 @@ async fn load_joined_room(
 
 					for (key, id) in current_state_ids {
 						if full_state || since_state_ids.get(&key) != Some(&id) {
-							let Some(pdu) = services().rooms.timeline.get_pdu(&id)? else {
+							let Some(pdu) = services.rooms.timeline.get_pdu(&id)? else {
 								error!("Pdu in state not found: {}", id);
 								continue;
 							};
@@ -740,13 +749,13 @@ async fn load_joined_room(
 					}
 				}
 
-				let encrypted_room = services()
+				let encrypted_room = services
 					.rooms
 					.state_accessor
 					.state_get(current_shortstatehash, &StateEventType::RoomEncryption, "")?
 					.is_some();
 
-				let since_encryption = services().rooms.state_accessor.state_get(
+				let since_encryption = services.rooms.state_accessor.state_get(
 					since_shortstatehash,
 					&StateEventType::RoomEncryption,
 					"",
@@ -781,7 +790,7 @@ async fn load_joined_room(
 							match new_membership {
 								MembershipState::Join => {
 									// A new user joined an encrypted room
-									if !share_encrypted_room(sender_user, &user_id, room_id)? {
+									if !share_encrypted_room(services, sender_user, &user_id, room_id)? {
 										device_list_updates.insert(user_id);
 									}
 								},
@@ -798,7 +807,7 @@ async fn load_joined_room(
 				if joined_since_last_sync && encrypted_room || new_encrypted_room {
 					// If the user is in a new encrypted room, give them all joined users
 					device_list_updates.extend(
-						services()
+						services
 							.rooms
 							.state_cache
 							.room_members(room_id)
@@ -810,7 +819,7 @@ async fn load_joined_room(
 							.filter(|user_id| {
 								// Only send keys if the sender doesn't share an encrypted room with the target
 								// already
-								!share_encrypted_room(sender_user, user_id, room_id).unwrap_or(false)
+								!share_encrypted_room(services, sender_user, user_id, room_id).unwrap_or(false)
 							}),
 					);
 				}
@@ -848,14 +857,14 @@ async fn load_joined_room(
 						continue;
 					}
 
-					if !services().rooms.lazy_loading.lazy_load_was_sent_before(
+					if !services.rooms.lazy_loading.lazy_load_was_sent_before(
 						sender_user,
 						sender_device,
 						room_id,
 						&event.sender,
 					)? || lazy_load_send_redundant
 					{
-						if let Some(member_event) = services().rooms.state_accessor.room_state_get(
+						if let Some(member_event) = services.rooms.state_accessor.room_state_get(
 							room_id,
 							&StateEventType::RoomMember,
 							event.sender.as_str(),
@@ -866,7 +875,7 @@ async fn load_joined_room(
 					}
 				}
 
-				services()
+				services
 					.rooms
 					.lazy_loading
 					.lazy_load_mark_sent(sender_user, sender_device, room_id, lazy_loaded, next_batchcount)
@@ -884,7 +893,7 @@ async fn load_joined_room(
 
 	// Look for device list updates in this room
 	device_list_updates.extend(
-		services()
+		services
 			.users
 			.keys_changed(room_id.as_ref(), since, None)
 			.filter_map(Result::ok),
@@ -892,7 +901,7 @@ async fn load_joined_room(
 
 	let notification_count = if send_notification_counts {
 		Some(
-			services()
+			services
 				.rooms
 				.user
 				.notification_count(sender_user, room_id)?
@@ -905,7 +914,7 @@ async fn load_joined_room(
 
 	let highlight_count = if send_notification_counts {
 		Some(
-			services()
+			services
 				.rooms
 				.user
 				.highlight_count(sender_user, room_id)?
@@ -933,7 +942,7 @@ async fn load_joined_room(
 		.map(|(_, pdu)| pdu.to_sync_room_event())
 		.collect();
 
-	let mut edus: Vec<_> = services()
+	let mut edus: Vec<_> = services
 		.rooms
 		.read_receipt
 		.readreceipts_since(room_id, since)
@@ -941,10 +950,10 @@ async fn load_joined_room(
 		.map(|(_, _, v)| v)
 		.collect();
 
-	if services().rooms.typing.last_typing_update(room_id).await? > since {
+	if services.rooms.typing.last_typing_update(room_id).await? > since {
 		edus.push(
 			serde_json::from_str(
-				&serde_json::to_string(&services().rooms.typing.typings_all(room_id).await?)
+				&serde_json::to_string(&services.rooms.typing.typings_all(room_id).await?)
 					.expect("event is valid, we just created it"),
 			)
 			.expect("event is valid, we just created it"),
@@ -953,14 +962,14 @@ async fn load_joined_room(
 
 	// Save the state after this sync so we can send the correct state diff next
 	// sync
-	services()
+	services
 		.rooms
 		.user
 		.associate_token_shortstatehash(room_id, next_batch, current_shortstatehash)?;
 
 	Ok(JoinedRoom {
 		account_data: RoomAccountData {
-			events: services()
+			events: services
 				.account_data
 				.changes_since(Some(room_id), sender_user, since)?
 				.into_iter()
@@ -985,7 +994,7 @@ async fn load_joined_room(
 			prev_batch,
 			events: room_events,
 		},
-		state: State {
+		state: RoomState {
 			events: state_events
 				.iter()
 				.map(|pdu| pdu.to_sync_state_event())
@@ -999,16 +1008,16 @@ async fn load_joined_room(
 }
 
 fn load_timeline(
-	sender_user: &UserId, room_id: &RoomId, roomsincecount: PduCount, limit: u64,
+	services: &Services, sender_user: &UserId, room_id: &RoomId, roomsincecount: PduCount, limit: u64,
 ) -> Result<(Vec<(PduCount, PduEvent)>, bool), Error> {
 	let timeline_pdus;
-	let limited = if services()
+	let limited = if services
 		.rooms
 		.timeline
 		.last_timeline_count(sender_user, room_id)?
 		> roomsincecount
 	{
-		let mut non_timeline_pdus = services()
+		let mut non_timeline_pdus = services
 			.rooms
 			.timeline
 			.pdus_until(sender_user, room_id, PduCount::max())?
@@ -1040,8 +1049,10 @@ fn load_timeline(
 	Ok((timeline_pdus, limited))
 }
 
-fn share_encrypted_room(sender_user: &UserId, user_id: &UserId, ignore_room: &RoomId) -> Result<bool> {
-	Ok(services()
+fn share_encrypted_room(
+	services: &Services, sender_user: &UserId, user_id: &UserId, ignore_room: &RoomId,
+) -> Result<bool> {
+	Ok(services
 		.rooms
 		.user
 		.get_shared_rooms(vec![sender_user.to_owned(), user_id.to_owned()])?
@@ -1049,7 +1060,7 @@ fn share_encrypted_room(sender_user: &UserId, user_id: &UserId, ignore_room: &Ro
 		.filter(|room_id| room_id != ignore_room)
 		.filter_map(|other_room_id| {
 			Some(
-				services()
+				services
 					.rooms
 					.state_accessor
 					.room_state_get(&other_room_id, &StateEventType::RoomEncryption, "")
@@ -1064,15 +1075,15 @@ fn share_encrypted_room(sender_user: &UserId, user_id: &UserId, ignore_room: &Ro
 ///
 /// Sliding Sync endpoint (future endpoint: `/_matrix/client/v4/sync`)
 pub(crate) async fn sync_events_v4_route(
-	body: Ruma<sync_events::v4::Request>,
+	State(services): State<crate::State>, body: Ruma<sync_events::v4::Request>,
 ) -> Result<sync_events::v4::Response, RumaResponse<UiaaResponse>> {
 	let sender_user = body.sender_user.expect("user is authenticated");
 	let sender_device = body.sender_device.expect("user is authenticated");
 	let mut body = body.body;
 	// Setup watchers, so if there's no response, we can wait for them
-	let watcher = services().globals.watch(&sender_user, &sender_device);
+	let watcher = services.globals.watch(&sender_user, &sender_device);
 
-	let next_batch = services().globals.next_count()?;
+	let next_batch = services.globals.next_count()?;
 
 	let globalsince = body
 		.pos
@@ -1082,21 +1093,19 @@ pub(crate) async fn sync_events_v4_route(
 
 	if globalsince == 0 {
 		if let Some(conn_id) = &body.conn_id {
-			services().users.forget_sync_request_connection(
-				sender_user.clone(),
-				sender_device.clone(),
-				conn_id.clone(),
-			);
+			services
+				.users
+				.forget_sync_request_connection(sender_user.clone(), sender_device.clone(), conn_id.clone());
 		}
 	}
 
 	// Get sticky parameters from cache
 	let known_rooms =
-		services()
+		services
 			.users
 			.update_sync_request_with_cache(sender_user.clone(), sender_device.clone(), &mut body);
 
-	let all_joined_rooms = services()
+	let all_joined_rooms = services
 		.rooms
 		.state_cache
 		.rooms_joined(&sender_user)
@@ -1104,7 +1113,7 @@ pub(crate) async fn sync_events_v4_route(
 		.collect::<Vec<_>>();
 
 	if body.extensions.to_device.enabled.unwrap_or(false) {
-		services()
+		services
 			.users
 			.remove_to_device_events(&sender_user, &sender_device, globalsince)?;
 	}
@@ -1116,26 +1125,26 @@ pub(crate) async fn sync_events_v4_route(
 	if body.extensions.e2ee.enabled.unwrap_or(false) {
 		// Look for device list updates of this account
 		device_list_changes.extend(
-			services()
+			services
 				.users
 				.keys_changed(sender_user.as_ref(), globalsince, None)
 				.filter_map(Result::ok),
 		);
 
 		for room_id in &all_joined_rooms {
-			let Some(current_shortstatehash) = services().rooms.state.get_room_shortstatehash(room_id)? else {
+			let Some(current_shortstatehash) = services.rooms.state.get_room_shortstatehash(room_id)? else {
 				error!("Room {} has no state", room_id);
 				continue;
 			};
 
-			let since_shortstatehash = services()
+			let since_shortstatehash = services
 				.rooms
 				.user
 				.get_token_shortstatehash(room_id, globalsince)?;
 
 			let since_sender_member: Option<RoomMemberEventContent> = since_shortstatehash
 				.and_then(|shortstatehash| {
-					services()
+					services
 						.rooms
 						.state_accessor
 						.state_get(shortstatehash, &StateEventType::RoomMember, sender_user.as_str())
@@ -1148,7 +1157,7 @@ pub(crate) async fn sync_events_v4_route(
 						.ok()
 				});
 
-			let encrypted_room = services()
+			let encrypted_room = services
 				.rooms
 				.state_accessor
 				.state_get(current_shortstatehash, &StateEventType::RoomEncryption, "")?
@@ -1160,7 +1169,7 @@ pub(crate) async fn sync_events_v4_route(
 					continue;
 				}
 
-				let since_encryption = services().rooms.state_accessor.state_get(
+				let since_encryption = services.rooms.state_accessor.state_get(
 					since_shortstatehash,
 					&StateEventType::RoomEncryption,
 					"",
@@ -1171,12 +1180,12 @@ pub(crate) async fn sync_events_v4_route(
 
 				let new_encrypted_room = encrypted_room && since_encryption.is_none();
 				if encrypted_room {
-					let current_state_ids = services()
+					let current_state_ids = services
 						.rooms
 						.state_accessor
 						.state_full_ids(current_shortstatehash)
 						.await?;
-					let since_state_ids = services()
+					let since_state_ids = services
 						.rooms
 						.state_accessor
 						.state_full_ids(since_shortstatehash)
@@ -1184,7 +1193,7 @@ pub(crate) async fn sync_events_v4_route(
 
 					for (key, id) in current_state_ids {
 						if since_state_ids.get(&key) != Some(&id) {
-							let Some(pdu) = services().rooms.timeline.get_pdu(&id)? else {
+							let Some(pdu) = services.rooms.timeline.get_pdu(&id)? else {
 								error!("Pdu in state not found: {}", id);
 								continue;
 							};
@@ -1205,7 +1214,7 @@ pub(crate) async fn sync_events_v4_route(
 									match new_membership {
 										MembershipState::Join => {
 											// A new user joined an encrypted room
-											if !share_encrypted_room(&sender_user, &user_id, room_id)? {
+											if !share_encrypted_room(&services, &sender_user, &user_id, room_id)? {
 												device_list_changes.insert(user_id);
 											}
 										},
@@ -1222,7 +1231,7 @@ pub(crate) async fn sync_events_v4_route(
 					if joined_since_last_sync || new_encrypted_room {
 						// If the user is in a new encrypted room, give them all joined users
 						device_list_changes.extend(
-							services()
+							services
 								.rooms
 								.state_cache
 								.room_members(room_id)
@@ -1234,7 +1243,7 @@ pub(crate) async fn sync_events_v4_route(
 								.filter(|user_id| {
 									// Only send keys if the sender doesn't share an encrypted room with the target
 									// already
-									!share_encrypted_room(&sender_user, user_id, room_id).unwrap_or(false)
+									!share_encrypted_room(&services, &sender_user, user_id, room_id).unwrap_or(false)
 								}),
 						);
 					}
@@ -1242,21 +1251,21 @@ pub(crate) async fn sync_events_v4_route(
 			}
 			// Look for device list updates in this room
 			device_list_changes.extend(
-				services()
+				services
 					.users
 					.keys_changed(room_id.as_ref(), globalsince, None)
 					.filter_map(Result::ok),
 			);
 		}
 		for user_id in left_encrypted_users {
-			let dont_share_encrypted_room = services()
+			let dont_share_encrypted_room = services
 				.rooms
 				.user
 				.get_shared_rooms(vec![sender_user.clone(), user_id.clone()])?
 				.filter_map(Result::ok)
 				.filter_map(|other_room_id| {
 					Some(
-						services()
+						services
 							.rooms
 							.state_accessor
 							.room_state_get(&other_room_id, &StateEventType::RoomEncryption, "")
@@ -1336,7 +1345,7 @@ pub(crate) async fn sync_events_v4_route(
 		);
 
 		if let Some(conn_id) = &body.conn_id {
-			services().users.update_sync_known_rooms(
+			services.users.update_sync_known_rooms(
 				sender_user.clone(),
 				sender_device.clone(),
 				conn_id.clone(),
@@ -1349,7 +1358,7 @@ pub(crate) async fn sync_events_v4_route(
 
 	let mut known_subscription_rooms = BTreeSet::new();
 	for (room_id, room) in &body.room_subscriptions {
-		if !services().rooms.metadata.exists(room_id)? {
+		if !services.rooms.metadata.exists(room_id)? {
 			continue;
 		}
 		let todo_room = todo_rooms
@@ -1375,7 +1384,7 @@ pub(crate) async fn sync_events_v4_route(
 	}
 
 	if let Some(conn_id) = &body.conn_id {
-		services().users.update_sync_known_rooms(
+		services.users.update_sync_known_rooms(
 			sender_user.clone(),
 			sender_device.clone(),
 			conn_id.clone(),
@@ -1386,7 +1395,7 @@ pub(crate) async fn sync_events_v4_route(
 	}
 
 	if let Some(conn_id) = &body.conn_id {
-		services().users.update_sync_subscriptions(
+		services.users.update_sync_subscriptions(
 			sender_user.clone(),
 			sender_device.clone(),
 			conn_id.clone(),
@@ -1398,7 +1407,8 @@ pub(crate) async fn sync_events_v4_route(
 	for (room_id, (required_state_request, timeline_limit, roomsince)) in &todo_rooms {
 		let roomsincecount = PduCount::Normal(*roomsince);
 
-		let (timeline_pdus, limited) = load_timeline(&sender_user, room_id, roomsincecount, *timeline_limit)?;
+		let (timeline_pdus, limited) =
+			load_timeline(&services, &sender_user, room_id, roomsincecount, *timeline_limit)?;
 
 		if roomsince != &0 && timeline_pdus.is_empty() {
 			continue;
@@ -1431,7 +1441,7 @@ pub(crate) async fn sync_events_v4_route(
 		let required_state = required_state_request
 			.iter()
 			.map(|state| {
-				services()
+				services
 					.rooms
 					.state_accessor
 					.room_state_get(room_id, &state.0, &state.1)
@@ -1442,7 +1452,7 @@ pub(crate) async fn sync_events_v4_route(
 			.collect();
 
 		// Heroes
-		let heroes = services()
+		let heroes = services
 			.rooms
 			.state_cache
 			.room_members(room_id)
@@ -1450,7 +1460,7 @@ pub(crate) async fn sync_events_v4_route(
 			.filter(|member| member != &sender_user)
 			.map(|member| {
 				Ok::<_, Error>(
-					services()
+					services
 						.rooms
 						.state_accessor
 						.get_member(room_id, &member)?
@@ -1491,11 +1501,11 @@ pub(crate) async fn sync_events_v4_route(
 		rooms.insert(
 			room_id.clone(),
 			sync_events::v4::SlidingSyncRoom {
-				name: services().rooms.state_accessor.get_name(room_id)?.or(name),
+				name: services.rooms.state_accessor.get_name(room_id)?.or(name),
 				avatar: if let Some(heroes_avatar) = heroes_avatar {
 					ruma::JsOption::Some(heroes_avatar)
 				} else {
-					match services().rooms.state_accessor.get_avatar(room_id)? {
+					match services.rooms.state_accessor.get_avatar(room_id)? {
 						ruma::JsOption::Some(avatar) => ruma::JsOption::from_option(avatar.url),
 						ruma::JsOption::Null => ruma::JsOption::Null,
 						ruma::JsOption::Undefined => ruma::JsOption::Undefined,
@@ -1506,7 +1516,7 @@ pub(crate) async fn sync_events_v4_route(
 				invite_state: None,
 				unread_notifications: UnreadNotificationsCount {
 					highlight_count: Some(
-						services()
+						services
 							.rooms
 							.user
 							.highlight_count(&sender_user, room_id)?
@@ -1514,7 +1524,7 @@ pub(crate) async fn sync_events_v4_route(
 							.expect("notification count can't go that high"),
 					),
 					notification_count: Some(
-						services()
+						services
 							.rooms
 							.user
 							.notification_count(&sender_user, room_id)?
@@ -1527,7 +1537,7 @@ pub(crate) async fn sync_events_v4_route(
 				prev_batch,
 				limited,
 				joined_count: Some(
-					services()
+					services
 						.rooms
 						.state_cache
 						.room_joined_count(room_id)?
@@ -1536,7 +1546,7 @@ pub(crate) async fn sync_events_v4_route(
 						.unwrap_or_else(|_| uint!(0)),
 				),
 				invited_count: Some(
-					services()
+					services
 						.rooms
 						.state_cache
 						.room_invited_count(room_id)?
@@ -1571,7 +1581,7 @@ pub(crate) async fn sync_events_v4_route(
 		extensions: sync_events::v4::Extensions {
 			to_device: if body.extensions.to_device.enabled.unwrap_or(false) {
 				Some(sync_events::v4::ToDevice {
-					events: services()
+					events: services
 						.users
 						.get_to_device_events(&sender_user, &sender_device)?,
 					next_batch: next_batch.to_string(),
@@ -1584,7 +1594,7 @@ pub(crate) async fn sync_events_v4_route(
 					changed: device_list_changes.into_iter().collect(),
 					left: device_list_left.into_iter().collect(),
 				},
-				device_one_time_keys_count: services()
+				device_one_time_keys_count: services
 					.users
 					.count_one_time_keys(&sender_user, &sender_device)?,
 				// Fallback keys are not yet supported
@@ -1592,7 +1602,7 @@ pub(crate) async fn sync_events_v4_route(
 			},
 			account_data: sync_events::v4::AccountData {
 				global: if body.extensions.account_data.enabled.unwrap_or(false) {
-					services()
+					services
 						.account_data
 						.changes_since(None, &sender_user, globalsince)?
 						.into_iter()

src/api/client/tag.rs

@@ -1,5 +1,6 @@
 use std::collections::BTreeMap;
 
+use axum::extract::State;
 use ruma::{
 	api::client::tag::{create_tag, delete_tag, get_tags},
 	events::{
@@ -8,17 +9,19 @@ use ruma::{
 	},
 };
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `PUT /_matrix/client/r0/user/{userId}/rooms/{roomId}/tags/{tag}`
 ///
 /// Adds a tag to the room.
 ///
 /// - Inserts the tag into the tag event of the room account data.
-pub(crate) async fn update_tag_route(body: Ruma<create_tag::v3::Request>) -> Result<create_tag::v3::Response> {
+pub(crate) async fn update_tag_route(
+	State(services): State<crate::State>, body: Ruma<create_tag::v3::Request>,
+) -> Result<create_tag::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(Some(&body.room_id), sender_user, RoomAccountDataEventType::Tag)?;
 
@@ -38,7 +41,7 @@ pub(crate) async fn update_tag_route(body: Ruma<create_tag::v3::Request>) -> Res
 		.tags
 		.insert(body.tag.clone().into(), body.tag_info.clone());
 
-	services().account_data.update(
+	services.account_data.update(
 		Some(&body.room_id),
 		sender_user,
 		RoomAccountDataEventType::Tag,
@@ -53,10 +56,12 @@ pub(crate) async fn update_tag_route(body: Ruma<create_tag::v3::Request>) -> Res
 /// Deletes a tag from the room.
 ///
 /// - Removes the tag from the tag event of the room account data.
-pub(crate) async fn delete_tag_route(body: Ruma<delete_tag::v3::Request>) -> Result<delete_tag::v3::Response> {
+pub(crate) async fn delete_tag_route(
+	State(services): State<crate::State>, body: Ruma<delete_tag::v3::Request>,
+) -> Result<delete_tag::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(Some(&body.room_id), sender_user, RoomAccountDataEventType::Tag)?;
 
@@ -73,7 +78,7 @@ pub(crate) async fn delete_tag_route(body: Ruma<delete_tag::v3::Request>) -> Res
 
 	tags_event.content.tags.remove(&body.tag.clone().into());
 
-	services().account_data.update(
+	services.account_data.update(
 		Some(&body.room_id),
 		sender_user,
 		RoomAccountDataEventType::Tag,
@@ -88,10 +93,12 @@ pub(crate) async fn delete_tag_route(body: Ruma<delete_tag::v3::Request>) -> Res
 /// Returns tags on the room.
 ///
 /// - Gets the tag event of the room account data.
-pub(crate) async fn get_tags_route(body: Ruma<get_tags::v3::Request>) -> Result<get_tags::v3::Response> {
+pub(crate) async fn get_tags_route(
+	State(services): State<crate::State>, body: Ruma<get_tags::v3::Request>,
+) -> Result<get_tags::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	let event = services()
+	let event = services
 		.account_data
 		.get(Some(&body.room_id), sender_user, RoomAccountDataEventType::Tag)?;
 

src/api/client/threads.rs

@@ -1,12 +1,15 @@
+use axum::extract::State;
 use ruma::{
 	api::client::{error::ErrorKind, threads::get_threads},
 	uint,
 };
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `GET /_matrix/client/r0/rooms/{roomId}/threads`
-pub(crate) async fn get_threads_route(body: Ruma<get_threads::v1::Request>) -> Result<get_threads::v1::Response> {
+pub(crate) async fn get_threads_route(
+	State(services): State<crate::State>, body: Ruma<get_threads::v1::Request>,
+) -> Result<get_threads::v1::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
 	// Use limit or else 10, with maximum 100
@@ -24,14 +27,14 @@ pub(crate) async fn get_threads_route(body: Ruma<get_threads::v1::Request>) -> R
 		u64::MAX
 	};
 
-	let threads = services()
+	let threads = services
 		.rooms
 		.threads
 		.threads_until(sender_user, &body.room_id, from, &body.include)?
 		.take(limit)
 		.filter_map(Result::ok)
 		.filter(|(_, pdu)| {
-			services()
+			services
 				.rooms
 				.state_accessor
 				.user_can_see_event(sender_user, &body.room_id, &pdu.event_id)

src/api/client/to_device.rs

@@ -1,5 +1,7 @@
 use std::collections::BTreeMap;
 
+use axum::extract::State;
+use conduit::{Error, Result};
 use ruma::{
 	api::{
 		client::{error::ErrorKind, to_device::send_event_to_device},
@@ -8,19 +10,19 @@ use ruma::{
 	to_device::DeviceIdOrAllDevices,
 };
 
-use crate::{services, user_is_local, Error, Result, Ruma};
+use crate::Ruma;
 
 /// # `PUT /_matrix/client/r0/sendToDevice/{eventType}/{txnId}`
 ///
 /// Send a to-device event to a set of client devices.
 pub(crate) async fn send_event_to_device_route(
-	body: Ruma<send_event_to_device::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<send_event_to_device::v3::Request>,
 ) -> Result<send_event_to_device::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let sender_device = body.sender_device.as_deref();
 
 	// Check if this is a new transaction id
-	if services()
+	if services
 		.transaction_ids
 		.existing_txnid(sender_user, sender_device, &body.txn_id)?
 		.is_some()
@@ -30,14 +32,14 @@ pub(crate) async fn send_event_to_device_route(
 
 	for (target_user_id, map) in &body.messages {
 		for (target_device_id_maybe, event) in map {
-			if !user_is_local(target_user_id) {
+			if !services.globals.user_is_local(target_user_id) {
 				let mut map = BTreeMap::new();
 				map.insert(target_device_id_maybe.clone(), event.clone());
 				let mut messages = BTreeMap::new();
 				messages.insert(target_user_id.clone(), map);
-				let count = services().globals.next_count()?;
+				let count = services.globals.next_count()?;
 
-				services().sending.send_edu_server(
+				services.sending.send_edu_server(
 					target_user_id.server_name(),
 					serde_json::to_vec(&federation::transactions::edu::Edu::DirectToDevice(DirectDeviceContent {
 						sender: sender_user.clone(),
@@ -53,7 +55,7 @@ pub(crate) async fn send_event_to_device_route(
 
 			match target_device_id_maybe {
 				DeviceIdOrAllDevices::DeviceId(target_device_id) => {
-					services().users.add_to_device_event(
+					services.users.add_to_device_event(
 						sender_user,
 						target_user_id,
 						target_device_id,
@@ -65,8 +67,8 @@ pub(crate) async fn send_event_to_device_route(
 				},
 
 				DeviceIdOrAllDevices::AllDevices => {
-					for target_device_id in services().users.all_device_ids(target_user_id) {
-						services().users.add_to_device_event(
+					for target_device_id in services.users.all_device_ids(target_user_id) {
+						services.users.add_to_device_event(
 							sender_user,
 							target_user_id,
 							&target_device_id?,
@@ -82,7 +84,7 @@ pub(crate) async fn send_event_to_device_route(
 	}
 
 	// Save transaction id with empty data
-	services()
+	services
 		.transaction_ids
 		.add_txnid(sender_user, sender_device, &body.txn_id, &[])?;
 

src/api/client/typing.rs

@@ -1,18 +1,19 @@
+use axum::extract::State;
 use ruma::api::client::{error::ErrorKind, typing::create_typing_event};
 
-use crate::{services, utils, Error, Result, Ruma};
+use crate::{utils, Error, Result, Ruma};
 
 /// # `PUT /_matrix/client/r0/rooms/{roomId}/typing/{userId}`
 ///
 /// Sets the typing state of the sender user.
 pub(crate) async fn create_typing_event_route(
-	body: Ruma<create_typing_event::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<create_typing_event::v3::Request>,
 ) -> Result<create_typing_event::v3::Response> {
 	use create_typing_event::v3::Typing;
 
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-	if !services()
+	if !services
 		.rooms
 		.state_cache
 		.is_joined(sender_user, &body.room_id)?
@@ -23,20 +24,20 @@ pub(crate) async fn create_typing_event_route(
 	if let Typing::Yes(duration) = body.state {
 		let duration = utils::clamp(
 			duration.as_millis().try_into().unwrap_or(u64::MAX),
-			services()
+			services
 				.globals
 				.config
 				.typing_client_timeout_min_s
 				.checked_mul(1000)
 				.unwrap(),
-			services()
+			services
 				.globals
 				.config
 				.typing_client_timeout_max_s
 				.checked_mul(1000)
 				.unwrap(),
 		);
-		services()
+		services
 			.rooms
 			.typing
 			.typing_add(
@@ -48,7 +49,7 @@ pub(crate) async fn create_typing_event_route(
 			)
 			.await?;
 	} else {
-		services()
+		services
 			.rooms
 			.typing
 			.typing_remove(sender_user, &body.room_id)

src/api/client/unstable.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use axum_client_ip::InsecureClientIp;
 use conduit::warn;
 use ruma::{
@@ -6,7 +7,7 @@ use ruma::{
 	OwnedRoomId,
 };
 
-use crate::{services, Error, Result, Ruma, RumaResponse};
+use crate::{Error, Result, Ruma, RumaResponse};
 
 /// # `GET /_matrix/client/unstable/uk.half-shot.msc2666/user/mutual_rooms`
 ///
@@ -17,7 +18,8 @@ use crate::{services, Error, Result, Ruma, RumaResponse};
 /// An implementation of [MSC2666](https://github.com/matrix-org/matrix-spec-proposals/pull/2666)
 #[tracing::instrument(skip_all, fields(%client), name = "mutual_rooms")]
 pub(crate) async fn get_mutual_rooms_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<mutual_rooms::unstable::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<mutual_rooms::unstable::Request>,
 ) -> Result<mutual_rooms::unstable::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
@@ -28,14 +30,14 @@ pub(crate) async fn get_mutual_rooms_route(
 		));
 	}
 
-	if !services().users.exists(&body.user_id)? {
+	if !services.users.exists(&body.user_id)? {
 		return Ok(mutual_rooms::unstable::Response {
 			joined: vec![],
 			next_batch_token: None,
 		});
 	}
 
-	let mutual_rooms: Vec<OwnedRoomId> = services()
+	let mutual_rooms: Vec<OwnedRoomId> = services
 		.rooms
 		.user
 		.get_shared_rooms(vec![sender_user.clone(), body.user_id.clone()])?
@@ -58,9 +60,10 @@ pub(crate) async fn get_mutual_rooms_route(
 ///
 /// An implementation of [MSC3266](https://github.com/matrix-org/matrix-spec-proposals/pull/3266)
 pub(crate) async fn get_room_summary_legacy(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_summary::msc3266::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_summary::msc3266::Request>,
 ) -> Result<RumaResponse<get_summary::msc3266::Response>> {
-	get_room_summary(InsecureClientIp(client), body)
+	get_room_summary(State(services), InsecureClientIp(client), body)
 		.await
 		.map(RumaResponse)
 }
@@ -74,22 +77,19 @@ pub(crate) async fn get_room_summary_legacy(
 /// An implementation of [MSC3266](https://github.com/matrix-org/matrix-spec-proposals/pull/3266)
 #[tracing::instrument(skip_all, fields(%client), name = "room_summary")]
 pub(crate) async fn get_room_summary(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_summary::msc3266::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_summary::msc3266::Request>,
 ) -> Result<get_summary::msc3266::Response> {
 	let sender_user = body.sender_user.as_ref();
 
-	let room_id = services()
-		.rooms
-		.alias
-		.resolve(&body.room_id_or_alias)
-		.await?;
+	let room_id = services.rooms.alias.resolve(&body.room_id_or_alias).await?;
 
-	if !services().rooms.metadata.exists(&room_id)? {
+	if !services.rooms.metadata.exists(&room_id)? {
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server"));
 	}
 
 	if sender_user.is_none()
-		&& !services()
+		&& !services
 			.rooms
 			.state_accessor
 			.is_world_readable(&room_id)
@@ -103,25 +103,25 @@ pub(crate) async fn get_room_summary(
 
 	Ok(get_summary::msc3266::Response {
 		room_id: room_id.clone(),
-		canonical_alias: services()
+		canonical_alias: services
 			.rooms
 			.state_accessor
 			.get_canonical_alias(&room_id)
 			.unwrap_or(None),
-		avatar_url: services()
+		avatar_url: services
 			.rooms
 			.state_accessor
 			.get_avatar(&room_id)?
 			.into_option()
 			.unwrap_or_default()
 			.url,
-		guest_can_join: services().rooms.state_accessor.guest_can_join(&room_id)?,
-		name: services()
+		guest_can_join: services.rooms.state_accessor.guest_can_join(&room_id)?,
+		name: services
 			.rooms
 			.state_accessor
 			.get_name(&room_id)
 			.unwrap_or(None),
-		num_joined_members: services()
+		num_joined_members: services
 			.rooms
 			.state_cache
 			.room_joined_count(&room_id)
@@ -132,21 +132,21 @@ pub(crate) async fn get_room_summary(
 			})
 			.try_into()
 			.expect("user count should not be that big"),
-		topic: services()
+		topic: services
 			.rooms
 			.state_accessor
 			.get_room_topic(&room_id)
 			.unwrap_or(None),
-		world_readable: services()
+		world_readable: services
 			.rooms
 			.state_accessor
 			.is_world_readable(&room_id)
 			.unwrap_or(false),
-		join_rule: services().rooms.state_accessor.get_join_rule(&room_id)?.0,
-		room_type: services().rooms.state_accessor.get_room_type(&room_id)?,
-		room_version: Some(services().rooms.state.get_room_version(&room_id)?),
+		join_rule: services.rooms.state_accessor.get_join_rule(&room_id)?.0,
+		room_type: services.rooms.state_accessor.get_room_type(&room_id)?,
+		room_version: Some(services.rooms.state.get_room_version(&room_id)?),
 		membership: if let Some(sender_user) = sender_user {
-			services()
+			services
 				.rooms
 				.state_accessor
 				.get_member(&room_id, sender_user)?
@@ -154,7 +154,7 @@ pub(crate) async fn get_room_summary(
 		} else {
 			None
 		},
-		encryption: services()
+		encryption: services
 			.rooms
 			.state_accessor
 			.get_room_encryption(&room_id)

src/api/client/unversioned.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use axum::{response::IntoResponse, Json};
+use axum::{extract::State, response::IntoResponse, Json};
 use ruma::api::client::{
 	discovery::{
 		discover_homeserver::{self, HomeserverInfo, SlidingSyncProxyInfo},
@@ -10,7 +10,7 @@ use ruma::api::client::{
 	error::ErrorKind,
 };
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `GET /_matrix/client/versions`
 ///
@@ -62,9 +62,9 @@ pub(crate) async fn get_supported_versions_route(
 ///
 /// Returns the .well-known URL if it is configured, otherwise returns 404.
 pub(crate) async fn well_known_client(
-	_body: Ruma<discover_homeserver::Request>,
+	State(services): State<crate::State>, _body: Ruma<discover_homeserver::Request>,
 ) -> Result<discover_homeserver::Response> {
-	let client_url = match services().globals.well_known_client() {
+	let client_url = match services.globals.well_known_client() {
 		Some(url) => url.to_string(),
 		None => return Err(Error::BadRequest(ErrorKind::NotFound, "Not found.")),
 	};
@@ -84,22 +84,24 @@ pub(crate) async fn well_known_client(
 /// # `GET /.well-known/matrix/support`
 ///
 /// Server support contact and support page of a homeserver's domain.
-pub(crate) async fn well_known_support(_body: Ruma<discover_support::Request>) -> Result<discover_support::Response> {
-	let support_page = services()
+pub(crate) async fn well_known_support(
+	State(services): State<crate::State>, _body: Ruma<discover_support::Request>,
+) -> Result<discover_support::Response> {
+	let support_page = services
 		.globals
 		.well_known_support_page()
 		.as_ref()
 		.map(ToString::to_string);
 
-	let role = services().globals.well_known_support_role().clone();
+	let role = services.globals.well_known_support_role().clone();
 
 	// support page or role must be either defined for this to be valid
 	if support_page.is_none() && role.is_none() {
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Not found."));
 	}
 
-	let email_address = services().globals.well_known_support_email().clone();
-	let matrix_id = services().globals.well_known_support_mxid().clone();
+	let email_address = services.globals.well_known_support_email().clone();
+	let matrix_id = services.globals.well_known_support_mxid().clone();
 
 	// if a role is specified, an email address or matrix id is required
 	if role.is_some() && (email_address.is_none() && matrix_id.is_none()) {
@@ -134,10 +136,10 @@ pub(crate) async fn well_known_support(_body: Ruma<discover_support::Request>) -
 ///
 /// Endpoint provided by sliding sync proxy used by some clients such as Element
 /// Web as a non-standard health check.
-pub(crate) async fn syncv3_client_server_json() -> Result<impl IntoResponse> {
-	let server_url = match services().globals.well_known_client() {
+pub(crate) async fn syncv3_client_server_json(State(services): State<crate::State>) -> Result<impl IntoResponse> {
+	let server_url = match services.globals.well_known_client() {
 		Some(url) => url.to_string(),
-		None => match services().globals.well_known_server() {
+		None => match services.globals.well_known_server() {
 			Some(url) => url.to_string(),
 			None => return Err(Error::BadRequest(ErrorKind::NotFound, "Not found.")),
 		},
@@ -165,8 +167,8 @@ pub(crate) async fn conduwuit_server_version() -> Result<impl IntoResponse> {
 /// conduwuit-specific API to return the amount of users registered on this
 /// homeserver. Endpoint is disabled if federation is disabled for privacy. This
 /// only includes active users (not deactivated, no guests, etc)
-pub(crate) async fn conduwuit_local_user_count() -> Result<impl IntoResponse> {
-	let user_count = services().users.list_local_users()?.len();
+pub(crate) async fn conduwuit_local_user_count(State(services): State<crate::State>) -> Result<impl IntoResponse> {
+	let user_count = services.users.list_local_users()?.len();
 
 	Ok(Json(serde_json::json!({
 		"count": user_count

src/api/client/user_directory.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use ruma::{
 	api::client::user_directory::search_users,
 	events::{
@@ -6,7 +7,7 @@ use ruma::{
 	},
 };
 
-use crate::{services, Result, Ruma};
+use crate::{Result, Ruma};
 
 /// # `POST /_matrix/client/r0/user_directory/search`
 ///
@@ -14,18 +15,20 @@ use crate::{services, Result, Ruma};
 ///
 /// - Hides any local users that aren't in any public rooms (i.e. those that
 ///   have the join rule set to public) and don't share a room with the sender
-pub(crate) async fn search_users_route(body: Ruma<search_users::v3::Request>) -> Result<search_users::v3::Response> {
+pub(crate) async fn search_users_route(
+	State(services): State<crate::State>, body: Ruma<search_users::v3::Request>,
+) -> Result<search_users::v3::Response> {
 	let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 	let limit = usize::try_from(body.limit).unwrap_or(10); // default limit is 10
 
-	let mut users = services().users.iter().filter_map(|user_id| {
+	let mut users = services.users.iter().filter_map(|user_id| {
 		// Filter out buggy users (they should not exist, but you never know...)
 		let user_id = user_id.ok()?;
 
 		let user = search_users::v3::User {
 			user_id: user_id.clone(),
-			display_name: services().users.displayname(&user_id).ok()?,
-			avatar_url: services().users.avatar_url(&user_id).ok()?,
+			display_name: services.users.displayname(&user_id).ok()?,
+			avatar_url: services.users.avatar_url(&user_id).ok()?,
 		};
 
 		let user_id_matches = user
@@ -50,13 +53,13 @@ pub(crate) async fn search_users_route(body: Ruma<search_users::v3::Request>) ->
 		// It's a matching user, but is the sender allowed to see them?
 		let mut user_visible = false;
 
-		let user_is_in_public_rooms = services()
+		let user_is_in_public_rooms = services
 			.rooms
 			.state_cache
 			.rooms_joined(&user_id)
 			.filter_map(Result::ok)
 			.any(|room| {
-				services()
+				services
 					.rooms
 					.state_accessor
 					.room_state_get(&room, &StateEventType::RoomJoinRules, "")
@@ -71,7 +74,7 @@ pub(crate) async fn search_users_route(body: Ruma<search_users::v3::Request>) ->
 		if user_is_in_public_rooms {
 			user_visible = true;
 		} else {
-			let user_is_in_shared_rooms = services()
+			let user_is_in_shared_rooms = services
 				.rooms
 				.user
 				.get_shared_rooms(vec![sender_user.clone(), user_id])

src/api/client/voip.rs

@@ -1,12 +1,13 @@
 use std::time::{Duration, SystemTime};
 
+use axum::extract::State;
 use base64::{engine::general_purpose, Engine as _};
 use conduit::utils;
 use hmac::{Hmac, Mac};
 use ruma::{api::client::voip::get_turn_server_info, SecondsSinceUnixEpoch, UserId};
 use sha1::Sha1;
 
-use crate::{services, Result, Ruma};
+use crate::{Result, Ruma};
 
 const RANDOM_USER_ID_LENGTH: usize = 10;
 
@@ -16,14 +17,14 @@ type HmacSha1 = Hmac<Sha1>;
 ///
 /// TODO: Returns information about the recommended turn server.
 pub(crate) async fn turn_server_route(
-	body: Ruma<get_turn_server_info::v3::Request>,
+	State(services): State<crate::State>, body: Ruma<get_turn_server_info::v3::Request>,
 ) -> Result<get_turn_server_info::v3::Response> {
-	let turn_secret = services().globals.turn_secret().clone();
+	let turn_secret = services.globals.turn_secret().clone();
 
 	let (username, password) = if !turn_secret.is_empty() {
 		let expiry = SecondsSinceUnixEpoch::from_system_time(
 			SystemTime::now()
-				.checked_add(Duration::from_secs(services().globals.turn_ttl()))
+				.checked_add(Duration::from_secs(services.globals.turn_ttl()))
 				.expect("TURN TTL should not get this high"),
 		)
 		.expect("time is valid");
@@ -31,7 +32,7 @@ pub(crate) async fn turn_server_route(
 		let user = body.sender_user.unwrap_or_else(|| {
 			UserId::parse_with_server_name(
 				utils::random_string(RANDOM_USER_ID_LENGTH).to_lowercase(),
-				&services().globals.config.server_name,
+				&services.globals.config.server_name,
 			)
 			.unwrap()
 		});
@@ -46,15 +47,15 @@ pub(crate) async fn turn_server_route(
 		(username, password)
 	} else {
 		(
-			services().globals.turn_username().clone(),
-			services().globals.turn_password().clone(),
+			services.globals.turn_username().clone(),
+			services.globals.turn_password().clone(),
 		)
 	};
 
 	Ok(get_turn_server_info::v3::Response {
 		username,
 		password,
-		uris: services().globals.turn_uris().to_vec(),
-		ttl: Duration::from_secs(services().globals.turn_ttl()),
+		uris: services.globals.turn_uris().to_vec(),
+		ttl: Duration::from_secs(services.globals.turn_ttl()),
 	})
 }

src/api/mod.rs

@@ -1,3 +1,5 @@
+#![recursion_limit = "192"]
+
 pub mod client;
 pub mod router;
 pub mod server;
@@ -5,8 +7,8 @@ pub mod server;
 extern crate conduit_core as conduit;
 extern crate conduit_service as service;
 
-pub(crate) use conduit::{debug_info, debug_warn, pdu::PduEvent, utils, Error, Result};
-pub(crate) use service::{services, user_is_local};
+pub(crate) use conduit::{debug_info, pdu::PduEvent, utils, Error, Result};
+pub(crate) use service::services;
 
 pub use crate::router::State;
 pub(crate) use crate::router::{Ruma, RumaResponse};

src/api/router.rs

@@ -4,6 +4,8 @@ mod handler;
 mod request;
 mod response;
 
+use std::sync::Arc;
+
 use axum::{
 	response::IntoResponse,
 	routing::{any, get, post},
@@ -16,7 +18,7 @@ use self::handler::RouterExt;
 pub(super) use self::{args::Args as Ruma, response::RumaResponse};
 use crate::{client, server};
 
-pub type State = &'static service::Services;
+pub type State = Arc<service::Services>;
 
 pub fn build(router: Router<State>, server: &Server) -> Router<State> {
 	let config = &server.config;

src/api/router/args.rs

@@ -2,11 +2,12 @@ use std::{mem, ops::Deref};
 
 use axum::{async_trait, body::Body, extract::FromRequest};
 use bytes::{BufMut, BytesMut};
-use conduit::{debug, err, trace, Error, Result};
+use conduit::{debug, err, trace, utils::string::EMPTY, Error, Result};
 use ruma::{api::IncomingRequest, CanonicalJsonValue, OwnedDeviceId, OwnedServerName, OwnedUserId, UserId};
+use service::Services;
 
 use super::{auth, auth::Auth, request, request::Request};
-use crate::{service::appservice::RegistrationInfo, services};
+use crate::{service::appservice::RegistrationInfo, State};
 
 /// Extractor for Ruma request structs
 pub(crate) struct Args<T> {
@@ -35,18 +36,18 @@ pub(crate) struct Args<T> {
 }
 
 #[async_trait]
-impl<T, S> FromRequest<S, Body> for Args<T>
+impl<T> FromRequest<State, Body> for Args<T>
 where
 	T: IncomingRequest,
 {
 	type Rejection = Error;
 
-	async fn from_request(request: hyper::Request<Body>, _: &S) -> Result<Self, Self::Rejection> {
-		let mut request = request::from(request).await?;
+	async fn from_request(request: hyper::Request<Body>, services: &State) -> Result<Self, Self::Rejection> {
+		let mut request = request::from(services, request).await?;
 		let mut json_body = serde_json::from_slice::<CanonicalJsonValue>(&request.body).ok();
-		let auth = auth::auth(&mut request, &json_body, &T::METADATA).await?;
+		let auth = auth::auth(services, &mut request, &json_body, &T::METADATA).await?;
 		Ok(Self {
-			body: make_body::<T>(&mut request, &mut json_body, &auth)?,
+			body: make_body::<T>(services, &mut request, &mut json_body, &auth)?,
 			origin: auth.origin,
 			sender_user: auth.sender_user,
 			sender_device: auth.sender_device,
@@ -62,13 +63,16 @@ impl<T> Deref for Args<T> {
 	fn deref(&self) -> &Self::Target { &self.body }
 }
 
-fn make_body<T>(request: &mut Request, json_body: &mut Option<CanonicalJsonValue>, auth: &Auth) -> Result<T>
+fn make_body<T>(
+	services: &Services, request: &mut Request, json_body: &mut Option<CanonicalJsonValue>, auth: &Auth,
+) -> Result<T>
 where
 	T: IncomingRequest,
 {
 	let body = if let Some(CanonicalJsonValue::Object(json_body)) = json_body {
 		let user_id = auth.sender_user.clone().unwrap_or_else(|| {
-			UserId::parse_with_server_name("", services().globals.server_name()).expect("we know this is valid")
+			let server_name = services.globals.server_name();
+			UserId::parse_with_server_name(EMPTY, server_name).expect("valid user_id")
 		});
 
 		let uiaa_request = json_body
@@ -77,9 +81,9 @@ where
 			.and_then(|auth| auth.get("session"))
 			.and_then(|session| session.as_str())
 			.and_then(|session| {
-				services().uiaa.get_uiaa_request(
+				services.uiaa.get_uiaa_request(
 					&user_id,
-					&auth.sender_device.clone().unwrap_or_else(|| "".into()),
+					&auth.sender_device.clone().unwrap_or_else(|| EMPTY.into()),
 					session,
 				)
 			});

src/api/router/auth.rs

@@ -6,17 +6,17 @@ use axum_extra::{
 	typed_header::TypedHeaderRejectionReason,
 	TypedHeader,
 };
-use conduit::Err;
+use conduit::{warn, Err, Error, Result};
 use http::uri::PathAndQuery;
 use ruma::{
 	api::{client::error::ErrorKind, AuthScheme, Metadata},
 	server_util::authorization::XMatrix,
 	CanonicalJsonValue, OwnedDeviceId, OwnedServerName, OwnedUserId, UserId,
 };
-use tracing::warn;
+use service::Services;
 
 use super::request::Request;
-use crate::{service::appservice::RegistrationInfo, services, Error, Result};
+use crate::service::appservice::RegistrationInfo;
 
 enum Token {
 	Appservice(Box<RegistrationInfo>),
@@ -33,7 +33,7 @@ pub(super) struct Auth {
 }
 
 pub(super) async fn auth(
-	request: &mut Request, json_body: &Option<CanonicalJsonValue>, metadata: &Metadata,
+	services: &Services, request: &mut Request, json_body: &Option<CanonicalJsonValue>, metadata: &Metadata,
 ) -> Result<Auth> {
 	let bearer: Option<TypedHeader<Authorization<Bearer>>> = request.parts.extract().await?;
 	let token = match &bearer {
@@ -42,9 +42,9 @@ pub(super) async fn auth(
 	};
 
 	let token = if let Some(token) = token {
-		if let Some(reg_info) = services().appservice.find_from_token(token).await {
+		if let Some(reg_info) = services.appservice.find_from_token(token).await {
 			Token::Appservice(Box::new(reg_info))
-		} else if let Some((user_id, device_id)) = services().users.find_from_token(token)? {
+		} else if let Some((user_id, device_id)) = services.users.find_from_token(token)? {
 			Token::User((user_id, OwnedDeviceId::from(device_id)))
 		} else {
 			Token::Invalid
@@ -57,7 +57,7 @@ pub(super) async fn auth(
 		match request.parts.uri.path() {
 			// TODO: can we check this better?
 			"/_matrix/client/v3/publicRooms" | "/_matrix/client/r0/publicRooms" => {
-				if !services()
+				if !services
 					.globals
 					.config
 					.allow_public_room_directory_without_auth
@@ -98,7 +98,7 @@ pub(super) async fn auth(
 				))
 			}
 		},
-		(AuthScheme::AccessToken, Token::Appservice(info)) => Ok(auth_appservice(request, info)?),
+		(AuthScheme::AccessToken, Token::Appservice(info)) => Ok(auth_appservice(services, request, info)?),
 		(AuthScheme::None | AuthScheme::AccessTokenOptional | AuthScheme::AppserviceToken, Token::Appservice(info)) => {
 			Ok(Auth {
 				origin: None,
@@ -110,7 +110,7 @@ pub(super) async fn auth(
 		(AuthScheme::AccessToken, Token::None) => match request.parts.uri.path() {
 			// TODO: can we check this better?
 			"/_matrix/client/v3/voip/turnServer" | "/_matrix/client/r0/voip/turnServer" => {
-				if services().globals.config.turn_allow_guests {
+				if services.globals.config.turn_allow_guests {
 					Ok(Auth {
 						origin: None,
 						sender_user: None,
@@ -132,7 +132,7 @@ pub(super) async fn auth(
 			sender_device: Some(device_id),
 			appservice_info: None,
 		}),
-		(AuthScheme::ServerSignatures, Token::None) => Ok(auth_server(request, json_body).await?),
+		(AuthScheme::ServerSignatures, Token::None) => Ok(auth_server(services, request, json_body).await?),
 		(AuthScheme::None | AuthScheme::AppserviceToken | AuthScheme::AccessTokenOptional, Token::None) => Ok(Auth {
 			sender_user: None,
 			sender_device: None,
@@ -150,7 +150,7 @@ pub(super) async fn auth(
 	}
 }
 
-fn auth_appservice(request: &Request, info: Box<RegistrationInfo>) -> Result<Auth> {
+fn auth_appservice(services: &Services, request: &Request, info: Box<RegistrationInfo>) -> Result<Auth> {
 	let user_id = request
 		.query
 		.user_id
@@ -159,7 +159,7 @@ fn auth_appservice(request: &Request, info: Box<RegistrationInfo>) -> Result<Aut
 			|| {
 				UserId::parse_with_server_name(
 					info.registration.sender_localpart.as_str(),
-					services().globals.server_name(),
+					services.globals.server_name(),
 				)
 			},
 			UserId::parse,
@@ -170,7 +170,7 @@ fn auth_appservice(request: &Request, info: Box<RegistrationInfo>) -> Result<Aut
 		return Err(Error::BadRequest(ErrorKind::Exclusive, "User is not in namespace."));
 	}
 
-	if !services().users.exists(&user_id)? {
+	if !services.users.exists(&user_id)? {
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "User does not exist."));
 	}
 
@@ -182,8 +182,10 @@ fn auth_appservice(request: &Request, info: Box<RegistrationInfo>) -> Result<Aut
 	})
 }
 
-async fn auth_server(request: &mut Request, json_body: &Option<CanonicalJsonValue>) -> Result<Auth> {
-	if !services().globals.allow_federation() {
+async fn auth_server(
+	services: &Services, request: &mut Request, json_body: &Option<CanonicalJsonValue>,
+) -> Result<Auth> {
+	if !services.globals.allow_federation() {
 		return Err!(Config("allow_federation", "Federation is disabled."));
 	}
 
@@ -216,7 +218,7 @@ async fn auth_server(request: &mut Request, json_body: &Option<CanonicalJsonValu
 		),
 	)]);
 
-	let server_destination = services().globals.server_name().as_str().to_owned();
+	let server_destination = services.globals.server_name().as_str().to_owned();
 	if let Some(destination) = x_matrix.destination.as_ref() {
 		if destination != &server_destination {
 			return Err(Error::BadRequest(ErrorKind::forbidden(), "Invalid authorization."));
@@ -247,7 +249,7 @@ async fn auth_server(request: &mut Request, json_body: &Option<CanonicalJsonValu
 		request_map.insert("content".to_owned(), json_body.clone());
 	};
 
-	let keys_result = services()
+	let keys_result = services
 		.rooms
 		.event_handler
 		.fetch_signing_keys_for_server(origin, vec![x_matrix.key.to_string()])

src/api/router/request.rs

@@ -2,11 +2,10 @@ use std::str;
 
 use axum::{extract::Path, RequestExt, RequestPartsExt};
 use bytes::Bytes;
-use conduit::err;
+use conduit::{err, Result};
 use http::request::Parts;
 use serde::Deserialize;
-
-use crate::{services, Result};
+use service::Services;
 
 #[derive(Deserialize)]
 pub(super) struct QueryParams {
@@ -21,7 +20,7 @@ pub(super) struct Request {
 	pub(super) parts: Parts,
 }
 
-pub(super) async fn from(request: hyper::Request<axum::body::Body>) -> Result<Request> {
+pub(super) async fn from(services: &Services, request: hyper::Request<axum::body::Body>) -> Result<Request> {
 	let limited = request.with_limited_body();
 	let (mut parts, body) = limited.into_parts();
 
@@ -30,7 +29,7 @@ pub(super) async fn from(request: hyper::Request<axum::body::Body>) -> Result<Re
 	let query =
 		serde_html_form::from_str(query).map_err(|e| err!(Request(Unknown("Failed to read query parameters: {e}"))))?;
 
-	let max_body_size = services().globals.config.max_request_size;
+	let max_body_size = services.globals.config.max_request_size;
 
 	let body = axum::body::to_bytes(body, max_body_size)
 		.await

src/api/server/backfill.rs

@@ -1,9 +1,9 @@
+use axum::extract::State;
 use conduit::{Error, Result};
 use ruma::{
 	api::{client::error::ErrorKind, federation::backfill::get_backfill},
 	uint, user_id, MilliSecondsSinceUnixEpoch,
 };
-use service::{sending::convert_to_outgoing_federation_event, services};
 
 use crate::Ruma;
 
@@ -11,19 +11,21 @@ use crate::Ruma;
 ///
 /// Retrieves events from before the sender joined the room, if the room's
 /// history visibility allows.
-pub(crate) async fn get_backfill_route(body: Ruma<get_backfill::v1::Request>) -> Result<get_backfill::v1::Response> {
+pub(crate) async fn get_backfill_route(
+	State(services): State<crate::State>, body: Ruma<get_backfill::v1::Request>,
+) -> Result<get_backfill::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(origin, &body.room_id)?;
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.is_world_readable(&body.room_id)?
-		&& !services()
+		&& !services
 			.rooms
 			.state_cache
 			.server_in_room(origin, &body.room_id)?
@@ -34,7 +36,7 @@ pub(crate) async fn get_backfill_route(body: Ruma<get_backfill::v1::Request>) ->
 	let until = body
 		.v
 		.iter()
-		.map(|event_id| services().rooms.timeline.get_pdu_count(event_id))
+		.map(|event_id| services.rooms.timeline.get_pdu_count(event_id))
 		.filter_map(|r| r.ok().flatten())
 		.max()
 		.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event not found."))?;
@@ -45,7 +47,7 @@ pub(crate) async fn get_backfill_route(body: Ruma<get_backfill::v1::Request>) ->
 		.try_into()
 		.expect("UInt could not be converted to usize");
 
-	let all_events = services()
+	let all_events = services
 		.rooms
 		.timeline
 		.pdus_until(user_id!("@doesntmatter:conduit.rs"), &body.room_id, until)?
@@ -55,20 +57,20 @@ pub(crate) async fn get_backfill_route(body: Ruma<get_backfill::v1::Request>) ->
 		.filter_map(Result::ok)
 		.filter(|(_, e)| {
 			matches!(
-				services()
+				services
 					.rooms
 					.state_accessor
 					.server_can_see_event(origin, &e.room_id, &e.event_id,),
 				Ok(true),
 			)
 		})
-		.map(|(_, pdu)| services().rooms.timeline.get_pdu_json(&pdu.event_id))
+		.map(|(_, pdu)| services.rooms.timeline.get_pdu_json(&pdu.event_id))
 		.filter_map(|r| r.ok().flatten())
-		.map(convert_to_outgoing_federation_event)
+		.map(|pdu| services.sending.convert_to_outgoing_federation_event(pdu))
 		.collect();
 
 	Ok(get_backfill::v1::Response {
-		origin: services().globals.server_name().to_owned(),
+		origin: services.globals.server_name().to_owned(),
 		origin_server_ts: MilliSecondsSinceUnixEpoch::now(),
 		pdus: events,
 	})

src/api/server/event.rs

@@ -1,9 +1,9 @@
+use axum::extract::State;
 use conduit::{Error, Result};
 use ruma::{
 	api::{client::error::ErrorKind, federation::event::get_event},
 	MilliSecondsSinceUnixEpoch, RoomId,
 };
-use service::{sending::convert_to_outgoing_federation_event, services};
 
 use crate::Ruma;
 
@@ -13,10 +13,12 @@ use crate::Ruma;
 ///
 /// - Only works if a user of this server is currently invited or joined the
 ///   room
-pub(crate) async fn get_event_route(body: Ruma<get_event::v1::Request>) -> Result<get_event::v1::Response> {
+pub(crate) async fn get_event_route(
+	State(services): State<crate::State>, body: Ruma<get_event::v1::Request>,
+) -> Result<get_event::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	let event = services()
+	let event = services
 		.rooms
 		.timeline
 		.get_pdu_json(&body.event_id)?
@@ -30,16 +32,13 @@ pub(crate) async fn get_event_route(body: Ruma<get_event::v1::Request>) -> Resul
 	let room_id =
 		<&RoomId>::try_from(room_id_str).map_err(|_| Error::bad_database("Invalid room_id in event in database."))?;
 
-	if !services().rooms.state_accessor.is_world_readable(room_id)?
-		&& !services()
-			.rooms
-			.state_cache
-			.server_in_room(origin, room_id)?
+	if !services.rooms.state_accessor.is_world_readable(room_id)?
+		&& !services.rooms.state_cache.server_in_room(origin, room_id)?
 	{
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Server is not in room."));
 	}
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.server_can_see_event(origin, room_id, &body.event_id)?
@@ -48,8 +47,8 @@ pub(crate) async fn get_event_route(body: Ruma<get_event::v1::Request>) -> Resul
 	}
 
 	Ok(get_event::v1::Response {
-		origin: services().globals.server_name().to_owned(),
+		origin: services.globals.server_name().to_owned(),
 		origin_server_ts: MilliSecondsSinceUnixEpoch::now(),
-		pdu: convert_to_outgoing_federation_event(event),
+		pdu: services.sending.convert_to_outgoing_federation_event(event),
 	})
 }

src/api/server/event_auth.rs

@@ -1,11 +1,11 @@
 use std::sync::Arc;
 
+use axum::extract::State;
 use conduit::{Error, Result};
 use ruma::{
 	api::{client::error::ErrorKind, federation::authorization::get_event_authorization},
 	RoomId,
 };
-use service::{sending::convert_to_outgoing_federation_event, services};
 
 use crate::Ruma;
 
@@ -15,20 +15,20 @@ use crate::Ruma;
 ///
 /// - This does not include the event itself
 pub(crate) async fn get_event_authorization_route(
-	body: Ruma<get_event_authorization::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_event_authorization::v1::Request>,
 ) -> Result<get_event_authorization::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(origin, &body.room_id)?;
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.is_world_readable(&body.room_id)?
-		&& !services()
+		&& !services
 			.rooms
 			.state_cache
 			.server_in_room(origin, &body.room_id)?
@@ -36,7 +36,7 @@ pub(crate) async fn get_event_authorization_route(
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Server is not in room."));
 	}
 
-	let event = services()
+	let event = services
 		.rooms
 		.timeline
 		.get_pdu_json(&body.event_id)?
@@ -50,7 +50,7 @@ pub(crate) async fn get_event_authorization_route(
 	let room_id =
 		<&RoomId>::try_from(room_id_str).map_err(|_| Error::bad_database("Invalid room_id in event in database."))?;
 
-	let auth_chain_ids = services()
+	let auth_chain_ids = services
 		.rooms
 		.auth_chain
 		.event_ids_iter(room_id, vec![Arc::from(&*body.event_id)])
@@ -58,8 +58,8 @@ pub(crate) async fn get_event_authorization_route(
 
 	Ok(get_event_authorization::v1::Response {
 		auth_chain: auth_chain_ids
-			.filter_map(|id| services().rooms.timeline.get_pdu_json(&id).ok()?)
-			.map(convert_to_outgoing_federation_event)
+			.filter_map(|id| services.rooms.timeline.get_pdu_json(&id).ok()?)
+			.map(|pdu| services.sending.convert_to_outgoing_federation_event(pdu))
 			.collect(),
 	})
 }

src/api/server/get_missing_events.rs

@@ -1,9 +1,9 @@
+use axum::extract::State;
 use conduit::{Error, Result};
 use ruma::{
 	api::{client::error::ErrorKind, federation::event::get_missing_events},
 	OwnedEventId, RoomId,
 };
-use service::{sending::convert_to_outgoing_federation_event, services};
 
 use crate::Ruma;
 
@@ -11,20 +11,20 @@ use crate::Ruma;
 ///
 /// Retrieves events that the sender is missing.
 pub(crate) async fn get_missing_events_route(
-	body: Ruma<get_missing_events::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_missing_events::v1::Request>,
 ) -> Result<get_missing_events::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(origin, &body.room_id)?;
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.is_world_readable(&body.room_id)?
-		&& !services()
+		&& !services
 			.rooms
 			.state_cache
 			.server_in_room(origin, &body.room_id)?
@@ -43,7 +43,7 @@ pub(crate) async fn get_missing_events_route(
 
 	let mut i: usize = 0;
 	while i < queued_events.len() && events.len() < limit {
-		if let Some(pdu) = services().rooms.timeline.get_pdu_json(&queued_events[i])? {
+		if let Some(pdu) = services.rooms.timeline.get_pdu_json(&queued_events[i])? {
 			let room_id_str = pdu
 				.get("room_id")
 				.and_then(|val| val.as_str())
@@ -61,7 +61,7 @@ pub(crate) async fn get_missing_events_route(
 				continue;
 			}
 
-			if !services()
+			if !services
 				.rooms
 				.state_accessor
 				.server_can_see_event(origin, &body.room_id, &queued_events[i])?
@@ -81,7 +81,7 @@ pub(crate) async fn get_missing_events_route(
 				)
 				.map_err(|_| Error::bad_database("Invalid prev_events in event in database."))?,
 			);
-			events.push(convert_to_outgoing_federation_event(pdu));
+			events.push(services.sending.convert_to_outgoing_federation_event(pdu));
 		}
 		i = i.saturating_add(1);
 	}

src/api/server/hierarchy.rs

@@ -1,16 +1,19 @@
+use axum::extract::State;
 use ruma::api::{client::error::ErrorKind, federation::space::get_hierarchy};
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `GET /_matrix/federation/v1/hierarchy/{roomId}`
 ///
 /// Gets the space tree in a depth-first manner to locate child rooms of a given
 /// space.
-pub(crate) async fn get_hierarchy_route(body: Ruma<get_hierarchy::v1::Request>) -> Result<get_hierarchy::v1::Response> {
+pub(crate) async fn get_hierarchy_route(
+	State(services): State<crate::State>, body: Ruma<get_hierarchy::v1::Request>,
+) -> Result<get_hierarchy::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	if services().rooms.metadata.exists(&body.room_id)? {
-		services()
+	if services.rooms.metadata.exists(&body.room_id)? {
+		services
 			.rooms
 			.spaces
 			.get_federation_hierarchy(&body.room_id, origin, body.suggested_only)

src/api/server/invite.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use axum_client_ip::InsecureClientIp;
 use conduit::{utils, warn, Error, PduEvent, Result};
 use ruma::{
@@ -6,7 +7,6 @@ use ruma::{
 	serde::JsonObject,
 	CanonicalJsonValue, EventId, OwnedUserId,
 };
-use service::{sending::convert_to_outgoing_federation_event, server_is_ours, services};
 
 use crate::Ruma;
 
@@ -15,17 +15,18 @@ use crate::Ruma;
 /// Invites a remote user to a room.
 #[tracing::instrument(skip_all, fields(%client), name = "invite")]
 pub(crate) async fn create_invite_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<create_invite::v2::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<create_invite::v2::Request>,
 ) -> Result<create_invite::v2::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
 	// ACL check origin
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(origin, &body.room_id)?;
 
-	if !services()
+	if !services
 		.globals
 		.supported_room_versions()
 		.contains(&body.room_version)
@@ -39,7 +40,7 @@ pub(crate) async fn create_invite_route(
 	}
 
 	if let Some(server) = body.room_id.server_name() {
-		if services()
+		if services
 			.globals
 			.config
 			.forbidden_remote_server_names
@@ -52,7 +53,7 @@ pub(crate) async fn create_invite_route(
 		}
 	}
 
-	if services()
+	if services
 		.globals
 		.config
 		.forbidden_remote_server_names
@@ -86,7 +87,7 @@ pub(crate) async fn create_invite_route(
 	)
 	.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "state_key is not a user ID."))?;
 
-	if !server_is_ours(invited_user.server_name()) {
+	if !services.globals.server_is_ours(invited_user.server_name()) {
 		return Err(Error::BadRequest(
 			ErrorKind::InvalidParam,
 			"User does not belong to this homeserver.",
@@ -94,14 +95,14 @@ pub(crate) async fn create_invite_route(
 	}
 
 	// Make sure we're not ACL'ed from their room.
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(invited_user.server_name(), &body.room_id)?;
 
 	ruma::signatures::hash_and_sign_event(
-		services().globals.server_name().as_str(),
-		services().globals.keypair(),
+		services.globals.server_name().as_str(),
+		services.globals.keypair(),
 		&mut signed_event,
 		&body.room_version,
 	)
@@ -127,14 +128,14 @@ pub(crate) async fn create_invite_route(
 	)
 	.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "sender is not a user ID."))?;
 
-	if services().rooms.metadata.is_banned(&body.room_id)? && !services().users.is_admin(&invited_user)? {
+	if services.rooms.metadata.is_banned(&body.room_id)? && !services.users.is_admin(&invited_user)? {
 		return Err(Error::BadRequest(
 			ErrorKind::forbidden(),
 			"This room is banned on this homeserver.",
 		));
 	}
 
-	if services().globals.block_non_admin_invites() && !services().users.is_admin(&invited_user)? {
+	if services.globals.block_non_admin_invites() && !services.users.is_admin(&invited_user)? {
 		return Err(Error::BadRequest(
 			ErrorKind::forbidden(),
 			"This server does not allow room invites.",
@@ -155,12 +156,12 @@ pub(crate) async fn create_invite_route(
 
 	// If we are active in the room, the remote server will notify us about the join
 	// via /send
-	if !services()
+	if !services
 		.rooms
 		.state_cache
-		.server_in_room(services().globals.server_name(), &body.room_id)?
+		.server_in_room(services.globals.server_name(), &body.room_id)?
 	{
-		services().rooms.state_cache.update_membership(
+		services.rooms.state_cache.update_membership(
 			&body.room_id,
 			&invited_user,
 			RoomMemberEventContent::new(MembershipState::Invite),
@@ -172,6 +173,8 @@ pub(crate) async fn create_invite_route(
 	}
 
 	Ok(create_invite::v2::Response {
-		event: convert_to_outgoing_federation_event(signed_event),
+		event: services
+			.sending
+			.convert_to_outgoing_federation_event(signed_event),
 	})
 }

src/api/server/key.rs

@@ -3,7 +3,7 @@ use std::{
 	time::{Duration, SystemTime},
 };
 
-use axum::{response::IntoResponse, Json};
+use axum::{extract::State, response::IntoResponse, Json};
 use ruma::{
 	api::{
 		federation::discovery::{get_server_keys, ServerSigningKeys, VerifyKey},
@@ -13,7 +13,7 @@ use ruma::{
 	MilliSecondsSinceUnixEpoch, OwnedServerSigningKeyId,
 };
 
-use crate::{services, Result};
+use crate::Result;
 
 /// # `GET /_matrix/key/v2/server`
 ///
@@ -23,20 +23,20 @@ use crate::{services, Result};
 ///   this will be valid forever.
 // Response type for this endpoint is Json because we need to calculate a
 // signature for the response
-pub(crate) async fn get_server_keys_route() -> Result<impl IntoResponse> {
+pub(crate) async fn get_server_keys_route(State(services): State<crate::State>) -> Result<impl IntoResponse> {
 	let verify_keys: BTreeMap<OwnedServerSigningKeyId, VerifyKey> = BTreeMap::from([(
-		format!("ed25519:{}", services().globals.keypair().version())
+		format!("ed25519:{}", services.globals.keypair().version())
 			.try_into()
 			.expect("found invalid server signing keys in DB"),
 		VerifyKey {
-			key: Base64::new(services().globals.keypair().public_key().to_vec()),
+			key: Base64::new(services.globals.keypair().public_key().to_vec()),
 		},
 	)]);
 
 	let mut response = serde_json::from_slice(
 		get_server_keys::v2::Response {
 			server_key: Raw::new(&ServerSigningKeys {
-				server_name: services().globals.server_name().to_owned(),
+				server_name: services.globals.server_name().to_owned(),
 				verify_keys,
 				old_verify_keys: BTreeMap::new(),
 				signatures: BTreeMap::new(),
@@ -56,8 +56,8 @@ pub(crate) async fn get_server_keys_route() -> Result<impl IntoResponse> {
 	.unwrap();
 
 	ruma::signatures::sign_json(
-		services().globals.server_name().as_str(),
-		services().globals.keypair(),
+		services.globals.server_name().as_str(),
+		services.globals.keypair(),
 		&mut response,
 	)
 	.unwrap();
@@ -71,4 +71,6 @@ pub(crate) async fn get_server_keys_route() -> Result<impl IntoResponse> {
 ///
 /// - Matrix does not support invalidating public keys, so the key returned by
 ///   this will be valid forever.
-pub(crate) async fn get_server_keys_deprecated_route() -> impl IntoResponse { get_server_keys_route().await }
+pub(crate) async fn get_server_keys_deprecated_route(State(services): State<crate::State>) -> impl IntoResponse {
+	get_server_keys_route(State(services)).await
+}

src/api/server/make_join.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use ruma::{
 	api::{client::error::ErrorKind, federation::membership::prepare_join_event},
 	events::{
@@ -12,15 +13,18 @@ use ruma::{
 use serde_json::value::to_raw_value;
 use tracing::warn;
 
-use crate::{service::pdu::PduBuilder, services, Error, Result, Ruma};
+use crate::{
+	service::{pdu::PduBuilder, Services},
+	Error, Result, Ruma,
+};
 
 /// # `GET /_matrix/federation/v1/make_join/{roomId}/{userId}`
 ///
 /// Creates a join template.
 pub(crate) async fn create_join_event_template_route(
-	body: Ruma<prepare_join_event::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<prepare_join_event::v1::Request>,
 ) -> Result<prepare_join_event::v1::Response> {
-	if !services().rooms.metadata.exists(&body.room_id)? {
+	if !services.rooms.metadata.exists(&body.room_id)? {
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server."));
 	}
 
@@ -33,12 +37,12 @@ pub(crate) async fn create_join_event_template_route(
 	}
 
 	// ACL check origin server
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(origin, &body.room_id)?;
 
-	if services()
+	if services
 		.globals
 		.config
 		.forbidden_remote_server_names
@@ -56,7 +60,7 @@ pub(crate) async fn create_join_event_template_route(
 	}
 
 	if let Some(server) = body.room_id.server_name() {
-		if services()
+		if services
 			.globals
 			.config
 			.forbidden_remote_server_names
@@ -69,25 +73,25 @@ pub(crate) async fn create_join_event_template_route(
 		}
 	}
 
-	let room_version_id = services().rooms.state.get_room_version(&body.room_id)?;
+	let room_version_id = services.rooms.state.get_room_version(&body.room_id)?;
 
-	let state_lock = services().rooms.state.mutex.lock(&body.room_id).await;
+	let state_lock = services.rooms.state.mutex.lock(&body.room_id).await;
 
-	let join_authorized_via_users_server = if (services()
+	let join_authorized_via_users_server = if (services
 		.rooms
 		.state_cache
 		.is_left(&body.user_id, &body.room_id)
 		.unwrap_or(true))
-		&& user_can_perform_restricted_join(&body.user_id, &body.room_id, &room_version_id)?
+		&& user_can_perform_restricted_join(&services, &body.user_id, &body.room_id, &room_version_id)?
 	{
-		let auth_user = services()
+		let auth_user = services
 			.rooms
 			.state_cache
 			.room_members(&body.room_id)
 			.filter_map(Result::ok)
-			.filter(|user| user.server_name() == services().globals.server_name())
+			.filter(|user| user.server_name() == services.globals.server_name())
 			.find(|user| {
-				services()
+				services
 					.rooms
 					.state_accessor
 					.user_can_invite(&body.room_id, user, &body.user_id, &state_lock)
@@ -106,7 +110,7 @@ pub(crate) async fn create_join_event_template_route(
 		None
 	};
 
-	let room_version_id = services().rooms.state.get_room_version(&body.room_id)?;
+	let room_version_id = services.rooms.state.get_room_version(&body.room_id)?;
 	if !body.ver.contains(&room_version_id) {
 		return Err(Error::BadRequest(
 			ErrorKind::IncompatibleRoomVersion {
@@ -128,7 +132,7 @@ pub(crate) async fn create_join_event_template_route(
 	})
 	.expect("member event is valid value");
 
-	let (_pdu, mut pdu_json) = services().rooms.timeline.create_hash_and_sign_event(
+	let (_pdu, mut pdu_json) = services.rooms.timeline.create_hash_and_sign_event(
 		PduBuilder {
 			event_type: TimelineEventType::RoomMember,
 			content,
@@ -157,15 +161,14 @@ pub(crate) async fn create_join_event_template_route(
 /// externally, either by using the state cache or attempting to authorize the
 /// event.
 pub(crate) fn user_can_perform_restricted_join(
-	user_id: &UserId, room_id: &RoomId, room_version_id: &RoomVersionId,
+	services: &Services, user_id: &UserId, room_id: &RoomId, room_version_id: &RoomVersionId,
 ) -> Result<bool> {
 	use RoomVersionId::*;
 
-	let join_rules_event =
-		services()
-			.rooms
-			.state_accessor
-			.room_state_get(room_id, &StateEventType::RoomJoinRules, "")?;
+	let join_rules_event = services
+		.rooms
+		.state_accessor
+		.room_state_get(room_id, &StateEventType::RoomJoinRules, "")?;
 
 	let Some(join_rules_event_content) = join_rules_event
 		.as_ref()
@@ -198,7 +201,7 @@ pub(crate) fn user_can_perform_restricted_join(
 			}
 		})
 		.any(|m| {
-			services()
+			services
 				.rooms
 				.state_cache
 				.is_joined(user_id, &m.room_id)

src/api/server/make_leave.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use conduit::{Error, Result};
 use ruma::{
 	api::{client::error::ErrorKind, federation::membership::prepare_leave_event},
@@ -9,15 +10,15 @@ use ruma::{
 use serde_json::value::to_raw_value;
 
 use super::make_join::maybe_strip_event_id;
-use crate::{service::pdu::PduBuilder, services, Ruma};
+use crate::{service::pdu::PduBuilder, Ruma};
 
 /// # `PUT /_matrix/federation/v1/make_leave/{roomId}/{eventId}`
 ///
 /// Creates a leave template.
 pub(crate) async fn create_leave_event_template_route(
-	body: Ruma<prepare_leave_event::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<prepare_leave_event::v1::Request>,
 ) -> Result<prepare_leave_event::v1::Response> {
-	if !services().rooms.metadata.exists(&body.room_id)? {
+	if !services.rooms.metadata.exists(&body.room_id)? {
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server."));
 	}
 
@@ -30,13 +31,13 @@ pub(crate) async fn create_leave_event_template_route(
 	}
 
 	// ACL check origin
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(origin, &body.room_id)?;
 
-	let room_version_id = services().rooms.state.get_room_version(&body.room_id)?;
-	let state_lock = services().rooms.state.mutex.lock(&body.room_id).await;
+	let room_version_id = services.rooms.state.get_room_version(&body.room_id)?;
+	let state_lock = services.rooms.state.mutex.lock(&body.room_id).await;
 	let content = to_raw_value(&RoomMemberEventContent {
 		avatar_url: None,
 		blurhash: None,
@@ -49,7 +50,7 @@ pub(crate) async fn create_leave_event_template_route(
 	})
 	.expect("member event is valid value");
 
-	let (_pdu, mut pdu_json) = services().rooms.timeline.create_hash_and_sign_event(
+	let (_pdu, mut pdu_json) = services.rooms.timeline.create_hash_and_sign_event(
 		PduBuilder {
 			event_type: TimelineEventType::RoomMember,
 			content,

src/api/server/openid.rs

@@ -1,16 +1,15 @@
+use axum::extract::State;
 use ruma::api::federation::openid::get_openid_userinfo;
 
-use crate::{services, Result, Ruma};
+use crate::{Result, Ruma};
 
 /// # `GET /_matrix/federation/v1/openid/userinfo`
 ///
 /// Get information about the user that generated the OpenID token.
 pub(crate) async fn get_openid_userinfo_route(
-	body: Ruma<get_openid_userinfo::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_openid_userinfo::v1::Request>,
 ) -> Result<get_openid_userinfo::v1::Response> {
 	Ok(get_openid_userinfo::v1::Response::new(
-		services()
-			.users
-			.find_from_openid_token(&body.access_token)?,
+		services.users.find_from_openid_token(&body.access_token)?,
 	))
 }

src/api/server/publicrooms.rs

@@ -1,3 +1,4 @@
+use axum::extract::State;
 use axum_client_ip::InsecureClientIp;
 use ruma::{
 	api::{
@@ -7,16 +8,17 @@ use ruma::{
 	directory::Filter,
 };
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `POST /_matrix/federation/v1/publicRooms`
 ///
 /// Lists the public rooms on this server.
 #[tracing::instrument(skip_all, fields(%client), name = "publicrooms")]
 pub(crate) async fn get_public_rooms_filtered_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_public_rooms_filtered::v1::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_public_rooms_filtered::v1::Request>,
 ) -> Result<get_public_rooms_filtered::v1::Response> {
-	if !services()
+	if !services
 		.globals
 		.allow_public_room_directory_over_federation()
 	{
@@ -24,6 +26,7 @@ pub(crate) async fn get_public_rooms_filtered_route(
 	}
 
 	let response = crate::client::get_public_rooms_filtered_helper(
+		&services,
 		None,
 		body.limit,
 		body.since.as_deref(),
@@ -46,9 +49,10 @@ pub(crate) async fn get_public_rooms_filtered_route(
 /// Lists the public rooms on this server.
 #[tracing::instrument(skip_all, fields(%client), "publicrooms")]
 pub(crate) async fn get_public_rooms_route(
-	InsecureClientIp(client): InsecureClientIp, body: Ruma<get_public_rooms::v1::Request>,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
+	body: Ruma<get_public_rooms::v1::Request>,
 ) -> Result<get_public_rooms::v1::Response> {
-	if !services()
+	if !services
 		.globals
 		.allow_public_room_directory_over_federation()
 	{
@@ -56,6 +60,7 @@ pub(crate) async fn get_public_rooms_route(
 	}
 
 	let response = crate::client::get_public_rooms_filtered_helper(
+		&services,
 		None,
 		body.limit,
 		body.since.as_deref(),

src/api/server/query.rs

@@ -1,3 +1,5 @@
+use axum::extract::State;
+use conduit::{Error, Result};
 use get_profile_information::v1::ProfileField;
 use rand::seq::SliceRandom;
 use ruma::{
@@ -8,21 +10,21 @@ use ruma::{
 	OwnedServerName,
 };
 
-use crate::{service::server_is_ours, services, Error, Result, Ruma};
+use crate::Ruma;
 
 /// # `GET /_matrix/federation/v1/query/directory`
 ///
 /// Resolve a room alias to a room id.
 pub(crate) async fn get_room_information_route(
-	body: Ruma<get_room_information::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_room_information::v1::Request>,
 ) -> Result<get_room_information::v1::Response> {
-	let room_id = services()
+	let room_id = services
 		.rooms
 		.alias
 		.resolve_local_alias(&body.room_alias)?
 		.ok_or_else(|| Error::BadRequest(ErrorKind::NotFound, "Room alias not found."))?;
 
-	let mut servers: Vec<OwnedServerName> = services()
+	let mut servers: Vec<OwnedServerName> = services
 		.rooms
 		.state_cache
 		.room_servers(&room_id)
@@ -37,10 +39,10 @@ pub(crate) async fn get_room_information_route(
 	// insert our server as the very first choice if in list
 	if let Some(server_index) = servers
 		.iter()
-		.position(|server| server == services().globals.server_name())
+		.position(|server| server == services.globals.server_name())
 	{
 		servers.swap_remove(server_index);
-		servers.insert(0, services().globals.server_name().to_owned());
+		servers.insert(0, services.globals.server_name().to_owned());
 	}
 
 	Ok(get_room_information::v1::Response {
@@ -54,19 +56,16 @@ pub(crate) async fn get_room_information_route(
 ///
 /// Gets information on a profile.
 pub(crate) async fn get_profile_information_route(
-	body: Ruma<get_profile_information::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_profile_information::v1::Request>,
 ) -> Result<get_profile_information::v1::Response> {
-	if !services()
-		.globals
-		.allow_profile_lookup_federation_requests()
-	{
+	if !services.globals.allow_profile_lookup_federation_requests() {
 		return Err(Error::BadRequest(
 			ErrorKind::forbidden(),
 			"Profile lookup over federation is not allowed on this homeserver.",
 		));
 	}
 
-	if !server_is_ours(body.user_id.server_name()) {
+	if !services.globals.server_is_ours(body.user_id.server_name()) {
 		return Err(Error::BadRequest(
 			ErrorKind::InvalidParam,
 			"User does not belong to this server.",
@@ -79,18 +78,18 @@ pub(crate) async fn get_profile_information_route(
 
 	match &body.field {
 		Some(ProfileField::DisplayName) => {
-			displayname = services().users.displayname(&body.user_id)?;
+			displayname = services.users.displayname(&body.user_id)?;
 		},
 		Some(ProfileField::AvatarUrl) => {
-			avatar_url = services().users.avatar_url(&body.user_id)?;
-			blurhash = services().users.blurhash(&body.user_id)?;
+			avatar_url = services.users.avatar_url(&body.user_id)?;
+			blurhash = services.users.blurhash(&body.user_id)?;
 		},
 		// TODO: what to do with custom
 		Some(_) => {},
 		None => {
-			displayname = services().users.displayname(&body.user_id)?;
-			avatar_url = services().users.avatar_url(&body.user_id)?;
-			blurhash = services().users.blurhash(&body.user_id)?;
+			displayname = services.users.displayname(&body.user_id)?;
+			avatar_url = services.users.avatar_url(&body.user_id)?;
+			blurhash = services.users.blurhash(&body.user_id)?;
 		},
 	}
 

src/api/server/send.rs

@@ -21,7 +21,6 @@ use ruma::{
 use tokio::sync::RwLock;
 
 use crate::{
-	service::rooms::event_handler::parse_incoming_pdu,
 	services::Services,
 	utils::{self},
 	Error, Result, Ruma,
@@ -34,7 +33,7 @@ type ResolvedMap = BTreeMap<OwnedEventId, Result<(), Error>>;
 /// Push EDUs and PDUs to this server.
 #[tracing::instrument(skip_all, fields(%client), name = "send")]
 pub(crate) async fn send_transaction_message_route(
-	State(services): State<&Services>, InsecureClientIp(client): InsecureClientIp,
+	State(services): State<crate::State>, InsecureClientIp(client): InsecureClientIp,
 	body: Ruma<send_transaction_message::v1::Request>,
 ) -> Result<send_transaction_message::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
@@ -63,8 +62,8 @@ pub(crate) async fn send_transaction_message_route(
 		"Starting txn",
 	);
 
-	let resolved_map = handle_pdus(services, &client, &body, origin, &txn_start_time).await?;
-	handle_edus(services, &client, &body, origin).await?;
+	let resolved_map = handle_pdus(&services, &client, &body, origin, &txn_start_time).await?;
+	handle_edus(&services, &client, &body, origin).await?;
 
 	debug!(
 		pdus = ?body.pdus.len(),
@@ -89,7 +88,7 @@ async fn handle_pdus(
 ) -> Result<ResolvedMap> {
 	let mut parsed_pdus = Vec::with_capacity(body.pdus.len());
 	for pdu in &body.pdus {
-		parsed_pdus.push(match parse_incoming_pdu(pdu) {
+		parsed_pdus.push(match services.rooms.event_handler.parse_incoming_pdu(pdu) {
 			Ok(t) => t,
 			Err(e) => {
 				debug_warn!("Could not parse PDU: {e}");

src/api/server/send_join.rs

@@ -2,7 +2,8 @@
 
 use std::collections::BTreeMap;
 
-use conduit::{Error, Result};
+use axum::extract::State;
+use conduit::{pdu::gen_event_id_canonical_json, warn, Error, Result};
 use ruma::{
 	api::{client::error::ErrorKind, federation::membership::create_join_event},
 	events::{
@@ -12,28 +13,25 @@ use ruma::{
 	CanonicalJsonValue, OwnedServerName, OwnedUserId, RoomId, ServerName,
 };
 use serde_json::value::{to_raw_value, RawValue as RawJsonValue};
-use service::{
-	pdu::gen_event_id_canonical_json, sending::convert_to_outgoing_federation_event, services, user_is_local,
-};
+use service::Services;
 use tokio::sync::RwLock;
-use tracing::warn;
 
 use crate::Ruma;
 
 /// helper method for /send_join v1 and v2
 async fn create_join_event(
-	origin: &ServerName, room_id: &RoomId, pdu: &RawJsonValue,
+	services: &Services, origin: &ServerName, room_id: &RoomId, pdu: &RawJsonValue,
 ) -> Result<create_join_event::v1::RoomState> {
-	if !services().rooms.metadata.exists(room_id)? {
+	if !services.rooms.metadata.exists(room_id)? {
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server."));
 	}
 
 	// ACL check origin server
-	services().rooms.event_handler.acl_check(origin, room_id)?;
+	services.rooms.event_handler.acl_check(origin, room_id)?;
 
 	// We need to return the state prior to joining, let's keep a reference to that
 	// here
-	let shortstatehash = services()
+	let shortstatehash = services
 		.rooms
 		.state
 		.get_room_shortstatehash(room_id)?
@@ -44,7 +42,7 @@ async fn create_join_event(
 
 	// We do not add the event_id field to the pdu here because of signature and
 	// hashes checks
-	let room_version_id = services().rooms.state.get_room_version(room_id)?;
+	let room_version_id = services.rooms.state.get_room_version(room_id)?;
 
 	let Ok((event_id, mut value)) = gen_event_id_canonical_json(pdu, &room_version_id) else {
 		// Event could not be converted to canonical json
@@ -96,7 +94,7 @@ async fn create_join_event(
 	)
 	.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "sender is not a valid user ID."))?;
 
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(sender.server_name(), room_id)?;
@@ -127,19 +125,19 @@ async fn create_join_event(
 
 	if content
 		.join_authorized_via_users_server
-		.is_some_and(|user| user_is_local(&user))
-		&& super::user_can_perform_restricted_join(&sender, room_id, &room_version_id).unwrap_or_default()
+		.is_some_and(|user| services.globals.user_is_local(&user))
+		&& super::user_can_perform_restricted_join(services, &sender, room_id, &room_version_id).unwrap_or_default()
 	{
 		ruma::signatures::hash_and_sign_event(
-			services().globals.server_name().as_str(),
-			services().globals.keypair(),
+			services.globals.server_name().as_str(),
+			services.globals.keypair(),
 			&mut value,
 			&room_version_id,
 		)
 		.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Failed to sign event."))?;
 	}
 
-	services()
+	services
 		.rooms
 		.event_handler
 		.fetch_required_signing_keys([&value], &pub_key_map)
@@ -155,13 +153,13 @@ async fn create_join_event(
 	)
 	.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "origin is not a server name."))?;
 
-	let mutex_lock = services()
+	let mutex_lock = services
 		.rooms
 		.event_handler
 		.mutex_federation
 		.lock(room_id)
 		.await;
-	let pdu_id: Vec<u8> = services()
+	let pdu_id: Vec<u8> = services
 		.rooms
 		.event_handler
 		.handle_incoming_pdu(&origin, room_id, &event_id, value.clone(), true, &pub_key_map)
@@ -169,28 +167,28 @@ async fn create_join_event(
 		.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Could not accept as timeline event."))?;
 	drop(mutex_lock);
 
-	let state_ids = services()
+	let state_ids = services
 		.rooms
 		.state_accessor
 		.state_full_ids(shortstatehash)
 		.await?;
-	let auth_chain_ids = services()
+	let auth_chain_ids = services
 		.rooms
 		.auth_chain
 		.event_ids_iter(room_id, state_ids.values().cloned().collect())
 		.await?;
 
-	services().sending.send_pdu_room(room_id, &pdu_id)?;
+	services.sending.send_pdu_room(room_id, &pdu_id)?;
 
 	Ok(create_join_event::v1::RoomState {
 		auth_chain: auth_chain_ids
-			.filter_map(|id| services().rooms.timeline.get_pdu_json(&id).ok().flatten())
-			.map(convert_to_outgoing_federation_event)
+			.filter_map(|id| services.rooms.timeline.get_pdu_json(&id).ok().flatten())
+			.map(|pdu| services.sending.convert_to_outgoing_federation_event(pdu))
 			.collect(),
 		state: state_ids
 			.iter()
-			.filter_map(|(_, id)| services().rooms.timeline.get_pdu_json(id).ok().flatten())
-			.map(convert_to_outgoing_federation_event)
+			.filter_map(|(_, id)| services.rooms.timeline.get_pdu_json(id).ok().flatten())
+			.map(|pdu| services.sending.convert_to_outgoing_federation_event(pdu))
 			.collect(),
 		// Event field is required if the room version supports restricted join rules.
 		event: Some(
@@ -204,11 +202,11 @@ async fn create_join_event(
 ///
 /// Submits a signed join event.
 pub(crate) async fn create_join_event_v1_route(
-	body: Ruma<create_join_event::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<create_join_event::v1::Request>,
 ) -> Result<create_join_event::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	if services()
+	if services
 		.globals
 		.config
 		.forbidden_remote_server_names
@@ -225,7 +223,7 @@ pub(crate) async fn create_join_event_v1_route(
 	}
 
 	if let Some(server) = body.room_id.server_name() {
-		if services()
+		if services
 			.globals
 			.config
 			.forbidden_remote_server_names
@@ -243,7 +241,7 @@ pub(crate) async fn create_join_event_v1_route(
 		}
 	}
 
-	let room_state = create_join_event(origin, &body.room_id, &body.pdu).await?;
+	let room_state = create_join_event(&services, origin, &body.room_id, &body.pdu).await?;
 
 	Ok(create_join_event::v1::Response {
 		room_state,
@@ -254,11 +252,11 @@ pub(crate) async fn create_join_event_v1_route(
 ///
 /// Submits a signed join event.
 pub(crate) async fn create_join_event_v2_route(
-	body: Ruma<create_join_event::v2::Request>,
+	State(services): State<crate::State>, body: Ruma<create_join_event::v2::Request>,
 ) -> Result<create_join_event::v2::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	if services()
+	if services
 		.globals
 		.config
 		.forbidden_remote_server_names
@@ -271,7 +269,7 @@ pub(crate) async fn create_join_event_v2_route(
 	}
 
 	if let Some(server) = body.room_id.server_name() {
-		if services()
+		if services
 			.globals
 			.config
 			.forbidden_remote_server_names
@@ -288,7 +286,7 @@ pub(crate) async fn create_join_event_v2_route(
 		auth_chain,
 		state,
 		event,
-	} = create_join_event(origin, &body.room_id, &body.pdu).await?;
+	} = create_join_event(&services, origin, &body.room_id, &body.pdu).await?;
 	let room_state = create_join_event::v2::RoomState {
 		members_omitted: false,
 		auth_chain,

src/api/server/send_leave.rs

@@ -2,6 +2,8 @@
 
 use std::collections::BTreeMap;
 
+use axum::extract::State;
+use conduit::{Error, Result};
 use ruma::{
 	api::{client::error::ErrorKind, federation::membership::create_leave_event},
 	events::{
@@ -14,19 +16,19 @@ use serde_json::value::RawValue as RawJsonValue;
 use tokio::sync::RwLock;
 
 use crate::{
-	service::{pdu::gen_event_id_canonical_json, server_is_ours},
-	services, Error, Result, Ruma,
+	service::{pdu::gen_event_id_canonical_json, Services},
+	Ruma,
 };
 
 /// # `PUT /_matrix/federation/v1/send_leave/{roomId}/{eventId}`
 ///
 /// Submits a signed leave event.
 pub(crate) async fn create_leave_event_v1_route(
-	body: Ruma<create_leave_event::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<create_leave_event::v1::Request>,
 ) -> Result<create_leave_event::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	create_leave_event(origin, &body.room_id, &body.pdu).await?;
+	create_leave_event(&services, origin, &body.room_id, &body.pdu).await?;
 
 	Ok(create_leave_event::v1::Response::new())
 }
@@ -35,28 +37,30 @@ pub(crate) async fn create_leave_event_v1_route(
 ///
 /// Submits a signed leave event.
 pub(crate) async fn create_leave_event_v2_route(
-	body: Ruma<create_leave_event::v2::Request>,
+	State(services): State<crate::State>, body: Ruma<create_leave_event::v2::Request>,
 ) -> Result<create_leave_event::v2::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	create_leave_event(origin, &body.room_id, &body.pdu).await?;
+	create_leave_event(&services, origin, &body.room_id, &body.pdu).await?;
 
 	Ok(create_leave_event::v2::Response::new())
 }
 
-async fn create_leave_event(origin: &ServerName, room_id: &RoomId, pdu: &RawJsonValue) -> Result<()> {
-	if !services().rooms.metadata.exists(room_id)? {
+async fn create_leave_event(
+	services: &Services, origin: &ServerName, room_id: &RoomId, pdu: &RawJsonValue,
+) -> Result<()> {
+	if !services.rooms.metadata.exists(room_id)? {
 		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server."));
 	}
 
 	// ACL check origin
-	services().rooms.event_handler.acl_check(origin, room_id)?;
+	services.rooms.event_handler.acl_check(origin, room_id)?;
 
 	let pub_key_map = RwLock::new(BTreeMap::new());
 
 	// We do not add the event_id field to the pdu here because of signature and
 	// hashes checks
-	let room_version_id = services().rooms.state.get_room_version(room_id)?;
+	let room_version_id = services.rooms.state.get_room_version(room_id)?;
 	let Ok((event_id, value)) = gen_event_id_canonical_json(pdu, &room_version_id) else {
 		// Event could not be converted to canonical json
 		return Err(Error::BadRequest(
@@ -107,7 +111,7 @@ async fn create_leave_event(origin: &ServerName, room_id: &RoomId, pdu: &RawJson
 	)
 	.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "User ID in sender is invalid."))?;
 
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(sender.server_name(), room_id)?;
@@ -145,19 +149,19 @@ async fn create_leave_event(origin: &ServerName, room_id: &RoomId, pdu: &RawJson
 	)
 	.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "origin is not a server name."))?;
 
-	services()
+	services
 		.rooms
 		.event_handler
 		.fetch_required_signing_keys([&value], &pub_key_map)
 		.await?;
 
-	let mutex_lock = services()
+	let mutex_lock = services
 		.rooms
 		.event_handler
 		.mutex_federation
 		.lock(room_id)
 		.await;
-	let pdu_id: Vec<u8> = services()
+	let pdu_id: Vec<u8> = services
 		.rooms
 		.event_handler
 		.handle_incoming_pdu(&origin, room_id, &event_id, value, true, &pub_key_map)
@@ -166,14 +170,14 @@ async fn create_leave_event(origin: &ServerName, room_id: &RoomId, pdu: &RawJson
 
 	drop(mutex_lock);
 
-	let servers = services()
+	let servers = services
 		.rooms
 		.state_cache
 		.room_servers(room_id)
 		.filter_map(Result::ok)
-		.filter(|server| !server_is_ours(server));
+		.filter(|server| !services.globals.server_is_ours(server));
 
-	services().sending.send_pdu_servers(servers, &pdu_id)?;
+	services.sending.send_pdu_servers(servers, &pdu_id)?;
 
 	Ok(())
 }

src/api/server/state.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
+use axum::extract::State;
 use conduit::{Error, Result};
 use ruma::api::{client::error::ErrorKind, federation::event::get_room_state};
-use service::{sending::convert_to_outgoing_federation_event, services};
 
 use crate::Ruma;
 
@@ -10,20 +10,20 @@ use crate::Ruma;
 ///
 /// Retrieves a snapshot of a room's state at a given event.
 pub(crate) async fn get_room_state_route(
-	body: Ruma<get_room_state::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_room_state::v1::Request>,
 ) -> Result<get_room_state::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(origin, &body.room_id)?;
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.is_world_readable(&body.room_id)?
-		&& !services()
+		&& !services
 			.rooms
 			.state_cache
 			.server_in_room(origin, &body.room_id)?
@@ -31,31 +31,26 @@ pub(crate) async fn get_room_state_route(
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Server is not in room."));
 	}
 
-	let shortstatehash = services()
+	let shortstatehash = services
 		.rooms
 		.state_accessor
 		.pdu_shortstatehash(&body.event_id)?
 		.ok_or_else(|| Error::BadRequest(ErrorKind::NotFound, "Pdu state not found."))?;
 
-	let pdus = services()
+	let pdus = services
 		.rooms
 		.state_accessor
 		.state_full_ids(shortstatehash)
 		.await?
 		.into_values()
 		.map(|id| {
-			convert_to_outgoing_federation_event(
-				services()
-					.rooms
-					.timeline
-					.get_pdu_json(&id)
-					.unwrap()
-					.unwrap(),
-			)
+			services
+				.sending
+				.convert_to_outgoing_federation_event(services.rooms.timeline.get_pdu_json(&id).unwrap().unwrap())
 		})
 		.collect();
 
-	let auth_chain_ids = services()
+	let auth_chain_ids = services
 		.rooms
 		.auth_chain
 		.event_ids_iter(&body.room_id, vec![Arc::from(&*body.event_id)])
@@ -64,12 +59,12 @@ pub(crate) async fn get_room_state_route(
 	Ok(get_room_state::v1::Response {
 		auth_chain: auth_chain_ids
 			.filter_map(|id| {
-				services()
+				services
 					.rooms
 					.timeline
 					.get_pdu_json(&id)
 					.ok()?
-					.map(convert_to_outgoing_federation_event)
+					.map(|pdu| services.sending.convert_to_outgoing_federation_event(pdu))
 			})
 			.collect(),
 		pdus,

src/api/server/state_ids.rs

@@ -1,28 +1,29 @@
 use std::sync::Arc;
 
+use axum::extract::State;
 use ruma::api::{client::error::ErrorKind, federation::event::get_room_state_ids};
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `GET /_matrix/federation/v1/state_ids/{roomId}`
 ///
 /// Retrieves a snapshot of a room's state at a given event, in the form of
 /// event IDs.
 pub(crate) async fn get_room_state_ids_route(
-	body: Ruma<get_room_state_ids::v1::Request>,
+	State(services): State<crate::State>, body: Ruma<get_room_state_ids::v1::Request>,
 ) -> Result<get_room_state_ids::v1::Response> {
 	let origin = body.origin.as_ref().expect("server is authenticated");
 
-	services()
+	services
 		.rooms
 		.event_handler
 		.acl_check(origin, &body.room_id)?;
 
-	if !services()
+	if !services
 		.rooms
 		.state_accessor
 		.is_world_readable(&body.room_id)?
-		&& !services()
+		&& !services
 			.rooms
 			.state_cache
 			.server_in_room(origin, &body.room_id)?
@@ -30,13 +31,13 @@ pub(crate) async fn get_room_state_ids_route(
 		return Err(Error::BadRequest(ErrorKind::forbidden(), "Server is not in room."));
 	}
 
-	let shortstatehash = services()
+	let shortstatehash = services
 		.rooms
 		.state_accessor
 		.pdu_shortstatehash(&body.event_id)?
 		.ok_or_else(|| Error::BadRequest(ErrorKind::NotFound, "Pdu state not found."))?;
 
-	let pdu_ids = services()
+	let pdu_ids = services
 		.rooms
 		.state_accessor
 		.state_full_ids(shortstatehash)
@@ -45,7 +46,7 @@ pub(crate) async fn get_room_state_ids_route(
 		.map(|id| (*id).to_owned())
 		.collect();
 
-	let auth_chain_ids = services()
+	let auth_chain_ids = services
 		.rooms
 		.auth_chain
 		.event_ids_iter(&body.room_id, vec![Arc::from(&*body.event_id)])

src/api/server/user.rs

@@ -1,3 +1,5 @@
+use axum::extract::State;
+use conduit::{Error, Result};
 use ruma::api::{
 	client::error::ErrorKind,
 	federation::{
@@ -8,15 +10,16 @@ use ruma::api::{
 
 use crate::{
 	client::{claim_keys_helper, get_keys_helper},
-	service::user_is_local,
-	services, Error, Result, Ruma,
+	Ruma,
 };
 
 /// # `GET /_matrix/federation/v1/user/devices/{userId}`
 ///
 /// Gets information on all devices of the user.
-pub(crate) async fn get_devices_route(body: Ruma<get_devices::v1::Request>) -> Result<get_devices::v1::Response> {
-	if !user_is_local(&body.user_id) {
+pub(crate) async fn get_devices_route(
+	State(services): State<crate::State>, body: Ruma<get_devices::v1::Request>,
+) -> Result<get_devices::v1::Response> {
+	if !services.globals.user_is_local(&body.user_id) {
 		return Err(Error::BadRequest(
 			ErrorKind::InvalidParam,
 			"Tried to access user from other server.",
@@ -27,25 +30,25 @@ pub(crate) async fn get_devices_route(body: Ruma<get_devices::v1::Request>) -> R
 
 	Ok(get_devices::v1::Response {
 		user_id: body.user_id.clone(),
-		stream_id: services()
+		stream_id: services
 			.users
 			.get_devicelist_version(&body.user_id)?
 			.unwrap_or(0)
 			.try_into()
 			.expect("version will not grow that large"),
-		devices: services()
+		devices: services
 			.users
 			.all_devices_metadata(&body.user_id)
 			.filter_map(Result::ok)
 			.filter_map(|metadata| {
 				let device_id_string = metadata.device_id.as_str().to_owned();
-				let device_display_name = if services().globals.allow_device_name_federation() {
+				let device_display_name = if services.globals.allow_device_name_federation() {
 					metadata.display_name
 				} else {
 					Some(device_id_string)
 				};
 				Some(UserDevice {
-					keys: services()
+					keys: services
 						.users
 						.get_device_keys(&body.user_id, &metadata.device_id)
 						.ok()??,
@@ -54,10 +57,10 @@ pub(crate) async fn get_devices_route(body: Ruma<get_devices::v1::Request>) -> R
 				})
 			})
 			.collect(),
-		master_key: services()
+		master_key: services
 			.users
 			.get_master_key(None, &body.user_id, &|u| u.server_name() == origin)?,
-		self_signing_key: services()
+		self_signing_key: services
 			.users
 			.get_self_signing_key(None, &body.user_id, &|u| u.server_name() == origin)?,
 	})
@@ -66,8 +69,14 @@ pub(crate) async fn get_devices_route(body: Ruma<get_devices::v1::Request>) -> R
 /// # `POST /_matrix/federation/v1/user/keys/query`
 ///
 /// Gets devices and identity keys for the given users.
-pub(crate) async fn get_keys_route(body: Ruma<get_keys::v1::Request>) -> Result<get_keys::v1::Response> {
-	if body.device_keys.iter().any(|(u, _)| !user_is_local(u)) {
+pub(crate) async fn get_keys_route(
+	State(services): State<crate::State>, body: Ruma<get_keys::v1::Request>,
+) -> Result<get_keys::v1::Response> {
+	if body
+		.device_keys
+		.iter()
+		.any(|(u, _)| !services.globals.user_is_local(u))
+	{
 		return Err(Error::BadRequest(
 			ErrorKind::InvalidParam,
 			"User does not belong to this server.",
@@ -75,10 +84,11 @@ pub(crate) async fn get_keys_route(body: Ruma<get_keys::v1::Request>) -> Result<
 	}
 
 	let result = get_keys_helper(
+		&services,
 		None,
 		&body.device_keys,
 		|u| Some(u.server_name()) == body.origin.as_deref(),
-		services().globals.allow_device_name_federation(),
+		services.globals.allow_device_name_federation(),
 	)
 	.await?;
 
@@ -92,15 +102,21 @@ pub(crate) async fn get_keys_route(body: Ruma<get_keys::v1::Request>) -> Result<
 /// # `POST /_matrix/federation/v1/user/keys/claim`
 ///
 /// Claims one-time keys.
-pub(crate) async fn claim_keys_route(body: Ruma<claim_keys::v1::Request>) -> Result<claim_keys::v1::Response> {
-	if body.one_time_keys.iter().any(|(u, _)| !user_is_local(u)) {
+pub(crate) async fn claim_keys_route(
+	State(services): State<crate::State>, body: Ruma<claim_keys::v1::Request>,
+) -> Result<claim_keys::v1::Response> {
+	if body
+		.one_time_keys
+		.iter()
+		.any(|(u, _)| !services.globals.user_is_local(u))
+	{
 		return Err(Error::BadRequest(
 			ErrorKind::InvalidParam,
 			"Tried to access user from other server.",
 		));
 	}
 
-	let result = claim_keys_helper(&body.one_time_keys).await?;
+	let result = claim_keys_helper(&services, &body.one_time_keys).await?;
 
 	Ok(claim_keys::v1::Response {
 		one_time_keys: result.one_time_keys,

src/api/server/well_known.rs

@@ -1,15 +1,16 @@
+use axum::extract::State;
 use ruma::api::{client::error::ErrorKind, federation::discovery::discover_homeserver};
 
-use crate::{services, Error, Result, Ruma};
+use crate::{Error, Result, Ruma};
 
 /// # `GET /.well-known/matrix/server`
 ///
 /// Returns the .well-known URL if it is configured, otherwise returns 404.
 pub(crate) async fn well_known_server(
-	_body: Ruma<discover_homeserver::Request>,
+	State(services): State<crate::State>, _body: Ruma<discover_homeserver::Request>,
 ) -> Result<discover_homeserver::Response> {
 	Ok(discover_homeserver::Response {
-		server: match services().globals.well_known_server() {
+		server: match services.globals.well_known_server() {
 			Some(server_name) => server_name.to_owned(),
 			None => return Err(Error::BadRequest(ErrorKind::NotFound, "Not found.")),
 		},