cargo fmt

src/api/appservice_server.rs

@@ -1,4 +1,4 @@
-use crate::{utils, Error, Result, services};
+use crate::{services, utils, Error, Result};
 use bytes::BytesMut;
 use ruma::api::{IncomingResponse, MatrixVersion, OutgoingRequest, SendAccessToken};
 use std::{fmt::Debug, mem, time::Duration};
@@ -45,7 +45,11 @@ where
     *reqwest_request.timeout_mut() = Some(Duration::from_secs(30));
 
     let url = reqwest_request.url().clone();
-    let mut response = services().globals.default_client().execute(reqwest_request).await?;
+    let mut response = services()
+        .globals
+        .default_client()
+        .execute(reqwest_request)
+        .await?;
 
     // reqwest::Response -> http::Response conversion
     let status = response.status();

src/api/client_server/account.rs

@@ -1,9 +1,7 @@
 use std::sync::Arc;
 
 use super::{DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
-use crate::{
-    utils, Error, Result, Ruma, services, api::client_server,
-};
+use crate::{api::client_server, services, utils, Error, Result, Ruma};
 use ruma::{
     api::client::{
         account::{
@@ -43,16 +41,18 @@ pub async fn get_register_available_route(
     body: Ruma<get_username_availability::v3::IncomingRequest>,
 ) -> 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())
-            .ok()
-            .filter(|user_id| {
-                !user_id.is_historical() && user_id.server_name() == services().globals.server_name()
-            })
-            .ok_or(Error::BadRequest(
-                ErrorKind::InvalidUsername,
-                "Username is invalid.",
-            ))?;
+    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_id.server_name() == services().globals.server_name()
+    })
+    .ok_or(Error::BadRequest(
+        ErrorKind::InvalidUsername,
+        "Username is invalid.",
+    ))?;
 
     // Check if username is creative enough
     if services().users.exists(&user_id)? {
@@ -95,17 +95,19 @@ pub 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())
-                    .ok()
-                    .filter(|user_id| {
-                        !user_id.is_historical()
-                            && user_id.server_name() == services().globals.server_name()
-                    })
-                    .ok_or(Error::BadRequest(
-                        ErrorKind::InvalidUsername,
-                        "Username is invalid.",
-                    ))?;
+            let proposed_user_id = UserId::parse_with_server_name(
+                username.to_lowercase(),
+                services().globals.server_name(),
+            )
+            .ok()
+            .filter(|user_id| {
+                !user_id.is_historical()
+                    && user_id.server_name() == services().globals.server_name()
+            })
+            .ok_or(Error::BadRequest(
+                ErrorKind::InvalidUsername,
+                "Username is invalid.",
+            ))?;
             if services().users.exists(&proposed_user_id)? {
                 return Err(Error::BadRequest(
                     ErrorKind::UserInUse,
@@ -176,7 +178,8 @@ pub async fn register_route(
 
     // Default to pretty displayname
     let displayname = format!("{} ⚡️", user_id.localpart());
-    services().users
+    services()
+        .users
         .set_displayname(&user_id, Some(displayname.clone()))?;
 
     // Initial account data
@@ -188,7 +191,8 @@ pub async fn register_route(
             content: ruma::events::push_rules::PushRulesEventContent {
                 global: push::Ruleset::server_default(&user_id),
             },
-        }).expect("to json always works"),
+        })
+        .expect("to json always works"),
     )?;
 
     // Inhibit login does not work for guests
@@ -220,7 +224,8 @@ pub async fn register_route(
     )?;
 
     info!("New user {} registered on this server.", user_id);
-    services().admin
+    services()
+        .admin
         .send_message(RoomMessageEventContent::notice_plain(format!(
             "New user {} registered on this server.",
             user_id
@@ -229,7 +234,10 @@ pub async fn register_route(
     // If this is the first real user, grant them admin privileges
     // Note: the server user, @conduit:servername, is generated first
     if services().users.count()? == 2 {
-        services().admin.make_user_admin(&user_id, displayname).await?;
+        services()
+            .admin
+            .make_user_admin(&user_id, displayname)
+            .await?;
 
         warn!("Granting {} admin privileges as the first user", user_id);
     }
@@ -272,26 +280,26 @@ pub async fn change_password_route(
     };
 
     if let Some(auth) = &body.auth {
-        let (worked, uiaainfo) = services().uiaa.try_auth(
-            sender_user,
-            sender_device,
-            auth,
-            &uiaainfo,
-        )?;
+        let (worked, uiaainfo) =
+            services()
+                .uiaa
+                .try_auth(sender_user, sender_device, auth, &uiaainfo)?;
         if !worked {
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
     } else if let Some(json) = body.json_body {
         uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        services().uiaa
+        services()
+            .uiaa
             .create(sender_user, sender_device, &uiaainfo, &json)?;
         return Err(Error::Uiaa(uiaainfo));
     } else {
         return Err(Error::BadRequest(ErrorKind::NotJson, "Not json."));
     }
 
-    services().users
+    services()
+        .users
         .set_password(sender_user, Some(&body.new_password))?;
 
     if body.logout_devices {
@@ -307,7 +315,8 @@ pub async fn change_password_route(
     }
 
     info!("User {} changed their password.", sender_user);
-    services().admin
+    services()
+        .admin
         .send_message(RoomMessageEventContent::notice_plain(format!(
             "User {} changed their password.",
             sender_user
@@ -321,9 +330,7 @@ pub async fn change_password_route(
 /// Get user_id of the sender user.
 ///
 /// Note: Also works for Application Services
-pub async fn whoami_route(
-    body: Ruma<whoami::v3::Request>,
-) -> Result<whoami::v3::Response> {
+pub async fn whoami_route(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.as_ref().cloned();
 
@@ -361,19 +368,18 @@ pub async fn deactivate_route(
     };
 
     if let Some(auth) = &body.auth {
-        let (worked, uiaainfo) = services().uiaa.try_auth(
-            sender_user,
-            sender_device,
-            auth,
-            &uiaainfo,
-        )?;
+        let (worked, uiaainfo) =
+            services()
+                .uiaa
+                .try_auth(sender_user, sender_device, auth, &uiaainfo)?;
         if !worked {
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
     } else if let Some(json) = body.json_body {
         uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        services().uiaa
+        services()
+            .uiaa
             .create(sender_user, sender_device, &uiaainfo, &json)?;
         return Err(Error::Uiaa(uiaainfo));
     } else {
@@ -387,7 +393,8 @@ pub async fn deactivate_route(
     services().users.deactivate_account(sender_user)?;
 
     info!("User {} deactivated their account.", sender_user);
-    services().admin
+    services()
+        .admin
         .send_message(RoomMessageEventContent::notice_plain(format!(
             "User {} deactivated their account.",
             sender_user

src/api/client_server/alias.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use regex::Regex;
 use ruma::{
     api::{
@@ -25,11 +25,18 @@ pub async fn create_alias_route(
         ));
     }
 
-    if services().rooms.alias.resolve_local_alias(&body.room_alias)?.is_some() {
+    if services()
+        .rooms
+        .alias
+        .resolve_local_alias(&body.room_alias)?
+        .is_some()
+    {
         return Err(Error::Conflict("Alias already exists."));
     }
 
-    services().rooms.alias
+    services()
+        .rooms
+        .alias
         .set_alias(&body.room_alias, &body.room_id)?;
 
     Ok(create_alias::v3::Response::new())
@@ -69,9 +76,7 @@ pub async fn get_alias_route(
     get_alias_helper(&body.room_alias).await
 }
 
-pub(crate) async fn get_alias_helper(
-    room_alias: &RoomAliasId,
-) -> Result<get_alias::v3::Response> {
+pub(crate) async fn get_alias_helper(room_alias: &RoomAliasId) -> Result<get_alias::v3::Response> {
     if room_alias.server_name() != services().globals.server_name() {
         let response = services()
             .sending
@@ -115,9 +120,15 @@ pub(crate) async fn get_alias_helper(
                         .await
                         .is_ok()
                 {
-                    room_id = Some(services().rooms.alias.resolve_local_alias(room_alias)?.ok_or_else(|| {
-                        Error::bad_config("Appservice lied to us. Room does not exist.")
-                    })?);
+                    room_id = Some(
+                        services()
+                            .rooms
+                            .alias
+                            .resolve_local_alias(room_alias)?
+                            .ok_or_else(|| {
+                                Error::bad_config("Appservice lied to us. Room does not exist.")
+                            })?,
+                    );
                     break;
                 }
             }

src/api/client_server/backup.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use ruma::api::client::{
     backup::{
         add_backup_keys, add_backup_keys_for_room, add_backup_keys_for_session,
@@ -31,7 +31,8 @@ pub async fn update_backup_version_route(
     body: Ruma<update_backup_version::v3::IncomingRequest>,
 ) -> Result<update_backup_version::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-    services().key_backups
+    services()
+        .key_backups
         .update_backup(sender_user, &body.version, &body.algorithm)?;
 
     Ok(update_backup_version::v3::Response {})
@@ -45,13 +46,13 @@ pub async fn get_latest_backup_info_route(
 ) -> Result<get_latest_backup_info::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let (version, algorithm) =
-        services().key_backups
-            .get_latest_backup(sender_user)?
-            .ok_or(Error::BadRequest(
-                ErrorKind::NotFound,
-                "Key backup does not exist.",
-            ))?;
+    let (version, algorithm) = services()
+        .key_backups
+        .get_latest_backup(sender_user)?
+        .ok_or(Error::BadRequest(
+            ErrorKind::NotFound,
+            "Key backup does not exist.",
+        ))?;
 
     Ok(get_latest_backup_info::v3::Response {
         algorithm,
@@ -78,8 +79,13 @@ pub async fn get_backup_info_route(
 
     Ok(get_backup_info::v3::Response {
         algorithm,
-        count: (services().key_backups.count_keys(sender_user, &body.version)? as u32).into(),
-        etag: services().key_backups.get_etag(sender_user, &body.version)?,
+        count: (services()
+            .key_backups
+            .count_keys(sender_user, &body.version)? as u32)
+            .into(),
+        etag: services()
+            .key_backups
+            .get_etag(sender_user, &body.version)?,
         version: body.version.to_owned(),
     })
 }
@@ -94,7 +100,9 @@ pub async fn delete_backup_version_route(
 ) -> Result<delete_backup_version::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    services().key_backups.delete_backup(sender_user, &body.version)?;
+    services()
+        .key_backups
+        .delete_backup(sender_user, &body.version)?;
 
     Ok(delete_backup_version::v3::Response {})
 }
@@ -136,8 +144,13 @@ pub async fn add_backup_keys_route(
     }
 
     Ok(add_backup_keys::v3::Response {
-        count: (services().key_backups.count_keys(sender_user, &body.version)? as u32).into(),
-        etag: services().key_backups.get_etag(sender_user, &body.version)?,
+        count: (services()
+            .key_backups
+            .count_keys(sender_user, &body.version)? as u32)
+            .into(),
+        etag: services()
+            .key_backups
+            .get_etag(sender_user, &body.version)?,
     })
 }
 
@@ -176,8 +189,13 @@ pub async fn add_backup_keys_for_room_route(
     }
 
     Ok(add_backup_keys_for_room::v3::Response {
-        count: (services().key_backups.count_keys(sender_user, &body.version)? as u32).into(),
-        etag: services().key_backups.get_etag(sender_user, &body.version)?,
+        count: (services()
+            .key_backups
+            .count_keys(sender_user, &body.version)? as u32)
+            .into(),
+        etag: services()
+            .key_backups
+            .get_etag(sender_user, &body.version)?,
     })
 }
 
@@ -214,8 +232,13 @@ pub async fn add_backup_keys_for_session_route(
     )?;
 
     Ok(add_backup_keys_for_session::v3::Response {
-        count: (services().key_backups.count_keys(sender_user, &body.version)? as u32).into(),
-        etag: services().key_backups.get_etag(sender_user, &body.version)?,
+        count: (services()
+            .key_backups
+            .count_keys(sender_user, &body.version)? as u32)
+            .into(),
+        etag: services()
+            .key_backups
+            .get_etag(sender_user, &body.version)?,
     })
 }
 
@@ -274,11 +297,18 @@ pub async fn delete_backup_keys_route(
 ) -> Result<delete_backup_keys::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    services().key_backups.delete_all_keys(sender_user, &body.version)?;
+    services()
+        .key_backups
+        .delete_all_keys(sender_user, &body.version)?;
 
     Ok(delete_backup_keys::v3::Response {
-        count: (services().key_backups.count_keys(sender_user, &body.version)? as u32).into(),
-        etag: services().key_backups.get_etag(sender_user, &body.version)?,
+        count: (services()
+            .key_backups
+            .count_keys(sender_user, &body.version)? as u32)
+            .into(),
+        etag: services()
+            .key_backups
+            .get_etag(sender_user, &body.version)?,
     })
 }
 
@@ -290,12 +320,18 @@ pub async fn delete_backup_keys_for_room_route(
 ) -> Result<delete_backup_keys_for_room::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    services().key_backups
+    services()
+        .key_backups
         .delete_room_keys(sender_user, &body.version, &body.room_id)?;
 
     Ok(delete_backup_keys_for_room::v3::Response {
-        count: (services().key_backups.count_keys(sender_user, &body.version)? as u32).into(),
-        etag: services().key_backups.get_etag(sender_user, &body.version)?,
+        count: (services()
+            .key_backups
+            .count_keys(sender_user, &body.version)? as u32)
+            .into(),
+        etag: services()
+            .key_backups
+            .get_etag(sender_user, &body.version)?,
     })
 }
 
@@ -307,11 +343,20 @@ pub async fn delete_backup_keys_for_session_route(
 ) -> Result<delete_backup_keys_for_session::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    services().key_backups
-        .delete_room_key(sender_user, &body.version, &body.room_id, &body.session_id)?;
+    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: (services().key_backups.count_keys(sender_user, &body.version)? as u32).into(),
-        etag: services().key_backups.get_etag(sender_user, &body.version)?,
+        count: (services()
+            .key_backups
+            .count_keys(sender_user, &body.version)? as u32)
+            .into(),
+        etag: services()
+            .key_backups
+            .get_etag(sender_user, &body.version)?,
     })
 }

src/api/client_server/capabilities.rs

@@ -1,4 +1,4 @@
-use crate::{Result, Ruma, services};
+use crate::{services, Result, Ruma};
 use ruma::api::client::discovery::get_capabilities::{
     self, Capabilities, RoomVersionStability, RoomVersionsCapability,
 };

src/api/client_server/config.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use ruma::{
     api::client::{
         config::{

src/api/client_server/context.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use ruma::{
     api::client::{context::get_context, error::ErrorKind, filter::LazyLoadOptions},
     events::StateEventType,
@@ -49,7 +49,11 @@ pub async fn get_context_route(
 
     let room_id = base_event.room_id.clone();
 
-    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.",
@@ -141,7 +145,11 @@ pub async fn get_context_route(
             .expect("All rooms have state"),
     };
 
-    let state_ids = services().rooms.state_accessor.state_full_ids(shortstatehash).await?;
+    let state_ids = services()
+        .rooms
+        .state_accessor
+        .state_full_ids(shortstatehash)
+        .await?;
 
     let end_token = events_after
         .last()
@@ -156,7 +164,10 @@ pub async fn get_context_route(
     let mut state = Vec::new();
 
     for (shortstatekey, id) in state_ids {
-        let (event_type, state_key) = services().rooms.short.get_statekey_from_short(shortstatekey)?;
+        let (event_type, state_key) = services()
+            .rooms
+            .short
+            .get_statekey_from_short(shortstatekey)?;
 
         if event_type != StateEventType::RoomMember {
             let pdu = match services().rooms.timeline.get_pdu(&id)? {

src/api/client_server/device.rs

@@ -1,4 +1,4 @@
-use crate::{utils, Error, Result, Ruma, services};
+use crate::{services, utils, Error, Result, Ruma};
 use ruma::api::client::{
     device::{self, delete_device, delete_devices, get_device, get_devices, update_device},
     error::ErrorKind,
@@ -55,7 +55,8 @@ pub async fn update_device_route(
 
     device.display_name = body.display_name.clone();
 
-    services().users
+    services()
+        .users
         .update_device_metadata(sender_user, &body.device_id, &device)?;
 
     Ok(update_device::v3::Response {})
@@ -88,26 +89,27 @@ pub async fn delete_device_route(
     };
 
     if let Some(auth) = &body.auth {
-        let (worked, uiaainfo) = services().uiaa.try_auth(
-            sender_user,
-            sender_device,
-            auth,
-            &uiaainfo,
-        )?;
+        let (worked, uiaainfo) =
+            services()
+                .uiaa
+                .try_auth(sender_user, sender_device, auth, &uiaainfo)?;
         if !worked {
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
     } else if let Some(json) = body.json_body {
         uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        services().uiaa
+        services()
+            .uiaa
             .create(sender_user, sender_device, &uiaainfo, &json)?;
         return Err(Error::Uiaa(uiaainfo));
     } else {
         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 {})
 }
@@ -141,19 +143,18 @@ pub async fn delete_devices_route(
     };
 
     if let Some(auth) = &body.auth {
-        let (worked, uiaainfo) = services().uiaa.try_auth(
-            sender_user,
-            sender_device,
-            auth,
-            &uiaainfo,
-        )?;
+        let (worked, uiaainfo) =
+            services()
+                .uiaa
+                .try_auth(sender_user, sender_device, auth, &uiaainfo)?;
         if !worked {
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
     } else if let Some(json) = body.json_body {
         uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        services().uiaa
+        services()
+            .uiaa
             .create(sender_user, sender_device, &uiaainfo, &json)?;
         return Err(Error::Uiaa(uiaainfo));
     } else {

src/api/client_server/directory.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use ruma::{
     api::{
         client::{
@@ -123,7 +123,8 @@ pub(crate) async fn get_public_rooms_filtered_helper(
     filter: &IncomingFilter,
     _network: &IncomingRoomNetwork,
 ) -> Result<get_public_rooms_filtered::v3::Response> {
-    if let Some(other_server) = server.filter(|server| *server != services().globals.server_name().as_str())
+    if let Some(other_server) =
+        server.filter(|server| *server != services().globals.server_name().as_str())
     {
         let response = services()
             .sending

src/api/client_server/filter.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use ruma::api::client::{
     error::ErrorKind,
     filter::{create_filter, get_filter},

src/api/client_server/keys.rs

@@ -1,5 +1,5 @@
 use super::SESSION_ID_LENGTH;
-use crate::{utils, Error, Result, Ruma, services};
+use crate::{services, utils, Error, Result, Ruma};
 use futures_util::{stream::FuturesUnordered, StreamExt};
 use ruma::{
     api::{
@@ -32,7 +32,8 @@ pub async fn upload_keys_route(
     let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
     for (key_key, key_value) in &body.one_time_keys {
-        services().users
+        services()
+            .users
             .add_one_time_key(sender_user, sender_device, key_key, key_value)?;
     }
 
@@ -44,16 +45,16 @@ pub async fn upload_keys_route(
             .get_device_keys(sender_user, sender_device)?
             .is_none()
         {
-            services().users.add_device_keys(
-                sender_user,
-                sender_device,
-                device_keys,
-            )?;
+            services()
+                .users
+                .add_device_keys(sender_user, sender_device, device_keys)?;
         }
     }
 
     Ok(upload_keys::v3::Response {
-        one_time_key_counts: services().users.count_one_time_keys(sender_user, sender_device)?,
+        one_time_key_counts: services()
+            .users
+            .count_one_time_keys(sender_user, sender_device)?,
     })
 }
 
@@ -69,12 +70,8 @@ pub async fn get_keys_route(
 ) -> Result<get_keys::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let response = get_keys_helper(
-        Some(sender_user),
-        &body.device_keys,
-        |u| u == sender_user,
-    )
-    .await?;
+    let response =
+        get_keys_helper(Some(sender_user), &body.device_keys, |u| u == sender_user).await?;
 
     Ok(response)
 }
@@ -113,19 +110,18 @@ pub async fn upload_signing_keys_route(
     };
 
     if let Some(auth) = &body.auth {
-        let (worked, uiaainfo) = services().uiaa.try_auth(
-            sender_user,
-            sender_device,
-            auth,
-            &uiaainfo,
-        )?;
+        let (worked, uiaainfo) =
+            services()
+                .uiaa
+                .try_auth(sender_user, sender_device, auth, &uiaainfo)?;
         if !worked {
             return Err(Error::Uiaa(uiaainfo));
         }
     // Success!
     } else if let Some(json) = body.json_body {
         uiaainfo.session = Some(utils::random_string(SESSION_ID_LENGTH));
-        services().uiaa
+        services()
+            .uiaa
             .create(sender_user, sender_device, &uiaainfo, &json)?;
         return Err(Error::Uiaa(uiaainfo));
     } else {
@@ -187,12 +183,9 @@ pub async fn upload_signatures_route(
                         ))?
                         .to_owned(),
                 );
-                services().users.sign_key(
-                    user_id,
-                    key_id,
-                    signature,
-                    sender_user,
-                )?;
+                services()
+                    .users
+                    .sign_key(user_id, key_id, signature, sender_user)?;
             }
         }
     }
@@ -215,7 +208,8 @@ pub async fn get_key_changes_route(
     let mut device_list_updates = HashSet::new();
 
     device_list_updates.extend(
-        services().users
+        services()
+            .users
             .keys_changed(
                 sender_user.as_str(),
                 body.from
@@ -230,9 +224,15 @@ pub async fn get_key_changes_route(
             .filter_map(|r| r.ok()),
     );
 
-    for room_id in services().rooms.state_cache.rooms_joined(sender_user).filter_map(|r| r.ok()) {
+    for room_id in services()
+        .rooms
+        .state_cache
+        .rooms_joined(sender_user)
+        .filter_map(|r| r.ok())
+    {
         device_list_updates.extend(
-            services().users
+            services()
+                .users
                 .keys_changed(
                     &room_id.to_string(),
                     body.from.parse().map_err(|_| {
@@ -296,12 +296,13 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
             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().users.get_device_metadata(user_id, device_id)?.ok_or(
-                        Error::BadRequest(
+                    let metadata = services()
+                        .users
+                        .get_device_metadata(user_id, device_id)?
+                        .ok_or(Error::BadRequest(
                             ErrorKind::InvalidParam,
                             "Tried to get keys for nonexistent device.",
-                        ),
-                    )?;
+                        ))?;
 
                     add_unsigned_device_display_name(&mut keys, metadata)
                         .map_err(|_| Error::bad_database("invalid device keys in database"))?;
@@ -311,7 +312,10 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
             }
         }
 
-        if let Some(master_key) = services().users.get_master_key(user_id, &allowed_signatures)? {
+        if let Some(master_key) = services()
+            .users
+            .get_master_key(user_id, &allowed_signatures)?
+        {
             master_keys.insert(user_id.to_owned(), master_key);
         }
         if let Some(self_signing_key) = services()
@@ -338,7 +342,8 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
             }
             (
                 server,
-                services().sending
+                services()
+                    .sending
                     .send_federation_request(
                         server,
                         federation::keys::get_keys::v1::Request {
@@ -408,7 +413,8 @@ 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().users
+                services()
+                    .users
                     .take_one_time_key(user_id, device_id, key_algorithm)?
             {
                 let mut c = BTreeMap::new();

src/api/client_server/media.rs

@@ -1,6 +1,4 @@
-use crate::{
-    utils, Error, Result, Ruma, services, service::media::FileMeta,
-};
+use crate::{service::media::FileMeta, services, utils, Error, Result, Ruma};
 use ruma::api::client::{
     error::ErrorKind,
     media::{
@@ -37,11 +35,11 @@ pub async fn create_content_route(
         utils::random_string(MXC_LENGTH)
     );
 
-    services().media
+    services()
+        .media
         .create(
             mxc.clone(),
-            body
-                .filename
+            body.filename
                 .as_ref()
                 .map(|filename| "inline; filename=".to_owned() + filename)
                 .as_deref(),
@@ -73,7 +71,8 @@ pub async fn get_remote_content(
         )
         .await?;
 
-    services().media
+    services()
+        .media
         .create(
             mxc.to_string(),
             content_response.content_disposition.as_deref(),
@@ -192,7 +191,8 @@ pub async fn get_content_thumbnail_route(
             )
             .await?;
 
-        services().media
+        services()
+            .media
             .upload_thumbnail(
                 mxc,
                 None,

src/api/client_server/membership.rs

@@ -30,7 +30,11 @@ use std::{
 };
 use tracing::{debug, error, warn};
 
-use crate::{Result, services, PduEvent, service::pdu::{gen_event_id_canonical_json, PduBuilder}, Error, api::{server_server, client_server}, utils, Ruma};
+use crate::{
+    api::{client_server, server_server},
+    service::pdu::{gen_event_id_canonical_json, PduBuilder},
+    services, utils, Error, PduEvent, Result, Ruma,
+};
 
 use super::get_alias_helper;
 
@@ -47,8 +51,9 @@ pub async fn join_room_by_id_route(
 
     let mut servers = Vec::new(); // There is no body.server_name for /roomId/join
     servers.extend(
-        services().rooms
-        .state_cache
+        services()
+            .rooms
+            .state_cache
             .invite_state(sender_user, &body.room_id)?
             .unwrap_or_default()
             .iter()
@@ -88,8 +93,9 @@ pub async fn join_room_by_id_or_alias_route(
         Ok(room_id) => {
             let mut servers = body.server_name.clone();
             servers.extend(
-                services().rooms
-                .state_cache
+                services()
+                    .rooms
+                    .state_cache
                     .invite_state(sender_user, &room_id)?
                     .unwrap_or_default()
                     .iter()
@@ -163,8 +169,9 @@ pub async fn kick_user_route(
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
     let mut event: RoomMemberEventContent = serde_json::from_str(
-        services().rooms
-        .state_accessor
+        services()
+            .rooms
+            .state_accessor
             .room_state_get(
                 &body.room_id,
                 &StateEventType::RoomMember,
@@ -183,7 +190,8 @@ pub async fn kick_user_route(
     // TODO: reason
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -250,7 +258,8 @@ pub async fn ban_user_route(
         )?;
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -286,8 +295,9 @@ pub async fn unban_user_route(
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
     let mut event: RoomMemberEventContent = serde_json::from_str(
-        services().rooms
-        .state_accessor
+        services()
+            .rooms
+            .state_accessor
             .room_state_get(
                 &body.room_id,
                 &StateEventType::RoomMember,
@@ -305,7 +315,8 @@ pub async fn unban_user_route(
     event.membership = MembershipState::Leave;
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -345,7 +356,10 @@ pub async fn forget_room_route(
 ) -> Result<forget_room::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    services().rooms.state_cache.forget(&body.room_id, sender_user)?;
+    services()
+        .rooms
+        .state_cache
+        .forget(&body.room_id, sender_user)?;
 
     Ok(forget_room::v3::Response::new())
 }
@@ -379,7 +393,11 @@ pub async fn get_member_events_route(
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
     // TODO: check history visibility?
-    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .is_joined(sender_user, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "You don't have permission to view this room.",
@@ -410,7 +428,11 @@ pub async fn joined_members_route(
 ) -> Result<joined_members::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .is_joined(sender_user, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "You aren't a member of the room.",
@@ -418,7 +440,12 @@ pub async fn joined_members_route(
     }
 
     let mut joined = BTreeMap::new();
-    for user_id in services().rooms.state_cache.room_members(&body.room_id).filter_map(|r| r.ok()) {
+    for user_id in services()
+        .rooms
+        .state_cache
+        .room_members(&body.room_id)
+        .filter_map(|r| r.ok())
+    {
         let display_name = services().users.displayname(&user_id)?;
         let avatar_url = services().users.avatar_url(&user_id)?;
 
@@ -443,7 +470,8 @@ async fn join_room_by_id_helper(
     let sender_user = sender_user.expect("user is authenticated");
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -481,7 +509,14 @@ async fn join_room_by_id_helper(
         let (make_join_response, remote_server) = make_join_response_and_server?;
 
         let room_version = match make_join_response.room_version {
-            Some(room_version) if services().globals.supported_room_versions().contains(&room_version) => room_version,
+            Some(room_version)
+                if services()
+                    .globals
+                    .supported_room_versions()
+                    .contains(&room_version) =>
+            {
+                room_version
+            }
             _ => return Err(Error::BadServerResponse("Room version is not supported")),
         };
 
@@ -568,12 +603,11 @@ async fn join_room_by_id_helper(
         let mut state = HashMap::new();
         let pub_key_map = RwLock::new(BTreeMap::new());
 
-        services().rooms.event_handler.fetch_join_signing_keys(
-            &send_join_response,
-            &room_version,
-            &pub_key_map,
-        )
-        .await?;
+        services()
+            .rooms
+            .event_handler
+            .fetch_join_signing_keys(&send_join_response, &room_version, &pub_key_map)
+            .await?;
 
         for result in send_join_response
             .room_state
@@ -591,12 +625,15 @@ async fn join_room_by_id_helper(
                 Error::BadServerResponse("Invalid PDU in send_join response.")
             })?;
 
-            services().rooms.outlier.add_pdu_outlier(&event_id, &value)?;
+            services()
+                .rooms
+                .outlier
+                .add_pdu_outlier(&event_id, &value)?;
             if let Some(state_key) = &pdu.state_key {
-                let shortstatekey = services().rooms.short.get_or_create_shortstatekey(
-                    &pdu.kind.to_string().into(),
-                    state_key,
-                )?;
+                let shortstatekey = services()
+                    .rooms
+                    .short
+                    .get_or_create_shortstatekey(&pdu.kind.to_string().into(), state_key)?;
                 state.insert(shortstatekey, pdu.event_id.clone());
             }
         }
@@ -632,7 +669,10 @@ async fn join_room_by_id_helper(
                 Err(_) => continue,
             };
 
-            services().rooms.outlier.add_pdu_outlier(&event_id, &value)?;
+            services()
+                .rooms
+                .outlier
+                .add_pdu_outlier(&event_id, &value)?;
         }
 
         let shortstatehash = services().rooms.state.set_event_state(
@@ -640,7 +680,12 @@ async fn join_room_by_id_helper(
             room_id,
             state
                 .into_iter()
-                .map(|(k, id)| services().rooms.state_compressor.compress_state_event(k, &id))
+                .map(|(k, id)| {
+                    services()
+                        .rooms
+                        .state_compressor
+                        .compress_state_event(k, &id)
+                })
                 .collect::<Result<_>>()?,
         )?;
 
@@ -650,12 +695,15 @@ async fn join_room_by_id_helper(
             &parsed_pdu,
             join_event,
             vec![(*parsed_pdu.event_id).to_owned()],
-            &state_lock
+            &state_lock,
         )?;
 
         // We set the room state after inserting the pdu, so that we never have a moment in time
         // where events in the current room state do not exist
-        services().rooms.state.set_room_state(room_id, shortstatehash, &state_lock)?;
+        services()
+            .rooms
+            .state
+            .set_room_state(room_id, shortstatehash, &state_lock)?;
 
         let statehashid = services().rooms.state.append_to_state(&parsed_pdu)?;
     } else {
@@ -705,7 +753,13 @@ fn validate_and_add_event_id(
     ))
     .expect("ruma's reference hashes are valid event ids");
 
-    let back_off = |id| match services().globals.bad_event_ratelimiter.write().unwrap().entry(id) {
+    let back_off = |id| match services()
+        .globals
+        .bad_event_ratelimiter
+        .write()
+        .unwrap()
+        .entry(id)
+    {
         Entry::Vacant(e) => {
             e.insert((Instant::now(), 1));
         }
@@ -760,7 +814,8 @@ pub(crate) async fn invite_helper<'a>(
     if user_id.server_name() != services().globals.server_name() {
         let (pdu_json, invite_room_state) = {
             let mutex_state = Arc::clone(
-                services().globals
+                services()
+                    .globals
                     .roomid_mutex_state
                     .write()
                     .unwrap()
@@ -781,13 +836,18 @@ pub(crate) async fn invite_helper<'a>(
             })
             .expect("member event is valid value");
 
-            let (pdu, pdu_json) = services().rooms.timeline.create_hash_and_sign_event(PduBuilder {
-                event_type: RoomEventType::RoomMember,
-                content,
-                unsigned: None,
-                state_key: Some(user_id.to_string()),
-                redacts: None,
-            }, sender_user, room_id, &state_lock)?;
+            let (pdu, pdu_json) = services().rooms.timeline.create_hash_and_sign_event(
+                PduBuilder {
+                    event_type: RoomEventType::RoomMember,
+                    content,
+                    unsigned: None,
+                    state_key: Some(user_id.to_string()),
+                    redacts: None,
+                },
+                sender_user,
+                room_id,
+                &state_lock,
+            )?;
 
             let invite_room_state = services().rooms.state.calculate_invite_state(&pdu)?;
 
@@ -799,8 +859,11 @@ pub(crate) async fn invite_helper<'a>(
         // Generate event id
         let expected_event_id = format!(
             "${}",
-            ruma::signatures::reference_hash(&pdu_json, &services().rooms.state.get_room_version(&room_id)?)
-                .expect("ruma can calculate reference hashes")
+            ruma::signatures::reference_hash(
+                &pdu_json,
+                &services().rooms.state.get_room_version(&room_id)?
+            )
+            .expect("ruma can calculate reference hashes")
         );
         let expected_event_id = <&EventId>::try_from(expected_event_id.as_str())
             .expect("ruma's reference hashes are valid event ids");
@@ -822,8 +885,7 @@ pub(crate) async fn invite_helper<'a>(
         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 (event_id, value) = match gen_event_id_canonical_json(&response.event)
-        {
+        let (event_id, value) = match gen_event_id_canonical_json(&response.event) {
             Ok(t) => t,
             Err(_) => {
                 // Event could not be converted to canonical json
@@ -847,22 +909,20 @@ pub(crate) async fn invite_helper<'a>(
         )
         .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Origin field is invalid."))?;
 
-        let pdu_id: Vec<u8> = services().rooms.event_handler.handle_incoming_pdu(
-            &origin,
-            &event_id,
-            room_id,
-            value,
-            true,
-            &pub_key_map,
-        )
-        .await?
-        .ok_or(Error::BadRequest(
-            ErrorKind::InvalidParam,
-            "Could not accept incoming PDU as timeline event.",
-        ))?;
+        let pdu_id: Vec<u8> = services()
+            .rooms
+            .event_handler
+            .handle_incoming_pdu(&origin, &event_id, room_id, value, true, &pub_key_map)
+            .await?
+            .ok_or(Error::BadRequest(
+                ErrorKind::InvalidParam,
+                "Could not accept incoming PDU as timeline event.",
+            ))?;
 
         // Bind to variable because of lifetimes
-        let servers = services().rooms.state_cache
+        let servers = services()
+            .rooms
+            .state_cache
             .room_servers(room_id)
             .filter_map(|r| r.ok())
             .filter(|server| &**server != services().globals.server_name());
@@ -872,7 +932,11 @@ pub(crate) async fn invite_helper<'a>(
         return Ok(());
     }
 
-    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.",
@@ -880,7 +944,8 @@ pub(crate) async fn invite_helper<'a>(
     }
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -923,7 +988,13 @@ pub async fn leave_all_rooms(user_id: &UserId) -> Result<()> {
         .rooms
         .state_cache
         .rooms_joined(user_id)
-        .chain(services().rooms.state_cache.rooms_invited(user_id).map(|t| t.map(|(r, _)| r)))
+        .chain(
+            services()
+                .rooms
+                .state_cache
+                .rooms_invited(user_id)
+                .map(|t| t.map(|(r, _)| r)),
+        )
         .collect::<Vec<_>>();
 
     for room_id in all_rooms {
@@ -938,20 +1009,24 @@ pub async fn leave_all_rooms(user_id: &UserId) -> Result<()> {
     Ok(())
 }
 
-pub async fn leave_room(
-    user_id: &UserId,
-    room_id: &RoomId,
-) -> Result<()> {
+pub async fn leave_room(user_id: &UserId, room_id: &RoomId) -> Result<()> {
     // Ask a remote server if we don't have this room
-    if !services().rooms.metadata.exists(room_id)? && room_id.server_name() != services().globals.server_name() {
+    if !services().rooms.metadata.exists(room_id)?
+        && room_id.server_name() != services().globals.server_name()
+    {
         if let Err(e) = remote_leave_room(user_id, room_id).await {
             warn!("Failed to leave room {} remotely: {}", user_id, e);
             // Don't tell the client about this error
         }
 
-        let last_state = services().rooms.state_cache
+        let last_state = services()
+            .rooms
+            .state_cache
             .invite_state(user_id, room_id)?
-            .map_or_else(|| services().rooms.state_cache.left_state(user_id, room_id), |s| Ok(Some(s)))?;
+            .map_or_else(
+                || services().rooms.state_cache.left_state(user_id, room_id),
+                |s| Ok(Some(s)),
+            )?;
 
         // We always drop the invite, we can't rely on other servers
         services().rooms.state_cache.update_membership(
@@ -964,7 +1039,8 @@ pub async fn leave_room(
         )?;
     } else {
         let mutex_state = Arc::clone(
-            services().globals
+            services()
+                .globals
                 .roomid_mutex_state
                 .write()
                 .unwrap()
@@ -974,7 +1050,10 @@ pub async fn leave_room(
         let state_lock = mutex_state.lock().await;
 
         let mut event: RoomMemberEventContent = serde_json::from_str(
-            services().rooms.state_accessor.room_state_get(room_id, &StateEventType::RoomMember, user_id.as_str())?
+            services()
+                .rooms
+                .state_accessor
+                .room_state_get(room_id, &StateEventType::RoomMember, user_id.as_str())?
                 .ok_or(Error::BadRequest(
                     ErrorKind::BadState,
                     "Cannot leave a room you are not a member of.",
@@ -1003,10 +1082,7 @@ pub async fn leave_room(
     Ok(())
 }
 
-async fn remote_leave_room(
-    user_id: &UserId,
-    room_id: &RoomId,
-) -> Result<()> {
+async fn remote_leave_room(user_id: &UserId, room_id: &RoomId) -> Result<()> {
     let mut make_leave_response_and_server = Err(Error::BadServerResponse(
         "No server available to assist in leaving.",
     ));
@@ -1048,14 +1124,21 @@ async fn remote_leave_room(
     let (make_leave_response, remote_server) = make_leave_response_and_server?;
 
     let room_version_id = match make_leave_response.room_version {
-        Some(version) if services().globals.supported_room_versions().contains(&version) => version,
+        Some(version)
+            if services()
+                .globals
+                .supported_room_versions()
+                .contains(&version) =>
+        {
+            version
+        }
         _ => return Err(Error::BadServerResponse("Room version is not supported")),
     };
 
-    let mut leave_event_stub =
-        serde_json::from_str::<CanonicalJsonObject>(make_leave_response.event.get()).map_err(
-            |_| Error::BadServerResponse("Invalid make_leave event json received from server."),
-        )?;
+    let mut leave_event_stub = serde_json::from_str::<CanonicalJsonObject>(
+        make_leave_response.event.get(),
+    )
+    .map_err(|_| Error::BadServerResponse("Invalid make_leave event json received from server."))?;
 
     // TODO: Is origin needed?
     leave_event_stub.insert(
@@ -1099,7 +1182,8 @@ async fn remote_leave_room(
     // It has enough fields to be called a proper event now
     let leave_event = leave_event_stub;
 
-    services().sending
+    services()
+        .sending
         .send_federation_request(
             &remote_server,
             federation::membership::create_leave_event::v2::Request {

src/api/client_server/message.rs

@@ -1,4 +1,4 @@
-use crate::{utils, Error, Result, Ruma, services, service::pdu::PduBuilder};
+use crate::{service::pdu::PduBuilder, services, utils, Error, Result, Ruma};
 use ruma::{
     api::client::{
         error::ErrorKind,
@@ -25,7 +25,8 @@ pub async fn send_message_event_route(
     let sender_device = body.sender_device.as_deref();
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -46,7 +47,8 @@ pub async fn send_message_event_route(
 
     // Check if this is a new transaction id
     if let Some(response) =
-        services().transaction_ids
+        services()
+            .transaction_ids
             .existing_txnid(sender_user, sender_device, &body.txn_id)?
     {
         // The client might have sent a txnid of the /sendToDevice endpoint
@@ -108,7 +110,11 @@ pub async fn get_message_events_route(
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
     let sender_device = body.sender_device.as_ref().expect("user is authenticated");
 
-    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .is_joined(sender_user, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "You don't have permission to view this room.",
@@ -128,8 +134,12 @@ pub async fn get_message_events_route(
 
     let to = body.to.as_ref().map(|t| t.parse());
 
-    services().rooms
-        .lazy_loading.lazy_load_confirm_delivery(sender_user, sender_device, &body.room_id, from)?;
+    services().rooms.lazy_loading.lazy_load_confirm_delivery(
+        sender_user,
+        sender_device,
+        &body.room_id,
+        from,
+    )?;
 
     // Use limit or else 10
     let limit = body.limit.try_into().map_or(10_usize, |l: u32| l as usize);
@@ -149,8 +159,10 @@ pub async fn get_message_events_route(
                 .take(limit)
                 .filter_map(|r| r.ok()) // Filter out buggy events
                 .filter_map(|(pdu_id, pdu)| {
-                    services().rooms
-                        .timeline.pdu_count(&pdu_id)
+                    services()
+                        .rooms
+                        .timeline
+                        .pdu_count(&pdu_id)
                         .map(|pdu_count| (pdu_count, pdu))
                         .ok()
                 })
@@ -187,7 +199,8 @@ pub async fn get_message_events_route(
                 .take(limit)
                 .filter_map(|r| r.ok()) // Filter out buggy events
                 .filter_map(|(pdu_id, pdu)| {
-                    services().rooms
+                    services()
+                        .rooms
                         .timeline
                         .pdu_count(&pdu_id)
                         .map(|pdu_count| (pdu_count, pdu))
@@ -222,10 +235,11 @@ pub 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());
         }
     }

src/api/client_server/presence.rs

@@ -1,4 +1,4 @@
-use crate::{utils, Result, Ruma, services};
+use crate::{services, utils, Result, Ruma};
 use ruma::api::client::presence::{get_presence, set_presence};
 use std::time::Duration;
 
@@ -51,7 +51,8 @@ pub async fn get_presence_route(
 
     for room_id in services()
         .rooms
-        .user.get_shared_rooms(vec![sender_user.clone(), body.user_id.clone()])?
+        .user
+        .get_shared_rooms(vec![sender_user.clone(), body.user_id.clone()])?
     {
         let room_id = room_id?;
 

src/api/client_server/profile.rs

@@ -1,4 +1,4 @@
-use crate::{utils, Error, Result, Ruma, services, service::pdu::PduBuilder};
+use crate::{service::pdu::PduBuilder, services, utils, Error, Result, Ruma};
 use ruma::{
     api::{
         client::{
@@ -24,7 +24,8 @@ pub async fn set_displayname_route(
 ) -> Result<set_display_name::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    services().users
+    services()
+        .users
         .set_displayname(sender_user, body.displayname.clone())?;
 
     // Send a new membership event and presence update into all joined rooms
@@ -40,8 +41,9 @@ pub async fn set_displayname_route(
                     content: to_raw_value(&RoomMemberEventContent {
                         displayname: body.displayname.clone(),
                         ..serde_json::from_str(
-                            services().rooms
-                            .state_accessor
+                            services()
+                                .rooms
+                                .state_accessor
                                 .room_state_get(
                                     &room_id,
                                     &StateEventType::RoomMember,
@@ -71,7 +73,8 @@ pub async fn set_displayname_route(
 
     for (pdu_builder, room_id) in all_rooms_joined {
         let mutex_state = Arc::clone(
-            services().globals
+            services()
+                .globals
                 .roomid_mutex_state
                 .write()
                 .unwrap()
@@ -80,10 +83,12 @@ pub async fn set_displayname_route(
         );
         let state_lock = mutex_state.lock().await;
 
-        let _ = services()
-            .rooms
-            .timeline
-            .build_and_append_pdu(pdu_builder, sender_user, &room_id, &state_lock);
+        let _ = services().rooms.timeline.build_and_append_pdu(
+            pdu_builder,
+            sender_user,
+            &room_id,
+            &state_lock,
+        );
 
         // Presence update
         services().rooms.edus.presence.update_presence(
@@ -150,10 +155,13 @@ pub async fn set_avatar_url_route(
 ) -> Result<set_avatar_url::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    services().users
+    services()
+        .users
         .set_avatar_url(sender_user, body.avatar_url.clone())?;
 
-    services().users.set_blurhash(sender_user, body.blurhash.clone())?;
+    services()
+        .users
+        .set_blurhash(sender_user, body.blurhash.clone())?;
 
     // Send a new membership event and presence update into all joined rooms
     let all_joined_rooms: Vec<_> = services()
@@ -168,8 +176,9 @@ pub async fn set_avatar_url_route(
                     content: to_raw_value(&RoomMemberEventContent {
                         avatar_url: body.avatar_url.clone(),
                         ..serde_json::from_str(
-                            services().rooms
-                            .state_accessor
+                            services()
+                                .rooms
+                                .state_accessor
                                 .room_state_get(
                                     &room_id,
                                     &StateEventType::RoomMember,
@@ -199,7 +208,8 @@ pub async fn set_avatar_url_route(
 
     for (pdu_builder, room_id) in all_joined_rooms {
         let mutex_state = Arc::clone(
-            services().globals
+            services()
+                .globals
                 .roomid_mutex_state
                 .write()
                 .unwrap()
@@ -208,10 +218,12 @@ pub async fn set_avatar_url_route(
         );
         let state_lock = mutex_state.lock().await;
 
-        let _ = services()
-            .rooms
-            .timeline
-            .build_and_append_pdu(pdu_builder, sender_user, &room_id, &state_lock);
+        let _ = services().rooms.timeline.build_and_append_pdu(
+            pdu_builder,
+            sender_user,
+            &room_id,
+            &state_lock,
+        );
 
         // Presence update
         services().rooms.edus.presence.update_presence(

src/api/client_server/push.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use ruma::{
     api::client::{
         error::ErrorKind,

src/api/client_server/read_marker.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use ruma::{
     api::client::{error::ErrorKind, read_marker::set_read_marker, receipt::create_receipt},
     events::RoomAccountDataEventType,
@@ -34,12 +34,18 @@ pub async fn set_read_marker_route(
         services().rooms.edus.read_receipt.private_read_set(
             &body.room_id,
             sender_user,
-            services().rooms.timeline.get_pdu_count(event)?.ok_or(Error::BadRequest(
-                ErrorKind::InvalidParam,
-                "Event does not exist.",
-            ))?,
+            services()
+                .rooms
+                .timeline
+                .get_pdu_count(event)?
+                .ok_or(Error::BadRequest(
+                    ErrorKind::InvalidParam,
+                    "Event does not exist.",
+                ))?,
         )?;
-        services().rooms.user
+        services()
+            .rooms
+            .user
             .reset_notification_counts(sender_user, &body.room_id)?;
 
         let mut user_receipts = BTreeMap::new();
@@ -80,7 +86,8 @@ pub async fn create_receipt_route(
     services().rooms.edus.read_receipt.private_read_set(
         &body.room_id,
         sender_user,
-        services().rooms
+        services()
+            .rooms
             .timeline
             .get_pdu_count(&body.event_id)?
             .ok_or(Error::BadRequest(
@@ -88,7 +95,9 @@ pub async fn create_receipt_route(
                 "Event does not exist.",
             ))?,
     )?;
-    services().rooms.user
+    services()
+        .rooms
+        .user
         .reset_notification_counts(sender_user, &body.room_id)?;
 
     let mut user_receipts = BTreeMap::new();

src/api/client_server/redact.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::{Result, Ruma, services, service::pdu::PduBuilder};
+use crate::{service::pdu::PduBuilder, services, Result, Ruma};
 use ruma::{
     api::client::redact::redact_event,
     events::{room::redaction::RoomRedactionEventContent, RoomEventType},
@@ -20,7 +20,8 @@ pub async fn redact_event_route(
     let body = body.body;
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()

src/api/client_server/report.rs

@@ -1,4 +1,4 @@
-use crate::{utils::HtmlEscape, Error, Result, Ruma, services};
+use crate::{services, utils::HtmlEscape, Error, Result, Ruma};
 use ruma::{
     api::client::{error::ErrorKind, room::report_content},
     events::room::message,

src/api/client_server/room.rs

@@ -1,5 +1,5 @@
 use crate::{
-    Error, Result, Ruma, service::pdu::PduBuilder, services, api::client_server::invite_helper,
+    api::client_server::invite_helper, service::pdu::PduBuilder, services, Error, Result, Ruma,
 };
 use ruma::{
     api::client::{
@@ -57,7 +57,8 @@ pub async fn create_room_route(
     services().rooms.short.get_or_create_shortroomid(&room_id)?;
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -81,13 +82,19 @@ pub async fn create_room_route(
             .as_ref()
             .map_or(Ok(None), |localpart| {
                 // TODO: Check for invalid characters and maximum length
-                let alias =
-                    RoomAliasId::parse(format!("#{}:{}", localpart, services().globals.server_name()))
-                        .map_err(|_| {
-                            Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias.")
-                        })?;
+                let alias = RoomAliasId::parse(format!(
+                    "#{}:{}",
+                    localpart,
+                    services().globals.server_name()
+                ))
+                .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;
 
-                if services().rooms.alias.resolve_local_alias(&alias)?.is_some() {
+                if services()
+                    .rooms
+                    .alias
+                    .resolve_local_alias(&alias)?
+                    .is_some()
+                {
                     Err(Error::BadRequest(
                         ErrorKind::RoomInUse,
                         "Room alias already exists.",
@@ -99,7 +106,11 @@ pub async fn create_room_route(
 
     let room_version = match body.room_version.clone() {
         Some(room_version) => {
-            if services().globals.supported_room_versions().contains(&room_version) {
+            if services()
+                .globals
+                .supported_room_versions()
+                .contains(&room_version)
+            {
                 room_version
             } else {
                 return Err(Error::BadRequest(
@@ -338,13 +349,18 @@ pub async fn create_room_route(
         pdu_builder.state_key.get_or_insert_with(|| "".to_owned());
 
         // Silently skip encryption events if they are not allowed
-        if pdu_builder.event_type == RoomEventType::RoomEncryption && !services().globals.allow_encryption()
+        if pdu_builder.event_type == RoomEventType::RoomEncryption
+            && !services().globals.allow_encryption()
         {
             continue;
         }
 
-        services().rooms
-            .timeline.build_and_append_pdu(pdu_builder, sender_user, &room_id, &state_lock)?;
+        services().rooms.timeline.build_and_append_pdu(
+            pdu_builder,
+            sender_user,
+            &room_id,
+            &state_lock,
+        )?;
     }
 
     // 7. Events implied by name and topic
@@ -412,7 +428,11 @@ pub async fn get_room_event_route(
 ) -> Result<get_room_event::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .is_joined(sender_user, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "You don't have permission to view this room.",
@@ -439,7 +459,11 @@ pub async fn get_room_aliases_route(
 ) -> Result<aliases::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .is_joined(sender_user, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "You don't have permission to view this room.",
@@ -449,7 +473,8 @@ pub async fn get_room_aliases_route(
     Ok(aliases::v3::Response {
         aliases: services()
             .rooms
-            .alias.local_aliases_for_room(&body.room_id)
+            .alias
+            .local_aliases_for_room(&body.room_id)
             .filter_map(|a| a.ok())
             .collect(),
     })
@@ -470,7 +495,11 @@ pub async fn upgrade_room_route(
 ) -> Result<upgrade_room::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    if !services().globals.supported_room_versions().contains(&body.new_version) {
+    if !services()
+        .globals
+        .supported_room_versions()
+        .contains(&body.new_version)
+    {
         return Err(Error::BadRequest(
             ErrorKind::UnsupportedRoomVersion,
             "This server does not support that room version.",
@@ -479,11 +508,14 @@ pub async fn upgrade_room_route(
 
     // Create a replacement room
     let replacement_room = RoomId::new(services().globals.server_name());
-    services().rooms
-        .short.get_or_create_shortroomid(&replacement_room)?;
+    services()
+        .rooms
+        .short
+        .get_or_create_shortroomid(&replacement_room)?;
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -514,7 +546,8 @@ pub async fn upgrade_room_route(
     // Change lock to replacement room
     drop(state_lock);
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -525,7 +558,8 @@ pub async fn upgrade_room_route(
 
     // Get the old room creation event
     let mut create_event_content = serde_json::from_str::<CanonicalJsonObject>(
-        services().rooms
+        services()
+            .rooms
             .state_accessor
             .room_state_get(&body.room_id, &StateEventType::RoomCreate, "")?
             .ok_or_else(|| Error::bad_database("Found room without m.room.create event."))?
@@ -627,10 +661,15 @@ pub async fn upgrade_room_route(
 
     // Replicate transferable state events to the new room
     for event_type in transferable_state_events {
-        let event_content = match services().rooms.state_accessor.room_state_get(&body.room_id, &event_type, "")? {
-            Some(v) => v.content.clone(),
-            None => continue, // Skipping missing events.
-        };
+        let event_content =
+            match services()
+                .rooms
+                .state_accessor
+                .room_state_get(&body.room_id, &event_type, "")?
+            {
+                Some(v) => v.content.clone(),
+                None => continue, // Skipping missing events.
+            };
 
         services().rooms.timeline.build_and_append_pdu(
             PduBuilder {
@@ -647,14 +686,22 @@ pub async fn upgrade_room_route(
     }
 
     // Moves any local aliases to the new room
-    for alias in services().rooms.alias.local_aliases_for_room(&body.room_id).filter_map(|r| r.ok()) {
-        services().rooms
-            .alias.set_alias(&alias, &replacement_room)?;
+    for alias in services()
+        .rooms
+        .alias
+        .local_aliases_for_room(&body.room_id)
+        .filter_map(|r| r.ok())
+    {
+        services()
+            .rooms
+            .alias
+            .set_alias(&alias, &replacement_room)?;
     }
 
     // Get the old room power levels
     let mut power_levels_event_content: RoomPowerLevelsEventContent = serde_json::from_str(
-        services().rooms
+        services()
+            .rooms
             .state_accessor
             .room_state_get(&body.room_id, &StateEventType::RoomPowerLevels, "")?
             .ok_or_else(|| Error::bad_database("Found room without m.room.create event."))?
@@ -688,4 +735,3 @@ pub async fn upgrade_room_route(
     // Return the replacement room id
     Ok(upgrade_room::v3::Response { replacement_room })
 }
-

src/api/client_server/search.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use ruma::api::client::{
     error::ErrorKind,
     search::search_events::{
@@ -23,7 +23,8 @@ pub async fn search_events_route(
     let filter = &search_criteria.filter;
 
     let room_ids = filter.rooms.clone().unwrap_or_else(|| {
-        services().rooms
+        services()
+            .rooms
             .state_cache
             .rooms_joined(sender_user)
             .filter_map(|r| r.ok())
@@ -35,7 +36,11 @@ pub async fn search_events_route(
     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.",

src/api/client_server/session.rs

@@ -1,5 +1,5 @@
 use super::{DEVICE_ID_LENGTH, TOKEN_LENGTH};
-use crate::{utils, Error, Result, Ruma, services};
+use crate::{services, utils, Error, Result, Ruma};
 use ruma::{
     api::client::{
         error::ErrorKind,
@@ -40,9 +40,7 @@ pub 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 async fn login_route(
-    body: Ruma<login::v3::IncomingRequest>,
-) -> Result<login::v3::Response> {
+pub async fn login_route(body: Ruma<login::v3::IncomingRequest>) -> Result<login::v3::Response> {
     // Validate login method
     // TODO: Other login methods
     let user_id = match &body.login_info {
@@ -55,15 +53,18 @@ pub async fn login_route(
             } else {
                 return Err(Error::BadRequest(ErrorKind::Forbidden, "Bad login type."));
             };
-            let user_id =
-                UserId::parse_with_server_name(username.to_owned(), services().globals.server_name())
-                    .map_err(|_| {
-                        Error::BadRequest(ErrorKind::InvalidUsername, "Username is invalid.")
-                    })?;
-            let hash = services().users.password_hash(&user_id)?.ok_or(Error::BadRequest(
-                ErrorKind::Forbidden,
-                "Wrong username or password.",
-            ))?;
+            let user_id = UserId::parse_with_server_name(
+                username.to_owned(),
+                services().globals.server_name(),
+            )
+            .map_err(|_| Error::BadRequest(ErrorKind::InvalidUsername, "Username is invalid."))?;
+            let hash = services()
+                .users
+                .password_hash(&user_id)?
+                .ok_or(Error::BadRequest(
+                    ErrorKind::Forbidden,
+                    "Wrong username or password.",
+                ))?;
 
             if hash.is_empty() {
                 return Err(Error::BadRequest(
@@ -121,7 +122,8 @@ pub async fn login_route(
 
     // 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().users
+        services()
+            .users
             .all_device_ids(&user_id)
             .any(|x| x.as_ref().map_or(false, |v| v == device_id))
     });
@@ -156,9 +158,7 @@ pub async fn login_route(
 /// - Deletes device metadata (device id, device display name, last seen ip, last seen ts)
 /// - Forgets to-device events
 /// - Triggers device list updates
-pub async fn logout_route(
-    body: Ruma<logout::v3::Request>,
-) -> Result<logout::v3::Response> {
+pub async fn logout_route(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");
 

src/api/client_server/state.rs

@@ -1,8 +1,6 @@
 use std::sync::Arc;
 
-use crate::{
-    Error, Result, Ruma, RumaResponse, services, service::pdu::PduBuilder,
-};
+use crate::{service::pdu::PduBuilder, services, Error, Result, Ruma, RumaResponse};
 use ruma::{
     api::client::{
         error::ErrorKind,
@@ -90,10 +88,14 @@ pub async fn get_state_events_route(
     #[allow(clippy::blocks_in_if_conditions)]
     // Users not in the room should not be able to access the state unless history_visibility is
     // WorldReadable
-    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)?
+    if !services()
+        .rooms
+        .state_cache
+        .is_joined(sender_user, &body.room_id)?
         && !matches!(
-            services().rooms
-            .state_accessor
+            services()
+                .rooms
+                .state_accessor
                 .room_state_get(&body.room_id, &StateEventType::RoomHistoryVisibility, "")?
                 .map(|event| {
                     serde_json::from_str(event.content.get())
@@ -138,10 +140,15 @@ pub async fn get_state_events_for_key_route(
     #[allow(clippy::blocks_in_if_conditions)]
     // Users not in the room should not be able to access the state unless history_visibility is
     // WorldReadable
-    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)?
+    if !services()
+        .rooms
+        .state_cache
+        .is_joined(sender_user, &body.room_id)?
         && !matches!(
-            services().rooms
-                .state_accessor.room_state_get(&body.room_id, &StateEventType::RoomHistoryVisibility, "")?
+            services()
+                .rooms
+                .state_accessor
+                .room_state_get(&body.room_id, &StateEventType::RoomHistoryVisibility, "")?
                 .map(|event| {
                     serde_json::from_str(event.content.get())
                         .map(|e: RoomHistoryVisibilityEventContent| e.history_visibility)
@@ -162,7 +169,8 @@ pub async fn get_state_events_for_key_route(
 
     let event = services()
         .rooms
-        .state_accessor.room_state_get(&body.room_id, &body.event_type, &body.state_key)?
+        .state_accessor
+        .room_state_get(&body.room_id, &body.event_type, &body.state_key)?
         .ok_or(Error::BadRequest(
             ErrorKind::NotFound,
             "State event not found.",
@@ -187,10 +195,15 @@ pub async fn get_state_events_for_empty_key_route(
     #[allow(clippy::blocks_in_if_conditions)]
     // Users not in the room should not be able to access the state unless history_visibility is
     // WorldReadable
-    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)?
+    if !services()
+        .rooms
+        .state_cache
+        .is_joined(sender_user, &body.room_id)?
         && !matches!(
-            services().rooms
-                .state_accessor.room_state_get(&body.room_id, &StateEventType::RoomHistoryVisibility, "")?
+            services()
+                .rooms
+                .state_accessor
+                .room_state_get(&body.room_id, &StateEventType::RoomHistoryVisibility, "")?
                 .map(|event| {
                     serde_json::from_str(event.content.get())
                         .map(|e: RoomHistoryVisibilityEventContent| e.history_visibility)
@@ -211,7 +224,8 @@ pub async fn get_state_events_for_empty_key_route(
 
     let event = services()
         .rooms
-        .state_accessor.room_state_get(&body.room_id, &body.event_type, "")?
+        .state_accessor
+        .room_state_get(&body.room_id, &body.event_type, "")?
         .ok_or(Error::BadRequest(
             ErrorKind::NotFound,
             "State event not found.",
@@ -248,7 +262,8 @@ async fn send_state_event_for_key_helper(
             if alias.server_name() != services().globals.server_name()
                 || services()
                     .rooms
-                    .alias.resolve_local_alias(&alias)?
+                    .alias
+                    .resolve_local_alias(&alias)?
                     .filter(|room| room == room_id) // Make sure it's the right room
                     .is_none()
             {
@@ -262,7 +277,8 @@ async fn send_state_event_for_key_helper(
     }
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()

src/api/client_server/sync.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result, Ruma, RumaResponse, services};
+use crate::{services, Error, Result, Ruma, RumaResponse};
 use ruma::{
     api::client::{
         filter::{IncomingFilterDefinition, LazyLoadOptions},
@@ -129,12 +129,7 @@ async fn sync_helper_wrapper(
 ) {
     let since = body.since.clone();
 
-    let r = sync_helper(
-        sender_user.clone(),
-        sender_device.clone(),
-        body,
-    )
-    .await;
+    let r = sync_helper(sender_user.clone(), sender_device.clone(), body).await;
 
     if let Ok((_, caching_allowed)) = r {
         if !caching_allowed {
@@ -211,12 +206,17 @@ async fn sync_helper(
 
     // Look for device list updates of this account
     device_list_updates.extend(
-        services().users
+        services()
+            .users
             .keys_changed(&sender_user.to_string(), since, None)
             .filter_map(|r| r.ok()),
     );
 
-    let all_joined_rooms = services().rooms.state_cache.rooms_joined(&sender_user).collect::<Vec<_>>();
+    let all_joined_rooms = services()
+        .rooms
+        .state_cache
+        .rooms_joined(&sender_user)
+        .collect::<Vec<_>>();
     for room_id in all_joined_rooms {
         let room_id = room_id?;
 
@@ -224,7 +224,8 @@ async fn sync_helper(
             // Get and drop the lock to wait for remaining operations to finish
             // This will make sure the we have all events until next_batch
             let mutex_insert = Arc::clone(
-                services().globals
+                services()
+                    .globals
                     .roomid_mutex_insert
                     .write()
                     .unwrap()
@@ -237,7 +238,12 @@ async fn sync_helper(
 
         let timeline_pdus;
         let limited;
-        if services().rooms.timeline.last_timeline_count(&sender_user, &room_id)? > since {
+        if services()
+            .rooms
+            .timeline
+            .last_timeline_count(&sender_user, &room_id)?
+            > since
+        {
             let mut non_timeline_pdus = services()
                 .rooms
                 .timeline
@@ -250,7 +256,8 @@ async fn sync_helper(
                     r.ok()
                 })
                 .take_while(|(pduid, _)| {
-                    services().rooms
+                    services()
+                        .rooms
                         .timeline
                         .pdu_count(pduid)
                         .map_or(false, |count| count > since)
@@ -286,24 +293,40 @@ async fn sync_helper(
             timeline_users.insert(event.sender.as_str().to_owned());
         }
 
-        services().rooms.lazy_loading
-            .lazy_load_confirm_delivery(&sender_user, &sender_device, &room_id, since)?;
+        services().rooms.lazy_loading.lazy_load_confirm_delivery(
+            &sender_user,
+            &sender_device,
+            &room_id,
+            since,
+        )?;
 
         // Database queries:
 
-        let current_shortstatehash = if let Some(s) = services().rooms.state.get_room_shortstatehash(&room_id)? {
-            s
-        } else {
-            error!("Room {} has no state", room_id);
-            continue;
-        };
+        let current_shortstatehash =
+            if let Some(s) = services().rooms.state.get_room_shortstatehash(&room_id)? {
+                s
+            } else {
+                error!("Room {} has no state", room_id);
+                continue;
+            };
 
-        let since_shortstatehash = services().rooms.user.get_token_shortstatehash(&room_id, since)?;
+        let since_shortstatehash = services()
+            .rooms
+            .user
+            .get_token_shortstatehash(&room_id, since)?;
 
         // Calculates joined_member_count, invited_member_count and heroes
         let calculate_counts = || {
-            let joined_member_count = services().rooms.state_cache.room_joined_count(&room_id)?.unwrap_or(0);
-            let invited_member_count = services().rooms.state_cache.room_invited_count(&room_id)?.unwrap_or(0);
+            let joined_member_count = services()
+                .rooms
+                .state_cache
+                .room_joined_count(&room_id)?
+                .unwrap_or(0);
+            let invited_member_count = services()
+                .rooms
+                .state_cache
+                .room_invited_count(&room_id)?
+                .unwrap_or(0);
 
             // Recalculate heroes (first 5 members)
             let mut heroes = Vec::new();
@@ -314,7 +337,8 @@ async fn sync_helper(
 
                 for hero in services()
                     .rooms
-                    .timeline.all_pdus(&sender_user, &room_id)?
+                    .timeline
+                    .all_pdus(&sender_user, &room_id)?
                     .filter_map(|pdu| pdu.ok()) // Ignore all broken pdus
                     .filter(|(_, pdu)| pdu.kind == RoomEventType::RoomMember)
                     .map(|(_, pdu)| {
@@ -333,7 +357,10 @@ async fn sync_helper(
                                 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_invited(&user_id, &room_id)?)
                             {
                                 Ok::<_, Error>(Some(state_key.clone()))
                             } else {
@@ -374,14 +401,21 @@ async fn sync_helper(
 
             let (joined_member_count, invited_member_count, heroes) = calculate_counts()?;
 
-            let current_state_ids = services().rooms.state_accessor.state_full_ids(current_shortstatehash).await?;
+            let current_state_ids = services()
+                .rooms
+                .state_accessor
+                .state_full_ids(current_shortstatehash)
+                .await?;
 
             let mut state_events = Vec::new();
             let mut lazy_loaded = HashSet::new();
 
             let mut i = 0;
             for (shortstatekey, id) in current_state_ids {
-                let (event_type, state_key) = services().rooms.short.get_statekey_from_short(shortstatekey)?;
+                let (event_type, state_key) = services()
+                    .rooms
+                    .short
+                    .get_statekey_from_short(shortstatekey)?;
 
                 if event_type != StateEventType::RoomMember {
                     let pdu = match services().rooms.timeline.get_pdu(&id)? {
@@ -423,8 +457,11 @@ async fn sync_helper(
             }
 
             // Reset lazy loading because this is an initial sync
-            services().rooms.lazy_loading
-                .lazy_load_reset(&sender_user, &sender_device, &room_id)?;
+            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.
@@ -471,8 +508,16 @@ async fn sync_helper(
             let mut lazy_loaded = HashSet::new();
 
             if since_shortstatehash != current_shortstatehash {
-                let current_state_ids = services().rooms.state_accessor.state_full_ids(current_shortstatehash).await?;
-                let since_state_ids = services().rooms.state_accessor.state_full_ids(since_shortstatehash).await?;
+                let current_state_ids = services()
+                    .rooms
+                    .state_accessor
+                    .state_full_ids(current_shortstatehash)
+                    .await?;
+                let since_state_ids = services()
+                    .rooms
+                    .state_accessor
+                    .state_full_ids(since_shortstatehash)
+                    .await?;
 
                 for (key, id) in current_state_ids {
                     if body.full_state || since_state_ids.get(&key) != Some(&id) {
@@ -537,13 +582,15 @@ async fn sync_helper(
 
             let encrypted_room = services()
                 .rooms
-                .state_accessor.state_get(current_shortstatehash, &StateEventType::RoomEncryption, "")?
+                .state_accessor
+                .state_get(current_shortstatehash, &StateEventType::RoomEncryption, "")?
                 .is_some();
 
-            let since_encryption =
-                services().rooms
-                .state_accessor
-                    .state_get(since_shortstatehash, &StateEventType::RoomEncryption, "")?;
+            let since_encryption = services().rooms.state_accessor.state_get(
+                since_shortstatehash,
+                &StateEventType::RoomEncryption,
+                "",
+            )?;
 
             // Calculations:
             let new_encrypted_room = encrypted_room && since_encryption.is_none();
@@ -592,8 +639,9 @@ async fn sync_helper(
             if joined_since_last_sync && encrypted_room || new_encrypted_room {
                 // If the user is in a new encrypted room, give them all joined users
                 device_list_updates.extend(
-                    services().rooms
-                    .state_cache
+                    services()
+                        .rooms
+                        .state_cache
                         .room_members(&room_id)
                         .flatten()
                         .filter(|user_id| {
@@ -602,8 +650,7 @@ async fn sync_helper(
                         })
                         .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(&sender_user, user_id, &room_id).unwrap_or(false)
                         }),
                 );
             }
@@ -625,15 +672,17 @@ async fn sync_helper(
 
         // Look for device list updates in this room
         device_list_updates.extend(
-            services().users
+            services()
+                .users
                 .keys_changed(&room_id.to_string(), since, None)
                 .filter_map(|r| r.ok()),
         );
 
         let notification_count = if send_notification_counts {
             Some(
-                services().rooms
-                .user
+                services()
+                    .rooms
+                    .user
                     .notification_count(&sender_user, &room_id)?
                     .try_into()
                     .expect("notification count can't go that high"),
@@ -644,8 +693,9 @@ async fn sync_helper(
 
         let highlight_count = if send_notification_counts {
             Some(
-                services().rooms
-                .user
+                services()
+                    .rooms
+                    .user
                     .highlight_count(&sender_user, &room_id)?
                     .try_into()
                     .expect("highlight count can't go that high"),
@@ -657,7 +707,9 @@ async fn sync_helper(
         let prev_batch = timeline_pdus
             .first()
             .map_or(Ok::<_, Error>(None), |(pdu_id, _)| {
-                Ok(Some(services().rooms.timeline.pdu_count(pdu_id)?.to_string()))
+                Ok(Some(
+                    services().rooms.timeline.pdu_count(pdu_id)?.to_string(),
+                ))
             })?;
 
         let room_events: Vec<_> = timeline_pdus
@@ -685,8 +737,11 @@ async fn sync_helper(
         }
 
         // Save the state after this sync so we can send the correct state diff next sync
-        services().rooms.user
-            .associate_token_shortstatehash(&room_id, next_batch, current_shortstatehash)?;
+        services().rooms.user.associate_token_shortstatehash(
+            &room_id,
+            next_batch,
+            current_shortstatehash,
+        )?;
 
         let joined_room = JoinedRoom {
             account_data: RoomAccountData {
@@ -729,11 +784,11 @@ async fn sync_helper(
         }
 
         // Take presence updates from this room
-        for (user_id, presence) in
-            services().rooms
-                .edus
-                .presence
-                .presence_since(&room_id, since)?
+        for (user_id, presence) in services()
+            .rooms
+            .edus
+            .presence
+            .presence_since(&room_id, since)?
         {
             match presence_updates.entry(user_id) {
                 Entry::Vacant(v) => {
@@ -765,14 +820,19 @@ async fn sync_helper(
     }
 
     let mut left_rooms = BTreeMap::new();
-    let all_left_rooms: Vec<_> = services().rooms.state_cache.rooms_left(&sender_user).collect();
+    let all_left_rooms: Vec<_> = services()
+        .rooms
+        .state_cache
+        .rooms_left(&sender_user)
+        .collect();
     for result in all_left_rooms {
         let (room_id, left_state_events) = result?;
 
         {
             // Get and drop the lock to wait for remaining operations to finish
             let mutex_insert = Arc::clone(
-                services().globals
+                services()
+                    .globals
                     .roomid_mutex_insert
                     .write()
                     .unwrap()
@@ -783,7 +843,10 @@ async fn sync_helper(
             drop(insert_lock);
         }
 
-        let left_count = services().rooms.state_cache.get_left_count(&room_id, &sender_user)?;
+        let left_count = services()
+            .rooms
+            .state_cache
+            .get_left_count(&room_id, &sender_user)?;
 
         // Left before last sync
         if Some(since) >= left_count {
@@ -807,14 +870,19 @@ async fn sync_helper(
     }
 
     let mut invited_rooms = BTreeMap::new();
-    let all_invited_rooms: Vec<_> = services().rooms.state_cache.rooms_invited(&sender_user).collect();
+    let all_invited_rooms: Vec<_> = services()
+        .rooms
+        .state_cache
+        .rooms_invited(&sender_user)
+        .collect();
     for result in all_invited_rooms {
         let (room_id, invite_state_events) = result?;
 
         {
             // Get and drop the lock to wait for remaining operations to finish
             let mutex_insert = Arc::clone(
-                services().globals
+                services()
+                    .globals
                     .roomid_mutex_insert
                     .write()
                     .unwrap()
@@ -825,7 +893,10 @@ async fn sync_helper(
             drop(insert_lock);
         }
 
-        let invite_count = services().rooms.state_cache.get_invite_count(&room_id, &sender_user)?;
+        let invite_count = services()
+            .rooms
+            .state_cache
+            .get_invite_count(&room_id, &sender_user)?;
 
         // Invited before last sync
         if Some(since) >= invite_count {
@@ -850,8 +921,10 @@ async fn sync_helper(
             .filter_map(|r| r.ok())
             .filter_map(|other_room_id| {
                 Some(
-                    services().rooms
-                    .state_accessor.room_state_get(&other_room_id, &StateEventType::RoomEncryption, "")
+                    services()
+                        .rooms
+                        .state_accessor
+                        .room_state_get(&other_room_id, &StateEventType::RoomEncryption, "")
                         .ok()?
                         .is_some(),
                 )
@@ -865,7 +938,8 @@ async fn sync_helper(
     }
 
     // Remove all to-device events the device received *last time*
-    services().users
+    services()
+        .users
         .remove_to_device_events(&sender_user, &sender_device, since)?;
 
     let response = sync_events::v3::Response {
@@ -898,7 +972,9 @@ async fn sync_helper(
             changed: device_list_updates.into_iter().collect(),
             left: device_list_left.into_iter().collect(),
         },
-        device_one_time_keys_count: services().users.count_one_time_keys(&sender_user, &sender_device)?,
+        device_one_time_keys_count: services()
+            .users
+            .count_one_time_keys(&sender_user, &sender_device)?,
         to_device: ToDevice {
             events: services()
                 .users
@@ -942,8 +1018,9 @@ fn share_encrypted_room(
         .filter(|room_id| room_id != ignore_room)
         .filter_map(|other_room_id| {
             Some(
-                services().rooms
-                .state_accessor
+                services()
+                    .rooms
+                    .state_accessor
                     .room_state_get(&other_room_id, &StateEventType::RoomEncryption, "")
                     .ok()?
                     .is_some(),

src/api/client_server/tag.rs

@@ -1,4 +1,4 @@
-use crate::{Result, Ruma, services, Error};
+use crate::{services, Error, Result, Ruma};
 use ruma::{
     api::client::tag::{create_tag, delete_tag, get_tags},
     events::{
@@ -18,21 +18,24 @@ pub async fn update_tag_route(
 ) -> Result<create_tag::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let event = services()
-        .account_data
-        .get(
-            Some(&body.room_id),
-            sender_user,
-            RoomAccountDataEventType::Tag,
-        )?;
+    let event = services().account_data.get(
+        Some(&body.room_id),
+        sender_user,
+        RoomAccountDataEventType::Tag,
+    )?;
 
-    let mut tags_event = event.map(|e| serde_json::from_str(e.get())
-        .map_err(|_| Error::bad_database("Invalid account data event in db.")))
-        .unwrap_or_else(|| Ok(TagEvent {
-            content: TagEventContent {
-                tags: BTreeMap::new(),
-            },
-        }))?;
+    let mut tags_event = event
+        .map(|e| {
+            serde_json::from_str(e.get())
+                .map_err(|_| Error::bad_database("Invalid account data event in db."))
+        })
+        .unwrap_or_else(|| {
+            Ok(TagEvent {
+                content: TagEventContent {
+                    tags: BTreeMap::new(),
+                },
+            })
+        })?;
 
     tags_event
         .content
@@ -59,21 +62,24 @@ pub async fn delete_tag_route(
 ) -> Result<delete_tag::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let mut event = services()
-        .account_data
-        .get(
-            Some(&body.room_id),
-            sender_user,
-            RoomAccountDataEventType::Tag,
-        )?;
+    let mut event = services().account_data.get(
+        Some(&body.room_id),
+        sender_user,
+        RoomAccountDataEventType::Tag,
+    )?;
 
-    let mut tags_event = event.map(|e| serde_json::from_str(e.get())
-        .map_err(|_| Error::bad_database("Invalid account data event in db.")))
-        .unwrap_or_else(|| Ok(TagEvent {
-            content: TagEventContent {
-                tags: BTreeMap::new(),
-            },
-        }))?;
+    let mut tags_event = event
+        .map(|e| {
+            serde_json::from_str(e.get())
+                .map_err(|_| Error::bad_database("Invalid account data event in db."))
+        })
+        .unwrap_or_else(|| {
+            Ok(TagEvent {
+                content: TagEventContent {
+                    tags: BTreeMap::new(),
+                },
+            })
+        })?;
 
     tags_event.content.tags.remove(&body.tag.clone().into());
 
@@ -97,21 +103,24 @@ pub async fn get_tags_route(
 ) -> Result<get_tags::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let mut event = services()
-        .account_data
-        .get(
-            Some(&body.room_id),
-            sender_user,
-            RoomAccountDataEventType::Tag,
-        )?;
+    let mut event = services().account_data.get(
+        Some(&body.room_id),
+        sender_user,
+        RoomAccountDataEventType::Tag,
+    )?;
 
-    let mut tags_event = event.map(|e| serde_json::from_str(e.get())
-        .map_err(|_| Error::bad_database("Invalid account data event in db.")))
-        .unwrap_or_else(|| Ok(TagEvent {
-            content: TagEventContent {
-                tags: BTreeMap::new(),
-            },
-        }))?;
+    let mut tags_event = event
+        .map(|e| {
+            serde_json::from_str(e.get())
+                .map_err(|_| Error::bad_database("Invalid account data event in db."))
+        })
+        .unwrap_or_else(|| {
+            Ok(TagEvent {
+                content: TagEventContent {
+                    tags: BTreeMap::new(),
+                },
+            })
+        })?;
 
     Ok(get_tags::v3::Response {
         tags: tags_event.content.tags,

src/api/client_server/to_device.rs

@@ -1,7 +1,7 @@
 use ruma::events::ToDeviceEventType;
 use std::collections::BTreeMap;
 
-use crate::{Error, Result, Ruma, services};
+use crate::{services, Error, Result, Ruma};
 use ruma::{
     api::{
         client::{error::ErrorKind, to_device::send_event_to_device},
@@ -54,15 +54,17 @@ pub async fn send_event_to_device_route(
             }
 
             match target_device_id_maybe {
-                DeviceIdOrAllDevices::DeviceId(target_device_id) => services().users.add_to_device_event(
-                    sender_user,
-                    target_user_id,
-                    &target_device_id,
-                    &body.event_type,
-                    event.deserialize_as().map_err(|_| {
-                        Error::BadRequest(ErrorKind::InvalidParam, "Event is invalid")
-                    })?,
-                )?,
+                DeviceIdOrAllDevices::DeviceId(target_device_id) => {
+                    services().users.add_to_device_event(
+                        sender_user,
+                        target_user_id,
+                        &target_device_id,
+                        &body.event_type,
+                        event.deserialize_as().map_err(|_| {
+                            Error::BadRequest(ErrorKind::InvalidParam, "Event is invalid")
+                        })?,
+                    )?
+                }
 
                 DeviceIdOrAllDevices::AllDevices => {
                     for target_device_id in services().users.all_device_ids(target_user_id) {
@@ -82,7 +84,8 @@ pub async fn send_event_to_device_route(
     }
 
     // Save transaction id with empty data
-    services().transaction_ids
+    services()
+        .transaction_ids
         .add_txnid(sender_user, sender_device, &body.txn_id, &[])?;
 
     Ok(send_event_to_device::v3::Response {})

src/api/client_server/typing.rs

@@ -1,4 +1,4 @@
-use crate::{utils, Error, Result, Ruma, services};
+use crate::{services, utils, Error, Result, Ruma};
 use ruma::api::client::{error::ErrorKind, typing::create_typing_event};
 
 /// # `PUT /_matrix/client/r0/rooms/{roomId}/typing/{userId}`
@@ -11,7 +11,11 @@ pub async fn create_typing_event_route(
 
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .is_joined(sender_user, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "You are not in this room.",
@@ -25,8 +29,10 @@ pub async fn create_typing_event_route(
             duration.as_millis() as u64 + utils::millis_since_unix_epoch(),
         )?;
     } else {
-        services().rooms
-            .edus.typing
+        services()
+            .rooms
+            .edus
+            .typing
             .typing_remove(sender_user, &body.room_id)?;
     }
 

src/api/client_server/user_directory.rs

@@ -1,4 +1,4 @@
-use crate::{Result, Ruma, services};
+use crate::{services, Result, Ruma};
 use ruma::{
     api::client::user_directory::search_users,
     events::{
@@ -48,22 +48,25 @@ pub async fn search_users_route(
             return None;
         }
 
-        let user_is_in_public_rooms =
-            services().rooms
-                .state_cache.rooms_joined(&user_id)
-                .filter_map(|r| r.ok())
-                .any(|room| {
-                    services().rooms
-                        .state_accessor.room_state_get(&room, &StateEventType::RoomJoinRules, "")
-                        .map_or(false, |event| {
-                            event.map_or(false, |event| {
-                                serde_json::from_str(event.content.get())
-                                    .map_or(false, |r: RoomJoinRulesEventContent| {
-                                        r.join_rule == JoinRule::Public
-                                    })
-                            })
+        let user_is_in_public_rooms = services()
+            .rooms
+            .state_cache
+            .rooms_joined(&user_id)
+            .filter_map(|r| r.ok())
+            .any(|room| {
+                services()
+                    .rooms
+                    .state_accessor
+                    .room_state_get(&room, &StateEventType::RoomJoinRules, "")
+                    .map_or(false, |event| {
+                        event.map_or(false, |event| {
+                            serde_json::from_str(event.content.get())
+                                .map_or(false, |r: RoomJoinRulesEventContent| {
+                                    r.join_rule == JoinRule::Public
+                                })
                         })
-                });
+                    })
+            });
 
         if user_is_in_public_rooms {
             return Some(user);
@@ -71,7 +74,8 @@ pub async fn search_users_route(
 
         let user_is_in_shared_rooms = services()
             .rooms
-            .user.get_shared_rooms(vec![sender_user.clone(), user_id.clone()])
+            .user
+            .get_shared_rooms(vec![sender_user.clone(), user_id.clone()])
             .ok()?
             .next()
             .is_some();

src/api/client_server/voip.rs

@@ -1,4 +1,4 @@
-use crate::{Result, Ruma, services};
+use crate::{services, Result, Ruma};
 use hmac::{Hmac, Mac, NewMac};
 use ruma::{api::client::voip::get_turn_server_info, SecondsSinceUnixEpoch};
 use sha1::Sha1;

src/api/mod.rs

@@ -1,4 +1,4 @@
-pub mod client_server;
-pub mod server_server;
 pub mod appservice_server;
+pub mod client_server;
 pub mod ruma_wrapper;
+pub mod server_server;

src/api/ruma_wrapper/axum.rs

@@ -24,7 +24,7 @@ use serde::Deserialize;
 use tracing::{debug, error, warn};
 
 use super::{Ruma, RumaResponse};
-use crate::{Error, Result, api::server_server, services};
+use crate::{api::server_server, services, Error, Result};
 
 #[async_trait]
 impl<T, B> FromRequest<B> for Ruma<T>
@@ -197,11 +197,11 @@ where
                             request_map.insert("content".to_owned(), json_body.clone());
                         };
 
-                        let keys_result = services().rooms.event_handler.fetch_signing_keys(
-                            &x_matrix.origin,
-                            vec![x_matrix.key.to_owned()],
-                        )
-                        .await;
+                        let keys_result = services()
+                            .rooms
+                            .event_handler
+                            .fetch_signing_keys(&x_matrix.origin, vec![x_matrix.key.to_owned()])
+                            .await;
 
                         let keys = match keys_result {
                             Ok(b) => b,

src/api/server_server.rs

@@ -1,6 +1,7 @@
 use crate::{
     api::client_server::{self, claim_keys_helper, get_keys_helper},
-    utils, Error, PduEvent, Result, Ruma, services, service::pdu::{gen_event_id_canonical_json, PduBuilder},
+    service::pdu::{gen_event_id_canonical_json, PduBuilder},
+    services, utils, Error, PduEvent, Result, Ruma,
 };
 use axum::{response::IntoResponse, Json};
 use futures_util::{stream::FuturesUnordered, StreamExt};
@@ -138,7 +139,8 @@ where
 
     let mut write_destination_to_cache = false;
 
-    let cached_result = services().globals
+    let cached_result = services()
+        .globals
         .actual_destination_cache
         .read()
         .unwrap()
@@ -191,7 +193,10 @@ where
             .to_string()
             .into(),
     );
-    request_map.insert("origin".to_owned(), services().globals.server_name().as_str().into());
+    request_map.insert(
+        "origin".to_owned(),
+        services().globals.server_name().as_str().into(),
+    );
     request_map.insert("destination".to_owned(), destination.as_str().into());
 
     let mut request_json =
@@ -238,7 +243,11 @@ where
 
     let url = reqwest_request.url().clone();
 
-    let response = services().globals.federation_client().execute(reqwest_request).await;
+    let response = services()
+        .globals
+        .federation_client()
+        .execute(reqwest_request)
+        .await;
 
     match response {
         Ok(mut response) => {
@@ -278,10 +287,15 @@ where
             if status == 200 {
                 let response = T::IncomingResponse::try_from_http_response(http_response);
                 if response.is_ok() && write_destination_to_cache {
-                    services().globals.actual_destination_cache.write().unwrap().insert(
-                        Box::<ServerName>::from(destination),
-                        (actual_destination, host),
-                    );
+                    services()
+                        .globals
+                        .actual_destination_cache
+                        .write()
+                        .unwrap()
+                        .insert(
+                            Box::<ServerName>::from(destination),
+                            (actual_destination, host),
+                        );
                 }
 
                 response.map_err(|e| {
@@ -329,9 +343,7 @@ fn add_port_to_hostname(destination_str: &str) -> FedDest {
 /// Returns: actual_destination, host header
 /// Implemented according to the specification at https://matrix.org/docs/spec/server_server/r0.1.4#resolving-server-names
 /// Numbers in comments below refer to bullet points in linked section of specification
-async fn find_actual_destination(
-    destination: &'_ ServerName,
-) -> (FedDest, FedDest) {
+async fn find_actual_destination(destination: &'_ ServerName) -> (FedDest, FedDest) {
     let destination_str = destination.as_str().to_owned();
     let mut hostname = destination_str.clone();
     let actual_destination = match get_ip_with_port(&destination_str) {
@@ -364,18 +376,24 @@ async fn find_actual_destination(
                                         // 3.3: SRV lookup successful
                                         let force_port = hostname_override.port();
 
-                                        if let Ok(override_ip) = services().globals
+                                        if let Ok(override_ip) = services()
+                                            .globals
                                             .dns_resolver()
                                             .lookup_ip(hostname_override.hostname())
                                             .await
                                         {
-                                            services().globals.tls_name_override.write().unwrap().insert(
-                                                delegated_hostname.clone(),
-                                                (
-                                                    override_ip.iter().collect(),
-                                                    force_port.unwrap_or(8448),
-                                                ),
-                                            );
+                                            services()
+                                                .globals
+                                                .tls_name_override
+                                                .write()
+                                                .unwrap()
+                                                .insert(
+                                                    delegated_hostname.clone(),
+                                                    (
+                                                        override_ip.iter().collect(),
+                                                        force_port.unwrap_or(8448),
+                                                    ),
+                                                );
                                         } else {
                                             warn!("Using SRV record, but could not resolve to IP");
                                         }
@@ -400,15 +418,24 @@ async fn find_actual_destination(
                             Some(hostname_override) => {
                                 let force_port = hostname_override.port();
 
-                                if let Ok(override_ip) = services().globals
+                                if let Ok(override_ip) = services()
+                                    .globals
                                     .dns_resolver()
                                     .lookup_ip(hostname_override.hostname())
                                     .await
                                 {
-                                    services().globals.tls_name_override.write().unwrap().insert(
-                                        hostname.clone(),
-                                        (override_ip.iter().collect(), force_port.unwrap_or(8448)),
-                                    );
+                                    services()
+                                        .globals
+                                        .tls_name_override
+                                        .write()
+                                        .unwrap()
+                                        .insert(
+                                            hostname.clone(),
+                                            (
+                                                override_ip.iter().collect(),
+                                                force_port.unwrap_or(8448),
+                                            ),
+                                        );
                                 } else {
                                     warn!("Using SRV record, but could not resolve to IP");
                                 }
@@ -443,10 +470,9 @@ async fn find_actual_destination(
     (actual_destination, hostname)
 }
 
-async fn query_srv_record(
-    hostname: &'_ str,
-) -> Option<FedDest> {
-    if let Ok(Some(host_port)) = services().globals
+async fn query_srv_record(hostname: &'_ str) -> Option<FedDest> {
+    if let Ok(Some(host_port)) = services()
+        .globals
         .dns_resolver()
         .srv_lookup(format!("_matrix._tcp.{}", hostname))
         .await
@@ -465,11 +491,10 @@ async fn query_srv_record(
     }
 }
 
-async fn request_well_known(
-    destination: &str,
-) -> Option<String> {
+async fn request_well_known(destination: &str) -> Option<String> {
     let body: serde_json::Value = serde_json::from_str(
-        &services().globals
+        &services()
+            .globals
             .default_client()
             .get(&format!(
                 "https://{}/.well-known/matrix/server",
@@ -664,15 +689,22 @@ pub async fn send_transaction_message_route(
             Some(id) => id,
             None => {
                 // Event is invalid
-                resolved_map.insert(event_id, Err(Error::bad_database("Event needs a valid RoomId.")));
+                resolved_map.insert(
+                    event_id,
+                    Err(Error::bad_database("Event needs a valid RoomId.")),
+                );
                 continue;
             }
         };
 
-        services().rooms.event_handler.acl_check(&sender_servername, &room_id)?;
+        services()
+            .rooms
+            .event_handler
+            .acl_check(&sender_servername, &room_id)?;
 
         let mutex = Arc::clone(
-            services().globals
+            services()
+                .globals
                 .roomid_mutex_federation
                 .write()
                 .unwrap()
@@ -683,16 +715,19 @@ pub async fn send_transaction_message_route(
         let start_time = Instant::now();
         resolved_map.insert(
             event_id.clone(),
-            services().rooms.event_handler.handle_incoming_pdu(
-                &sender_servername,
-                &event_id,
-                &room_id,
-                value,
-                true,
-                &pub_key_map,
-            )
-            .await
-            .map(|_| ()),
+            services()
+                .rooms
+                .event_handler
+                .handle_incoming_pdu(
+                    &sender_servername,
+                    &event_id,
+                    &room_id,
+                    value,
+                    true,
+                    &pub_key_map,
+                )
+                .await
+                .map(|_| ()),
         );
         drop(mutex_lock);
 
@@ -727,7 +762,13 @@ pub async fn send_transaction_message_route(
                             .event_ids
                             .iter()
                             .filter_map(|id| {
-                                services().rooms.timeline.get_pdu_count(id).ok().flatten().map(|r| (id, r))
+                                services()
+                                    .rooms
+                                    .timeline
+                                    .get_pdu_count(id)
+                                    .ok()
+                                    .flatten()
+                                    .map(|r| (id, r))
                             })
                             .max_by_key(|(_, count)| *count)
                         {
@@ -744,11 +785,11 @@ pub async fn send_transaction_message_route(
                                 content: ReceiptEventContent(receipt_content),
                                 room_id: room_id.clone(),
                             };
-                            services().rooms.edus.read_receipt.readreceipt_update(
-                                &user_id,
-                                &room_id,
-                                event,
-                            )?;
+                            services()
+                                .rooms
+                                .edus
+                                .read_receipt
+                                .readreceipt_update(&user_id, &room_id, event)?;
                         } else {
                             // TODO fetch missing events
                             info!("No known event ids in read receipt: {:?}", user_updates);
@@ -757,7 +798,11 @@ pub async fn send_transaction_message_route(
                 }
             }
             Edu::Typing(typing) => {
-                if services().rooms.state_cache.is_joined(&typing.user_id, &typing.room_id)? {
+                if services()
+                    .rooms
+                    .state_cache
+                    .is_joined(&typing.user_id, &typing.room_id)?
+                {
                     if typing.typing {
                         services().rooms.edus.typing.typing_add(
                             &typing.user_id,
@@ -765,16 +810,16 @@ pub async fn send_transaction_message_route(
                             3000 + utils::millis_since_unix_epoch(),
                         )?;
                     } else {
-                        services().rooms.edus.typing.typing_remove(
-                            &typing.user_id,
-                            &typing.room_id,
-                        )?;
+                        services()
+                            .rooms
+                            .edus
+                            .typing
+                            .typing_remove(&typing.user_id, &typing.room_id)?;
                     }
                 }
             }
             Edu::DeviceListUpdate(DeviceListUpdateContent { user_id, .. }) => {
-                services().users
-                    .mark_device_key_update(&user_id)?;
+                services().users.mark_device_key_update(&user_id)?;
             }
             Edu::DirectToDevice(DirectDeviceContent {
                 sender,
@@ -810,7 +855,9 @@ pub async fn send_transaction_message_route(
                             }
 
                             DeviceIdOrAllDevices::AllDevices => {
-                                for target_device_id in services().users.all_device_ids(target_user_id) {
+                                for target_device_id in
+                                    services().users.all_device_ids(target_user_id)
+                                {
                                     services().users.add_to_device_event(
                                         &sender,
                                         target_user_id,
@@ -830,7 +877,8 @@ pub async fn send_transaction_message_route(
                 }
 
                 // Save transaction id with empty data
-                services().transaction_ids
+                services()
+                    .transaction_ids
                     .add_txnid(&sender, None, &message_id, &[])?;
             }
             Edu::SigningKeyUpdate(SigningKeyUpdateContent {
@@ -854,7 +902,12 @@ pub async fn send_transaction_message_route(
         }
     }
 
-    Ok(send_transaction_message::v1::Response { pdus: resolved_map.into_iter().map(|(e, r)| (e, r.map_err(|e| e.to_string()))).collect() })
+    Ok(send_transaction_message::v1::Response {
+        pdus: resolved_map
+            .into_iter()
+            .map(|(e, r)| (e, r.map_err(|e| e.to_string())))
+            .collect(),
+    })
 }
 
 /// # `GET /_matrix/federation/v1/event/{eventId}`
@@ -875,7 +928,8 @@ pub async fn get_event_route(
         .expect("server is authenticated");
 
     let event = services()
-        .rooms.timeline
+        .rooms
+        .timeline
         .get_pdu_json(&body.event_id)?
         .ok_or(Error::BadRequest(ErrorKind::NotFound, "Event not found."))?;
 
@@ -887,7 +941,11 @@ pub async fn get_event_route(
     let room_id = <&RoomId>::try_from(room_id_str)
         .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;
 
-    if !services().rooms.state_cache.server_in_room(sender_servername, room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .server_in_room(sender_servername, room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "Server is not in room",
@@ -916,14 +974,21 @@ pub async fn get_missing_events_route(
         .as_ref()
         .expect("server is authenticated");
 
-    if !services().rooms.state_cache.server_in_room(sender_servername, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .server_in_room(sender_servername, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "Server is not in room",
         ));
     }
 
-    services().rooms.event_handler.acl_check(&sender_servername, &body.room_id)?;
+    services()
+        .rooms
+        .event_handler
+        .acl_check(&sender_servername, &body.room_id)?;
 
     let mut queued_events = body.latest_events.clone();
     let mut events = Vec::new();
@@ -988,17 +1053,25 @@ pub async fn get_event_authorization_route(
         .as_ref()
         .expect("server is authenticated");
 
-    if !services().rooms.state_cache.server_in_room(sender_servername, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .server_in_room(sender_servername, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "Server is not in room.",
         ));
     }
 
-    services().rooms.event_handler.acl_check(&sender_servername, &body.room_id)?;
+    services()
+        .rooms
+        .event_handler
+        .acl_check(&sender_servername, &body.room_id)?;
 
     let event = services()
-        .rooms.timeline
+        .rooms
+        .timeline
         .get_pdu_json(&body.event_id)?
         .ok_or(Error::BadRequest(ErrorKind::NotFound, "Event not found."))?;
 
@@ -1010,7 +1083,11 @@ pub async fn get_event_authorization_route(
     let room_id = <&RoomId>::try_from(room_id_str)
         .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;
 
-    let auth_chain_ids = services().rooms.auth_chain.get_auth_chain(room_id, vec![Arc::from(&*body.event_id)]).await?;
+    let auth_chain_ids = services()
+        .rooms
+        .auth_chain
+        .get_auth_chain(room_id, vec![Arc::from(&*body.event_id)])
+        .await?;
 
     Ok(get_event_authorization::v1::Response {
         auth_chain: auth_chain_ids
@@ -1035,17 +1112,25 @@ pub async fn get_room_state_route(
         .as_ref()
         .expect("server is authenticated");
 
-    if !services().rooms.state_cache.server_in_room(sender_servername, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .server_in_room(sender_servername, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "Server is not in room.",
         ));
     }
 
-    services().rooms.event_handler.acl_check(&sender_servername, &body.room_id)?;
+    services()
+        .rooms
+        .event_handler
+        .acl_check(&sender_servername, &body.room_id)?;
 
     let shortstatehash = services()
-        .rooms.state_accessor
+        .rooms
+        .state_accessor
         .pdu_shortstatehash(&body.event_id)?
         .ok_or(Error::BadRequest(
             ErrorKind::NotFound,
@@ -1053,26 +1138,39 @@ pub async fn get_room_state_route(
         ))?;
 
     let pdus = services()
-        .rooms.state_accessor
+        .rooms
+        .state_accessor
         .state_full_ids(shortstatehash)
         .await?
         .into_iter()
         .map(|(_, id)| {
             PduEvent::convert_to_outgoing_federation_event(
-                services().rooms.timeline.get_pdu_json(&id).unwrap().unwrap(),
+                services()
+                    .rooms
+                    .timeline
+                    .get_pdu_json(&id)
+                    .unwrap()
+                    .unwrap(),
             )
         })
         .collect();
 
-    let auth_chain_ids =
-        services().rooms.auth_chain.get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)]).await?;
+    let auth_chain_ids = services()
+        .rooms
+        .auth_chain
+        .get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)])
+        .await?;
 
     Ok(get_room_state::v1::Response {
         auth_chain: auth_chain_ids
             .map(|id| {
-                services().rooms.timeline.get_pdu_json(&id).map(|maybe_json| {
-                    PduEvent::convert_to_outgoing_federation_event(maybe_json.unwrap())
-                })
+                services()
+                    .rooms
+                    .timeline
+                    .get_pdu_json(&id)
+                    .map(|maybe_json| {
+                        PduEvent::convert_to_outgoing_federation_event(maybe_json.unwrap())
+                    })
             })
             .filter_map(|r| r.ok())
             .collect(),
@@ -1095,17 +1193,25 @@ pub async fn get_room_state_ids_route(
         .as_ref()
         .expect("server is authenticated");
 
-    if !services().rooms.state_cache.server_in_room(sender_servername, &body.room_id)? {
+    if !services()
+        .rooms
+        .state_cache
+        .server_in_room(sender_servername, &body.room_id)?
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "Server is not in room.",
         ));
     }
 
-    services().rooms.event_handler.acl_check(&sender_servername, &body.room_id)?;
+    services()
+        .rooms
+        .event_handler
+        .acl_check(&sender_servername, &body.room_id)?;
 
     let shortstatehash = services()
-        .rooms.state_accessor
+        .rooms
+        .state_accessor
         .pdu_shortstatehash(&body.event_id)?
         .ok_or(Error::BadRequest(
             ErrorKind::NotFound,
@@ -1113,15 +1219,19 @@ pub async fn get_room_state_ids_route(
         ))?;
 
     let pdu_ids = services()
-        .rooms.state_accessor
+        .rooms
+        .state_accessor
         .state_full_ids(shortstatehash)
         .await?
         .into_iter()
         .map(|(_, id)| (*id).to_owned())
         .collect();
 
-    let auth_chain_ids =
-        services().rooms.auth_chain.get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)]).await?;
+    let auth_chain_ids = services()
+        .rooms
+        .auth_chain
+        .get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)])
+        .await?;
 
     Ok(get_room_state_ids::v1::Response {
         auth_chain_ids: auth_chain_ids.map(|id| (*id).to_owned()).collect(),
@@ -1151,10 +1261,14 @@ pub async fn create_join_event_template_route(
         .as_ref()
         .expect("server is authenticated");
 
-    services().rooms.event_handler.acl_check(&sender_servername, &body.room_id)?;
+    services()
+        .rooms
+        .event_handler
+        .acl_check(&sender_servername, &body.room_id)?;
 
     let mutex_state = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_state
             .write()
             .unwrap()
@@ -1164,9 +1278,11 @@ pub async fn create_join_event_template_route(
     let state_lock = mutex_state.lock().await;
 
     // TODO: Conduit does not implement restricted join rules yet, we always reject
-    let join_rules_event =
-        services().rooms.state_accessor
-            .room_state_get(&body.room_id, &StateEventType::RoomJoinRules, "")?;
+    let join_rules_event = services().rooms.state_accessor.room_state_get(
+        &body.room_id,
+        &StateEventType::RoomJoinRules,
+        "",
+    )?;
 
     let join_rules_event_content: Option<RoomJoinRulesEventContent> = join_rules_event
         .as_ref()
@@ -1212,13 +1328,18 @@ pub async fn create_join_event_template_route(
     })
     .expect("member event is valid value");
 
-    let (pdu, pdu_json) = services().rooms.timeline.create_hash_and_sign_event(PduBuilder {
-        event_type: RoomEventType::RoomMember,
-        content,
-        unsigned: None,
-        state_key: Some(body.user_id.to_string()),
-        redacts: None,
-    }, &body.user_id, &body.room_id, &state_lock)?;
+    let (pdu, pdu_json) = services().rooms.timeline.create_hash_and_sign_event(
+        PduBuilder {
+            event_type: RoomEventType::RoomMember,
+            content,
+            unsigned: None,
+            state_key: Some(body.user_id.to_string()),
+            redacts: None,
+        },
+        &body.user_id,
+        &body.room_id,
+        &state_lock,
+    )?;
 
     drop(state_lock);
 
@@ -1244,12 +1365,17 @@ async fn create_join_event(
         ));
     }
 
-    services().rooms.event_handler.acl_check(&sender_servername, room_id)?;
+    services()
+        .rooms
+        .event_handler
+        .acl_check(&sender_servername, room_id)?;
 
     // TODO: Conduit does not implement restricted join rules yet, we always reject
-    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 join_rules_event_content: Option<RoomJoinRulesEventContent> = join_rules_event
         .as_ref()
@@ -1275,7 +1401,8 @@ async fn create_join_event(
 
     // We need to return the state prior to joining, let's keep a reference to that here
     let shortstatehash = services()
-        .rooms.state
+        .rooms
+        .state
         .get_room_shortstatehash(room_id)?
         .ok_or(Error::BadRequest(
             ErrorKind::NotFound,
@@ -1307,7 +1434,8 @@ async fn create_join_event(
     .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Origin field is invalid."))?;
 
     let mutex = Arc::clone(
-        services().globals
+        services()
+            .globals
             .roomid_mutex_federation
             .write()
             .unwrap()
@@ -1315,7 +1443,10 @@ async fn create_join_event(
             .or_default(),
     );
     let mutex_lock = mutex.lock().await;
-    let pdu_id: Vec<u8> = services().rooms.event_handler.handle_incoming_pdu(&origin, &event_id, room_id, value, true, &pub_key_map)
+    let pdu_id: Vec<u8> = services()
+        .rooms
+        .event_handler
+        .handle_incoming_pdu(&origin, &event_id, room_id, value, true, &pub_key_map)
         .await?
         .ok_or(Error::BadRequest(
             ErrorKind::InvalidParam,
@@ -1323,12 +1454,19 @@ async fn create_join_event(
         ))?;
     drop(mutex_lock);
 
-    let state_ids = services().rooms.state_accessor.state_full_ids(shortstatehash).await?;
-    let auth_chain_ids = services().rooms.auth_chain.get_auth_chain(
-        room_id,
-        state_ids.iter().map(|(_, id)| id.clone()).collect(),
-    )
-    .await?;
+    let state_ids = services()
+        .rooms
+        .state_accessor
+        .state_full_ids(shortstatehash)
+        .await?;
+    let auth_chain_ids = services()
+        .rooms
+        .auth_chain
+        .get_auth_chain(
+            room_id,
+            state_ids.iter().map(|(_, id)| id.clone()).collect(),
+        )
+        .await?;
 
     let servers = services()
         .rooms
@@ -1399,9 +1537,16 @@ pub async fn create_invite_route(
         .as_ref()
         .expect("server is authenticated");
 
-    services().rooms.event_handler.acl_check(&sender_servername, &body.room_id)?;
+    services()
+        .rooms
+        .event_handler
+        .acl_check(&sender_servername, &body.room_id)?;
 
-    if !services().globals.supported_room_versions().contains(&body.room_version) {
+    if !services()
+        .globals
+        .supported_room_versions()
+        .contains(&body.room_version)
+    {
         return Err(Error::BadRequest(
             ErrorKind::IncompatibleRoomVersion {
                 room_version: body.room_version.clone(),
@@ -1549,7 +1694,8 @@ pub async fn get_room_information_route(
 
     let room_id = services()
         .rooms
-        .alias.resolve_local_alias(&body.room_alias)?
+        .alias
+        .resolve_local_alias(&body.room_alias)?
         .ok_or(Error::BadRequest(
             ErrorKind::NotFound,
             "Room alias not found.",
@@ -1576,7 +1722,9 @@ pub async fn get_profile_information_route(
     let mut blurhash = None;
 
     match &body.field {
-        Some(ProfileField::DisplayName) => displayname = services().users.displayname(&body.user_id)?,
+        Some(ProfileField::DisplayName) => {
+            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)?
@@ -1600,18 +1748,14 @@ pub async fn get_profile_information_route(
 /// # `POST /_matrix/federation/v1/user/keys/query`
 ///
 /// Gets devices and identity keys for the given users.
-pub async fn get_keys_route(
-    body: Ruma<get_keys::v1::Request>,
-) -> Result<get_keys::v1::Response> {
+pub async fn get_keys_route(body: Ruma<get_keys::v1::Request>) -> Result<get_keys::v1::Response> {
     if !services().globals.allow_federation() {
         return Err(Error::bad_config("Federation is disabled."));
     }
 
-    let result = get_keys_helper(
-        None,
-        &body.device_keys,
-        |u| Some(u.server_name()) == body.sender_servername.as_deref(),
-    )
+    let result = get_keys_helper(None, &body.device_keys, |u| {
+        Some(u.server_name()) == body.sender_servername.as_deref()
+    })
     .await?;
 
     Ok(get_keys::v1::Response {