From 76509830e64af509f63b288709b9bf5637a67c41 Mon Sep 17 00:00:00 2001 From: Jason Volk Date: Tue, 22 Apr 2025 04:42:26 +0000 Subject: [PATCH] chain_width to 50 Signed-off-by: Jason Volk --- rustfmt.toml | 2 +- src/admin/check/commands.rs | 7 +- src/admin/context.rs | 10 +- src/admin/debug/commands.rs | 128 ++++++++--- src/admin/federation/commands.rs | 10 +- src/admin/media/commands.rs | 22 +- src/admin/processor.rs | 18 +- src/admin/query/appservice.rs | 11 +- src/admin/query/globals.rs | 5 +- src/admin/query/raw.rs | 17 +- src/admin/query/resolver.rs | 7 +- src/admin/query/room_alias.rs | 6 +- src/admin/query/room_state_cache.rs | 6 +- src/admin/query/room_timeline.rs | 14 +- src/admin/query/sending.rs | 6 +- src/admin/query/short.rs | 14 +- src/admin/query/users.rs | 32 ++- src/admin/room/alias.rs | 44 +++- src/admin/room/commands.rs | 23 +- src/admin/room/moderation.rs | 60 ++++- src/admin/user/commands.rs | 74 ++++++- src/api/client/account.rs | 100 +++++++-- src/api/client/alias.rs | 16 +- src/api/client/capabilities.rs | 6 +- src/api/client/context.rs | 21 +- src/api/client/device.rs | 24 +- src/api/client/directory.rs | 74 +++++-- src/api/client/filter.rs | 14 +- src/api/client/keys.rs | 46 +++- src/api/client/media.rs | 25 ++- src/api/client/media_legacy.rs | 19 +- src/api/client/membership.rs | 207 ++++++++++++++---- src/api/client/message.rs | 10 +- src/api/client/openid.rs | 5 +- src/api/client/presence.rs | 6 +- src/api/client/profile.rs | 46 +++- src/api/client/push.rs | 82 +++++-- src/api/client/redact.rs | 12 +- src/api/client/report.rs | 23 +- src/api/client/room/aliases.rs | 5 +- src/api/client/room/create.rs | 86 ++++++-- src/api/client/room/initial_sync.rs | 13 +- src/api/client/room/summary.rs | 62 ++++-- src/api/client/room/upgrade.rs | 24 +- src/api/client/search.rs | 15 +- src/api/client/send.rs | 13 +- src/api/client/session.rs | 34 ++- src/api/client/state.rs | 5 +- src/api/client/sync/mod.rs | 6 +- src/api/client/sync/v3.rs | 64 ++++-- src/api/client/sync/v4.rs | 102 +++++++-- src/api/client/sync/v5.rs | 75 +++++-- src/api/client/tag.rs | 20 +- src/api/client/to_device.rs | 5 +- src/api/client/typing.rs | 5 +- src/api/client/unstable.rs | 24 +- src/api/client/user_directory.rs | 7 +- src/api/client/well_known.rs | 21 +- src/api/router/args.rs | 8 +- src/api/router/auth.rs | 6 +- src/api/router/response.rs | 6 +- src/api/server/event_auth.rs | 15 +- src/api/server/get_missing_events.rs | 7 +- src/api/server/hierarchy.rs | 18 +- src/api/server/invite.rs | 17 +- src/api/server/key.rs | 5 +- src/api/server/make_join.rs | 34 ++- src/api/server/make_knock.rs | 20 +- src/api/server/make_leave.rs | 20 +- src/api/server/query.rs | 29 ++- src/api/server/send.rs | 18 +- src/api/server/send_join.rs | 17 +- src/api/server/send_knock.rs | 13 +- src/api/server/send_leave.rs | 6 +- src/api/server/utils.rs | 9 +- src/core/alloc/je.rs | 6 +- src/core/config/check.rs | 19 +- src/core/config/mod.rs | 8 +- src/core/config/proxy.rs | 5 +- src/core/debug.rs | 4 +- src/core/error/mod.rs | 4 +- src/core/error/response.rs | 6 +- src/core/info/cargo.rs | 5 +- src/core/info/room_version.rs | 3 +- src/core/log/capture/data.rs | 13 +- src/core/log/console.rs | 6 +- src/core/log/reload.rs | 4 +- src/core/matrix/pdu/filter.rs | 6 +- src/core/matrix/pdu/raw_id.rs | 6 +- src/core/matrix/pdu/unsigned.rs | 3 +- src/core/matrix/state_res/event_auth.rs | 122 ++++++++--- src/core/matrix/state_res/mod.rs | 98 +++++++-- src/core/matrix/state_res/test_utils.rs | 26 ++- src/core/metrics/mod.rs | 4 +- src/core/mods/path.rs | 5 +- src/core/utils/bytes.rs | 4 +- src/core/utils/mutex_map.rs | 8 +- src/core/utils/result/unwrap_infallible.rs | 5 +- src/core/utils/set.rs | 6 +- src/core/utils/stream/try_parallel.rs | 6 +- src/core/utils/string/unquote.rs | 3 +- src/core/utils/sys.rs | 6 +- src/core/utils/sys/compute.rs | 20 +- src/core/utils/sys/storage.rs | 11 +- src/database/engine.rs | 6 +- src/database/engine/backup.rs | 4 +- src/database/engine/cf_opts.rs | 3 +- src/database/engine/open.rs | 4 +- src/database/map/clear.rs | 5 +- src/database/map/get.rs | 4 +- src/database/map/get_batch.rs | 6 +- src/database/map/keys.rs | 3 +- src/database/map/keys_from.rs | 6 +- src/database/map/rev_keys.rs | 3 +- src/database/map/stream.rs | 3 +- src/database/map/stream_from.rs | 6 +- src/database/pool.rs | 13 +- src/database/pool/configure.rs | 17 +- src/database/watchers.rs | 10 +- src/macros/admin.rs | 11 +- src/macros/config.rs | 7 +- src/macros/utils.rs | 7 +- src/main/mods.rs | 10 +- src/main/runtime.rs | 6 +- src/main/sentry.rs | 4 +- src/router/request.rs | 4 +- src/router/serve/plain.rs | 13 +- src/service/account_data/mod.rs | 16 +- src/service/admin/console.rs | 18 +- src/service/admin/execute.rs | 27 ++- src/service/admin/grant.rs | 23 +- src/service/admin/mod.rs | 25 ++- src/service/appservice/mod.rs | 4 +- src/service/emergency/mod.rs | 19 +- src/service/federation/execute.rs | 9 +- src/service/globals/mod.rs | 20 +- src/service/key_backups/mod.rs | 32 ++- src/service/media/mod.rs | 6 +- src/service/media/preview.rs | 48 +++- src/service/media/remote.rs | 34 ++- src/service/media/thumbnail.rs | 10 +- src/service/migrations.rs | 41 +++- src/service/presence/data.rs | 12 +- src/service/presence/mod.rs | 19 +- src/service/pusher/mod.rs | 31 ++- src/service/resolver/actual.rs | 48 ++-- src/service/resolver/dns.rs | 14 +- src/service/rooms/alias/mod.rs | 16 +- src/service/rooms/auth_chain/mod.rs | 22 +- src/service/rooms/event_handler/acl_check.rs | 8 +- .../event_handler/handle_incoming_pdu.rs | 6 +- src/service/rooms/event_handler/mod.rs | 6 +- .../rooms/event_handler/resolve_state.rs | 6 +- .../event_handler/upgrade_outlier_pdu.rs | 16 +- src/service/rooms/lazy_loading/mod.rs | 4 +- src/service/rooms/outlier/mod.rs | 4 +- src/service/rooms/pdu_metadata/data.rs | 31 ++- src/service/rooms/pdu_metadata/mod.rs | 4 +- src/service/rooms/read_receipt/data.rs | 11 +- src/service/rooms/read_receipt/mod.rs | 38 +++- src/service/rooms/search/mod.rs | 10 +- src/service/rooms/short/mod.rs | 11 +- src/service/rooms/spaces/mod.rs | 100 +++++++-- src/service/rooms/state/mod.rs | 47 ++-- .../rooms/state_accessor/room_state.rs | 6 +- src/service/rooms/state_accessor/state.rs | 24 +- src/service/rooms/state_accessor/user_can.rs | 24 +- src/service/rooms/state_cache/mod.rs | 111 ++++++++-- src/service/rooms/state_compressor/mod.rs | 56 +++-- src/service/rooms/threads/mod.rs | 19 +- src/service/rooms/timeline/data.rs | 10 +- src/service/rooms/timeline/mod.rs | 137 +++++++++--- src/service/rooms/typing/mod.rs | 29 ++- src/service/rooms/user/mod.rs | 14 +- src/service/sending/appservice.rs | 18 +- src/service/sending/data.rs | 15 +- src/service/sending/dest.rs | 5 +- src/service/sending/mod.rs | 32 ++- src/service/sending/sender.rs | 86 ++++++-- src/service/server_keys/acquire.rs | 30 ++- src/service/server_keys/get.rs | 27 ++- src/service/server_keys/mod.rs | 13 +- src/service/server_keys/request.rs | 7 +- src/service/server_keys/verify.rs | 15 +- src/service/services.rs | 10 +- src/service/sync/mod.rs | 15 +- src/service/sync/watch.rs | 41 +++- src/service/transaction_ids/mod.rs | 10 +- src/service/uiaa/mod.rs | 38 +++- src/service/users/mod.rs | 148 ++++++++++--- 190 files changed, 3469 insertions(+), 930 deletions(-) diff --git a/rustfmt.toml b/rustfmt.toml index 89041b04..6ea1ba64 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -1,5 +1,5 @@ array_width = 80 -chain_width = 60 +chain_width = 50 comment_width = 80 condense_wildcard_suffixes = true style_edition = "2024" diff --git a/src/admin/check/commands.rs b/src/admin/check/commands.rs index d111c7cc..8e874309 100644 --- a/src/admin/check/commands.rs +++ b/src/admin/check/commands.rs @@ -10,7 +10,12 @@ use crate::Context; #[implement(Context, params = "<'_>")] pub(super) async fn check_all_users(&self) -> Result { let timer = tokio::time::Instant::now(); - let users = self.services.users.iter().collect::>().await; + let users = self + .services + .users + .iter() + .collect::>() + .await; let query_time = timer.elapsed(); let total = users.len(); diff --git a/src/admin/context.rs b/src/admin/context.rs index b141e1eb..e754cd54 100644 --- a/src/admin/context.rs +++ b/src/admin/context.rs @@ -24,7 +24,10 @@ impl Context<'_> { ) -> impl Future + Send + '_ + use<'_> { let buf = format!("{arguments}"); self.output.lock().then(async move |mut output| { - output.write_all(buf.as_bytes()).map_err(Into::into).await + output + .write_all(buf.as_bytes()) + .map_err(Into::into) + .await }) } @@ -33,7 +36,10 @@ impl Context<'_> { s: &'a str, ) -> impl Future + Send + 'a { self.output.lock().then(async move |mut output| { - output.write_all(s.as_bytes()).map_err(Into::into).await + output + .write_all(s.as_bytes()) + .map_err(Into::into) + .await }) } } diff --git a/src/admin/debug/commands.rs b/src/admin/debug/commands.rs index 53baa4b3..ca03f128 100644 --- a/src/admin/debug/commands.rs +++ b/src/admin/debug/commands.rs @@ -37,7 +37,13 @@ pub(super) async fn echo(&self, message: Vec) -> Result { #[admin_command] pub(super) async fn get_auth_chain(&self, event_id: OwnedEventId) -> Result { - let Ok(event) = self.services.rooms.timeline.get_pdu_json(&event_id).await else { + let Ok(event) = self + .services + .rooms + .timeline + .get_pdu_json(&event_id) + .await + else { return Err!("Event not found."); }; @@ -103,7 +109,12 @@ pub(super) async fn get_pdu(&self, event_id: OwnedEventId) -> Result { if pdu_json.is_err() { outlier = true; - pdu_json = self.services.rooms.timeline.get_pdu_json(&event_id).await; + pdu_json = self + .services + .rooms + .timeline + .get_pdu_json(&event_id) + .await; } match pdu_json { @@ -361,7 +372,11 @@ pub(super) async fn force_device_list_updates(&self) -> Result { self.services .users .stream() - .for_each(|user_id| self.services.users.mark_device_key_update(user_id)) + .for_each(|user_id| { + self.services + .users + .mark_device_key_update(user_id) + }) .await; write!(self, "Marked all devices for all users as having new keys to update").await @@ -407,7 +422,10 @@ pub(super) async fn change_log_level(&self, filter: Option, reset: bool) .reload .reload(&new_filter_layer, Some(handles)) { - | Ok(()) => return self.write_str("Successfully changed log level").await, + | Ok(()) => + return self + .write_str("Successfully changed log level") + .await, | Err(e) => return Err!("Failed to modify and reload the global tracing log level: {e}"), } @@ -449,7 +467,12 @@ pub(super) async fn verify_json(&self) -> Result { let string = self.body[1..self.body.len().checked_sub(1).unwrap()].join("\n"); match serde_json::from_str::(&string) { | Err(e) => return Err!("Invalid json: {e}"), - | Ok(value) => match self.services.server_keys.verify_json(&value, None).await { + | Ok(value) => match self + .services + .server_keys + .verify_json(&value, None) + .await + { | Err(e) => return Err!("Signature verification failed: {e}"), | Ok(()) => write!(self, "Signature correct"), }, @@ -461,10 +484,20 @@ pub(super) async fn verify_json(&self) -> Result { pub(super) async fn verify_pdu(&self, event_id: OwnedEventId) -> Result { use ruma::signatures::Verified; - let mut event = self.services.rooms.timeline.get_pdu_json(&event_id).await?; + let mut event = self + .services + .rooms + .timeline + .get_pdu_json(&event_id) + .await?; event.remove("event_id"); - let msg = match self.services.server_keys.verify_event(&event, None).await { + let msg = match self + .services + .server_keys + .verify_event(&event, None) + .await + { | Err(e) => return Err(e), | Ok(Verified::Signatures) => "signatures OK, but content hash failed (redaction).", | Ok(Verified::All) => "signatures and hashes OK.", @@ -548,7 +581,12 @@ pub(super) async fn force_set_room_state_from_server( .await .map_err(|_| err!(Database("Failed to find the latest PDU in database")))?; - let room_version = self.services.rooms.state.get_room_version(&room_id).await?; + let room_version = self + .services + .rooms + .state + .get_room_version(&room_id) + .await?; let mut state: HashMap = HashMap::new(); @@ -610,11 +648,14 @@ pub(super) async fn force_set_room_state_from_server( } info!("Going through auth_chain response"); - for result in remote_state_response.auth_chain.iter().map(|pdu| { - self.services - .server_keys - .validate_and_add_event_id(pdu, &room_version) - }) { + for result in remote_state_response + .auth_chain + .iter() + .map(|pdu| { + self.services + .server_keys + .validate_and_add_event_id(pdu, &room_version) + }) { let Ok((event_id, value)) = result.await else { continue; }; @@ -644,7 +685,13 @@ pub(super) async fn force_set_room_state_from_server( .save_state(room_id.clone().as_ref(), new_room_state) .await?; - let state_lock = self.services.rooms.state.mutex.lock(&*room_id).await; + let state_lock = self + .services + .rooms + .state + .mutex + .lock(&*room_id) + .await; self.services .rooms @@ -775,17 +822,22 @@ pub(super) async fn memory_stats(&self, opts: Option) -> Result { #[cfg(tokio_unstable)] #[admin_command] pub(super) async fn runtime_metrics(&self) -> Result { - let out = self.services.server.metrics.runtime_metrics().map_or_else( - || "Runtime metrics are not available.".to_owned(), - |metrics| { - format!( - "```rs\nnum_workers: {}\nnum_alive_tasks: {}\nglobal_queue_depth: {}\n```", - metrics.num_workers(), - metrics.num_alive_tasks(), - metrics.global_queue_depth() - ) - }, - ); + let out = self + .services + .server + .metrics + .runtime_metrics() + .map_or_else( + || "Runtime metrics are not available.".to_owned(), + |metrics| { + format!( + "```rs\nnum_workers: {}\nnum_alive_tasks: {}\nglobal_queue_depth: {}\n```", + metrics.num_workers(), + metrics.num_alive_tasks(), + metrics.global_queue_depth() + ) + }, + ); self.write_str(&out).await } @@ -800,10 +852,15 @@ pub(super) async fn runtime_metrics(&self) -> Result { #[cfg(tokio_unstable)] #[admin_command] pub(super) async fn runtime_interval(&self) -> Result { - let out = self.services.server.metrics.runtime_interval().map_or_else( - || "Runtime metrics are not available.".to_owned(), - |metrics| format!("```rs\n{metrics:#?}\n```"), - ); + let out = self + .services + .server + .metrics + .runtime_interval() + .map_or_else( + || "Runtime metrics are not available.".to_owned(), + |metrics| format!("```rs\n{metrics:#?}\n```"), + ); self.write_str(&out).await } @@ -871,7 +928,12 @@ pub(super) async fn database_stats( #[admin_command] pub(super) async fn database_files(&self, map: Option, level: Option) -> Result { - let mut files: Vec<_> = self.services.db.db.file_list().collect::>()?; + let mut files: Vec<_> = self + .services + .db + .db + .file_list() + .collect::>()?; files.sort_by_key(|f| f.name.clone()); @@ -883,7 +945,11 @@ pub(super) async fn database_files(&self, map: Option, level: Option Result { - self.services.rooms.metadata.disable_room(&room_id, true); + self.services + .rooms + .metadata + .disable_room(&room_id, true); self.write_str("Room disabled.").await } #[admin_command] pub(super) async fn enable_room(&self, room_id: OwnedRoomId) -> Result { - self.services.rooms.metadata.disable_room(&room_id, false); + self.services + .rooms + .metadata + .disable_room(&room_id, false); self.write_str("Room enabled.").await } diff --git a/src/admin/media/commands.rs b/src/admin/media/commands.rs index 3177136b..c0c1a145 100644 --- a/src/admin/media/commands.rs +++ b/src/admin/media/commands.rs @@ -35,7 +35,13 @@ pub(super) async fn delete( let mut mxc_urls = Vec::with_capacity(4); // parsing the PDU for any MXC URLs begins here - match self.services.rooms.timeline.get_pdu_json(&event_id).await { + match self + .services + .rooms + .timeline + .get_pdu_json(&event_id) + .await + { | Ok(event_json) => { if let Some(content_key) = event_json.get("content") { debug!("Event ID has \"content\"."); @@ -255,7 +261,11 @@ pub(super) async fn delete_past_remote_media( pub(super) async fn delete_all_from_user(&self, username: String) -> Result { let user_id = parse_local_user_id(self.services, &username)?; - let deleted_count = self.services.media.delete_from_user(&user_id).await?; + let deleted_count = self + .services + .media + .delete_from_user(&user_id) + .await?; self.write_str(&format!("Deleted {deleted_count} total files.",)) .await @@ -294,7 +304,10 @@ pub(super) async fn delete_all_from_server( }; if mxc_server_name != server_name - || (self.services.globals.server_is_ours(mxc_server_name) + || (self + .services + .globals + .server_is_ours(mxc_server_name) && !yes_i_want_to_delete_local_media) { trace!("skipping MXC URI {mxc}"); @@ -323,7 +336,8 @@ pub(super) async fn get_file_info(&self, mxc: OwnedMxcUri) -> Result { let mxc: Mxc<'_> = mxc.as_str().try_into()?; let metadata = self.services.media.get_metadata(&mxc).await; - self.write_str(&format!("```\n{metadata:#?}\n```")).await + self.write_str(&format!("```\n{metadata:#?}\n```")) + .await } #[admin_command] diff --git a/src/admin/processor.rs b/src/admin/processor.rs index f94a8113..5bc456b2 100644 --- a/src/admin/processor.rs +++ b/src/admin/processor.rs @@ -69,7 +69,10 @@ async fn process_command(services: Arc, input: &CommandInput) -> Proce let (result, mut logs) = process(&context, command, &args).await; let output = &mut context.output.lock().await; - output.flush().await.expect("final flush of output stream"); + output + .flush() + .await + .expect("final flush of output stream"); let output = String::from_utf8(take(output.get_mut())).expect("invalid utf8 in command output stream"); @@ -79,7 +82,8 @@ async fn process_command(services: Arc, input: &CommandInput) -> Proce Ok(Some(reply(RoomMessageEventContent::notice_markdown(output), context.reply_id))), | Ok(()) => { - logs.write_str(output.as_str()).expect("output buffer"); + logs.write_str(output.as_str()) + .expect("output buffer"); Ok(Some(reply(RoomMessageEventContent::notice_markdown(logs), context.reply_id))) }, | Err(error) => { @@ -172,8 +176,14 @@ fn parse<'a>( services: &Arc, input: &'a CommandInput, ) -> Result<(AdminCommand, Vec, Vec<&'a str>), CommandOutput> { - let lines = input.command.lines().filter(|line| !line.trim().is_empty()); - let command_line = lines.clone().next().expect("command missing first line"); + let lines = input + .command + .lines() + .filter(|line| !line.trim().is_empty()); + let command_line = lines + .clone() + .next() + .expect("command missing first line"); let body = lines.skip(1).collect(); match parse_command(command_line) { | Ok((command, args)) => Ok((command, args, body)), diff --git a/src/admin/query/appservice.rs b/src/admin/query/appservice.rs index ad28796f..174daa0f 100644 --- a/src/admin/query/appservice.rs +++ b/src/admin/query/appservice.rs @@ -24,7 +24,10 @@ pub(super) async fn process(subcommand: AppserviceCommand, context: &Context<'_> match subcommand { | AppserviceCommand::GetRegistration { appservice_id } => { let timer = tokio::time::Instant::now(); - let results = services.appservice.get_registration(&appservice_id).await; + let results = services + .appservice + .get_registration(&appservice_id) + .await; let query_time = timer.elapsed(); @@ -32,7 +35,11 @@ pub(super) async fn process(subcommand: AppserviceCommand, context: &Context<'_> }, | AppserviceCommand::All => { let timer = tokio::time::Instant::now(); - let results: Vec<_> = services.appservice.iter_db_ids().try_collect().await?; + let results: Vec<_> = services + .appservice + .iter_db_ids() + .try_collect() + .await?; let query_time = timer.elapsed(); write!(context, "Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```") diff --git a/src/admin/query/globals.rs b/src/admin/query/globals.rs index 34717ff3..2db7d241 100644 --- a/src/admin/query/globals.rs +++ b/src/admin/query/globals.rs @@ -39,7 +39,10 @@ pub(super) async fn process(subcommand: GlobalsCommand, context: &Context<'_>) - }, | GlobalsCommand::SigningKeysFor { origin } => { let timer = tokio::time::Instant::now(); - let results = services.server_keys.verify_keys_for(&origin).await; + let results = services + .server_keys + .verify_keys_for(&origin) + .await; let query_time = timer.elapsed(); write!(context, "Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```") diff --git a/src/admin/query/raw.rs b/src/admin/query/raw.rs index 2bccd54f..44505576 100644 --- a/src/admin/query/raw.rs +++ b/src/admin/query/raw.rs @@ -194,8 +194,13 @@ pub(super) async fn compact( } let range = ( - start.as_ref().map(String::as_bytes).map(Into::into), - stop.as_ref().map(String::as_bytes).map(Into::into), + start + .as_ref() + .map(String::as_bytes) + .map(Into::into), + stop.as_ref() + .map(String::as_bytes) + .map(Into::into), ); let options = Options { @@ -429,7 +434,13 @@ pub(super) async fn raw_get(&self, map: String, key: String) -> Result { #[admin_command] pub(super) async fn raw_maps(&self) -> Result { - let list: Vec<_> = self.services.db.iter().map(at!(0)).copied().collect(); + let list: Vec<_> = self + .services + .db + .iter() + .map(at!(0)) + .copied() + .collect(); self.write_str(&format!("{list:#?}")).await } diff --git a/src/admin/query/resolver.rs b/src/admin/query/resolver.rs index e02465f4..e8ae6dc3 100644 --- a/src/admin/query/resolver.rs +++ b/src/admin/query/resolver.rs @@ -27,7 +27,12 @@ async fn destinations_cache(&self, server_name: Option) -> Resu writeln!(self, "| Server Name | Destination | Hostname | Expires |").await?; writeln!(self, "| ----------- | ----------- | -------- | ------- |").await?; - let mut destinations = self.services.resolver.cache.destinations().boxed(); + let mut destinations = self + .services + .resolver + .cache + .destinations() + .boxed(); while let Some((name, CachedDest { dest, host, expire })) = destinations.next().await { if let Some(server_name) = server_name.as_ref() { diff --git a/src/admin/query/room_alias.rs b/src/admin/query/room_alias.rs index 57f779df..460e56d8 100644 --- a/src/admin/query/room_alias.rs +++ b/src/admin/query/room_alias.rs @@ -30,7 +30,11 @@ pub(super) async fn process(subcommand: RoomAliasCommand, context: &Context<'_>) match subcommand { | RoomAliasCommand::ResolveLocalAlias { alias } => { let timer = tokio::time::Instant::now(); - let results = services.rooms.alias.resolve_local_alias(&alias).await; + let results = services + .rooms + .alias + .resolve_local_alias(&alias) + .await; let query_time = timer.elapsed(); write!(context, "Query completed in {query_time:?}:\n\n```rs\n{results:#?}\n```") diff --git a/src/admin/query/room_state_cache.rs b/src/admin/query/room_state_cache.rs index ff192d04..ae26abe8 100644 --- a/src/admin/query/room_state_cache.rs +++ b/src/admin/query/room_state_cache.rs @@ -182,7 +182,11 @@ pub(super) async fn process(subcommand: RoomStateCacheCommand, context: &Context }, | RoomStateCacheCommand::RoomJoinedCount { room_id } => { let timer = tokio::time::Instant::now(); - let results = services.rooms.state_cache.room_joined_count(&room_id).await; + let results = services + .rooms + .state_cache + .room_joined_count(&room_id) + .await; let query_time = timer.elapsed(); context diff --git a/src/admin/query/room_timeline.rs b/src/admin/query/room_timeline.rs index e55abe02..c90b1cb8 100644 --- a/src/admin/query/room_timeline.rs +++ b/src/admin/query/room_timeline.rs @@ -25,7 +25,12 @@ pub(crate) enum RoomTimelineCommand { #[admin_command] pub(super) async fn last(&self, room_id: OwnedRoomOrAliasId) -> Result { - let room_id = self.services.rooms.alias.resolve(&room_id).await?; + let room_id = self + .services + .rooms + .alias + .resolve(&room_id) + .await?; let result = self .services @@ -44,7 +49,12 @@ pub(super) async fn pdus( from: Option, limit: Option, ) -> Result { - let room_id = self.services.rooms.alias.resolve(&room_id).await?; + let room_id = self + .services + .rooms + .alias + .resolve(&room_id) + .await?; let from: Option = from.as_deref().map(str::parse).transpose()?; diff --git a/src/admin/query/sending.rs b/src/admin/query/sending.rs index 65dbb55c..5e6b43b4 100644 --- a/src/admin/query/sending.rs +++ b/src/admin/query/sending.rs @@ -223,7 +223,11 @@ pub(super) async fn process(subcommand: SendingCommand, context: &Context<'_>) - }, | SendingCommand::GetLatestEduCount { server_name } => { let timer = tokio::time::Instant::now(); - let results = services.sending.db.get_latest_educount(&server_name).await; + let results = services + .sending + .db + .get_latest_educount(&server_name) + .await; let query_time = timer.elapsed(); context diff --git a/src/admin/query/short.rs b/src/admin/query/short.rs index 21b3f796..d17092f0 100644 --- a/src/admin/query/short.rs +++ b/src/admin/query/short.rs @@ -31,9 +31,19 @@ pub(super) async fn short_event_id(&self, event_id: OwnedEventId) -> Result { #[admin_command] pub(super) async fn short_room_id(&self, room_id: OwnedRoomOrAliasId) -> Result { - let room_id = self.services.rooms.alias.resolve(&room_id).await?; + let room_id = self + .services + .rooms + .alias + .resolve(&room_id) + .await?; - let shortid = self.services.rooms.short.get_shortroomid(&room_id).await?; + let shortid = self + .services + .rooms + .short + .get_shortroomid(&room_id) + .await?; self.write_str(&format!("{shortid:#?}")).await } diff --git a/src/admin/query/users.rs b/src/admin/query/users.rs index df545c1a..1b6b534a 100644 --- a/src/admin/query/users.rs +++ b/src/admin/query/users.rs @@ -155,7 +155,11 @@ async fn get_room_backups( #[admin_command] async fn get_all_backups(&self, user_id: OwnedUserId, version: String) -> Result { let timer = tokio::time::Instant::now(); - let result = self.services.key_backups.get_all(&user_id, &version).await; + let result = self + .services + .key_backups + .get_all(&user_id, &version) + .await; let query_time = timer.elapsed(); self.write_str(&format!("Query completed in {query_time:?}:\n\n```rs\n{result:#?}\n```")) @@ -193,7 +197,11 @@ async fn get_latest_backup_version(&self, user_id: OwnedUserId) -> Result { #[admin_command] async fn get_latest_backup(&self, user_id: OwnedUserId) -> Result { let timer = tokio::time::Instant::now(); - let result = self.services.key_backups.get_latest_backup(&user_id).await; + let result = self + .services + .key_backups + .get_latest_backup(&user_id) + .await; let query_time = timer.elapsed(); self.write_str(&format!("Query completed in {query_time:?}:\n\n```rs\n{result:#?}\n```")) @@ -203,7 +211,13 @@ async fn get_latest_backup(&self, user_id: OwnedUserId) -> Result { #[admin_command] async fn iter_users(&self) -> Result { let timer = tokio::time::Instant::now(); - let result: Vec = self.services.users.stream().map(Into::into).collect().await; + let result: Vec = self + .services + .users + .stream() + .map(Into::into) + .collect() + .await; let query_time = timer.elapsed(); @@ -296,7 +310,11 @@ async fn get_device_metadata(&self, user_id: OwnedUserId, device_id: OwnedDevice #[admin_command] async fn get_devices_version(&self, user_id: OwnedUserId) -> Result { let timer = tokio::time::Instant::now(); - let device = self.services.users.get_devicelist_version(&user_id).await; + let device = self + .services + .users + .get_devicelist_version(&user_id) + .await; let query_time = timer.elapsed(); self.write_str(&format!("Query completed in {query_time:?}:\n\n```rs\n{device:#?}\n```")) @@ -334,7 +352,11 @@ async fn get_device_keys(&self, user_id: OwnedUserId, device_id: OwnedDeviceId) #[admin_command] async fn get_user_signing_key(&self, user_id: OwnedUserId) -> Result { let timer = tokio::time::Instant::now(); - let result = self.services.users.get_user_signing_key(&user_id).await; + let result = self + .services + .users + .get_user_signing_key(&user_id) + .await; let query_time = timer.elapsed(); self.write_str(&format!("Query completed in {query_time:?}:\n\n```rs\n{result:#?}\n```")) diff --git a/src/admin/room/alias.rs b/src/admin/room/alias.rs index f94ae325..67a41fa8 100644 --- a/src/admin/room/alias.rs +++ b/src/admin/room/alias.rs @@ -60,7 +60,14 @@ pub(super) async fn process(command: RoomAliasCommand, context: &Context<'_>) -> }; match command { | RoomAliasCommand::Set { force, room_id, .. } => { - match (force, services.rooms.alias.resolve_local_alias(&room_alias).await) { + match ( + force, + services + .rooms + .alias + .resolve_local_alias(&room_alias) + .await, + ) { | (true, Ok(id)) => { match services.rooms.alias.set_alias( &room_alias, @@ -93,7 +100,12 @@ pub(super) async fn process(command: RoomAliasCommand, context: &Context<'_>) -> } }, | RoomAliasCommand::Remove { .. } => { - match services.rooms.alias.resolve_local_alias(&room_alias).await { + match services + .rooms + .alias + .resolve_local_alias(&room_alias) + .await + { | Err(_) => Err!("Alias isn't in use."), | Ok(id) => match services .rooms @@ -103,14 +115,24 @@ pub(super) async fn process(command: RoomAliasCommand, context: &Context<'_>) -> { | Err(err) => Err!("Failed to remove alias: {err}"), | Ok(()) => - context.write_str(&format!("Removed alias from {id}")).await, + context + .write_str(&format!("Removed alias from {id}")) + .await, }, } }, | RoomAliasCommand::Which { .. } => { - match services.rooms.alias.resolve_local_alias(&room_alias).await { + match services + .rooms + .alias + .resolve_local_alias(&room_alias) + .await + { | Err(_) => Err!("Alias isn't in use."), - | Ok(id) => context.write_str(&format!("Alias resolves to {id}")).await, + | Ok(id) => + context + .write_str(&format!("Alias resolves to {id}")) + .await, } }, | RoomAliasCommand::List { .. } => unreachable!(), @@ -126,11 +148,13 @@ pub(super) async fn process(command: RoomAliasCommand, context: &Context<'_>) -> .collect() .await; - let plain_list = aliases.iter().fold(String::new(), |mut output, alias| { - writeln!(output, "- {alias}") - .expect("should be able to write to string buffer"); - output - }); + let plain_list = aliases + .iter() + .fold(String::new(), |mut output, alias| { + writeln!(output, "- {alias}") + .expect("should be able to write to string buffer"); + output + }); let plain = format!("Aliases for {room_id}:\n{plain_list}"); context.write_str(&plain).await diff --git a/src/admin/room/commands.rs b/src/admin/room/commands.rs index c5572c67..91393cc1 100644 --- a/src/admin/room/commands.rs +++ b/src/admin/room/commands.rs @@ -20,11 +20,23 @@ pub(super) async fn list_rooms( .metadata .iter_ids() .filter_map(|room_id| async move { - (!exclude_disabled || !self.services.rooms.metadata.is_disabled(room_id).await) + (!exclude_disabled + || !self + .services + .rooms + .metadata + .is_disabled(room_id) + .await) .then_some(room_id) }) .filter_map(|room_id| async move { - (!exclude_banned || !self.services.rooms.metadata.is_banned(room_id).await) + (!exclude_banned + || !self + .services + .rooms + .metadata + .is_banned(room_id) + .await) .then_some(room_id) }) .then(|room_id| get_room_info(self.services, room_id)) @@ -62,7 +74,12 @@ pub(super) async fn list_rooms( #[admin_command] pub(super) async fn exists(&self, room_id: OwnedRoomId) -> Result { - let result = self.services.rooms.metadata.exists(&room_id).await; + let result = self + .services + .rooms + .metadata + .exists(&room_id) + .await; self.write_str(&format!("{result}")).await } diff --git a/src/admin/room/moderation.rs b/src/admin/room/moderation.rs index 62fd6347..ecb7357c 100644 --- a/src/admin/room/moderation.rs +++ b/src/admin/room/moderation.rs @@ -70,7 +70,10 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result { }; debug!("Room specified is a room ID, banning room ID"); - self.services.rooms.metadata.ban_room(room_id, true); + self.services + .rooms + .metadata + .ban_room(room_id, true); room_id.to_owned() } else if room.is_room_alias_id() { @@ -128,7 +131,10 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result { }, }; - self.services.rooms.metadata.ban_room(&room_id, true); + self.services + .rooms + .metadata + .ban_room(&room_id, true); room_id } else { @@ -159,7 +165,10 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result { warn!("Failed to leave room: {e}"); } - self.services.rooms.state_cache.forget(&room_id, user_id); + self.services + .rooms + .state_cache + .forget(&room_id, user_id); } self.services @@ -178,9 +187,15 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result { .await; // unpublish from room directory - self.services.rooms.directory.set_not_public(&room_id); + self.services + .rooms + .directory + .set_not_public(&room_id); - self.services.rooms.metadata.disable_room(&room_id, true); + self.services + .rooms + .metadata + .disable_room(&room_id, true); self.write_str( "Room banned, removed all our local users, and disabled incoming federation with room.", @@ -302,7 +317,10 @@ async fn ban_list_of_rooms(&self) -> Result { } for room_id in room_ids { - self.services.rooms.metadata.ban_room(&room_id, true); + self.services + .rooms + .metadata + .ban_room(&room_id, true); debug!("Banned {room_id} successfully"); room_ban_count = room_ban_count.saturating_add(1); @@ -327,7 +345,10 @@ async fn ban_list_of_rooms(&self) -> Result { warn!("Failed to leave room: {e}"); } - self.services.rooms.state_cache.forget(&room_id, user_id); + self.services + .rooms + .state_cache + .forget(&room_id, user_id); } // remove any local aliases, ignore errors @@ -347,9 +368,15 @@ async fn ban_list_of_rooms(&self) -> Result { .await; // unpublish from room directory, ignore errors - self.services.rooms.directory.set_not_public(&room_id); + self.services + .rooms + .directory + .set_not_public(&room_id); - self.services.rooms.metadata.disable_room(&room_id, true); + self.services + .rooms + .metadata + .disable_room(&room_id, true); } self.write_str(&format!( @@ -374,7 +401,10 @@ async fn unban_room(&self, room: OwnedRoomOrAliasId) -> Result { }; debug!("Room specified is a room ID, unbanning room ID"); - self.services.rooms.metadata.ban_room(room_id, false); + self.services + .rooms + .metadata + .ban_room(room_id, false); room_id.to_owned() } else if room.is_room_alias_id() { @@ -430,7 +460,10 @@ async fn unban_room(&self, room: OwnedRoomOrAliasId) -> Result { }, }; - self.services.rooms.metadata.ban_room(&room_id, false); + self.services + .rooms + .metadata + .ban_room(&room_id, false); room_id } else { @@ -441,7 +474,10 @@ async fn unban_room(&self, room: OwnedRoomOrAliasId) -> Result { ); }; - self.services.rooms.metadata.disable_room(&room_id, false); + self.services + .rooms + .metadata + .disable_room(&room_id, false); self.write_str("Room unbanned and federation re-enabled.") .await } diff --git a/src/admin/user/commands.rs b/src/admin/user/commands.rs index 3baaa103..47211312 100644 --- a/src/admin/user/commands.rs +++ b/src/admin/user/commands.rs @@ -82,7 +82,14 @@ pub(super) async fn create_user(&self, username: String, password: Option return Err!("Not allowed to deactivate the server service account.",); } - self.services.users.deactivate_account(&user_id).await?; + self.services + .users + .deactivate_account(&user_id) + .await?; if !no_leave_rooms { self.services @@ -312,7 +331,12 @@ pub(super) async fn deactivate_all(&self, no_leave_rooms: bool, force: bool) -> let mut deactivation_count: usize = 0; for user_id in user_ids { - match self.services.users.deactivate_account(&user_id).await { + match self + .services + .users + .deactivate_account(&user_id) + .await + { | Err(e) => { self.services .admin @@ -640,7 +664,12 @@ pub(super) async fn force_leave_room( room_id: OwnedRoomOrAliasId, ) -> Result { let user_id = parse_local_user_id(self.services, &user_id)?; - let room_id = self.services.rooms.alias.resolve(&room_id).await?; + let room_id = self + .services + .rooms + .alias + .resolve(&room_id) + .await?; assert!( self.services.globals.user_is_local(&user_id), @@ -666,14 +695,25 @@ pub(super) async fn force_leave_room( #[admin_command] pub(super) async fn force_demote(&self, user_id: String, room_id: OwnedRoomOrAliasId) -> Result { let user_id = parse_local_user_id(self.services, &user_id)?; - let room_id = self.services.rooms.alias.resolve(&room_id).await?; + let room_id = self + .services + .rooms + .alias + .resolve(&room_id) + .await?; assert!( self.services.globals.user_is_local(&user_id), "Parsed user_id must be a local user" ); - let state_lock = self.services.rooms.state.mutex.lock(&room_id).await; + let state_lock = self + .services + .rooms + .state + .mutex + .lock(&room_id) + .await; let room_power_levels: Option = self .services @@ -730,7 +770,10 @@ pub(super) async fn make_user_admin(&self, user_id: String) -> Result { "Parsed user_id must be a local user" ); - self.services.admin.make_user_admin(&user_id).await?; + self.services + .admin + .make_user_admin(&user_id) + .await?; self.write_str(&format!("{user_id} has been granted admin privileges.",)) .await @@ -793,7 +836,10 @@ pub(super) async fn delete_room_tag( content: TagEventContent { tags: BTreeMap::new() }, }); - tags_event.content.tags.remove(&tag.clone().into()); + tags_event + .content + .tags + .remove(&tag.clone().into()); self.services .account_data @@ -858,7 +904,13 @@ pub(super) async fn redact_event(&self, event_id: OwnedEventId) -> Result { ); let redaction_event_id = { - let state_lock = self.services.rooms.state.mutex.lock(&room_id).await; + let state_lock = self + .services + .rooms + .state + .mutex + .lock(&room_id) + .await; self.services .rooms diff --git a/src/api/client/account.rs b/src/api/client/account.rs index 1157d94c..2706d727 100644 --- a/src/api/client/account.rs +++ b/src/api/client/account.rs @@ -57,11 +57,20 @@ pub(crate) async fn get_register_available_route( body: Ruma, ) -> Result { // workaround for https://github.com/matrix-org/matrix-appservice-irc/issues/1780 due to inactivity of fixing the issue - let is_matrix_appservice_irc = body.appservice_info.as_ref().is_some_and(|appservice| { - appservice.registration.id == "irc" - || appservice.registration.id.contains("matrix-appservice-irc") - || appservice.registration.id.contains("matrix_appservice_irc") - }); + let is_matrix_appservice_irc = body + .appservice_info + .as_ref() + .is_some_and(|appservice| { + appservice.registration.id == "irc" + || appservice + .registration + .id + .contains("matrix-appservice-irc") + || appservice + .registration + .id + .contains("matrix_appservice_irc") + }); if services .globals @@ -114,7 +123,11 @@ pub(crate) async fn get_register_available_route( } } - if services.appservice.is_exclusive_user_id(&user_id).await { + if services + .appservice + .is_exclusive_user_id(&user_id) + .await + { return Err!(Request(Exclusive("Username is reserved by an appservice."))); } @@ -175,7 +188,9 @@ pub(crate) async fn register_route( info!( "Guest registration disabled / registration enabled with token configured, \ rejecting guest registration attempt, initial device name: \"{}\"", - body.initial_device_display_name.as_deref().unwrap_or("") + body.initial_device_display_name + .as_deref() + .unwrap_or("") ); return Err!(Request(GuestAccessForbidden("Guest registration is disabled."))); } @@ -186,7 +201,9 @@ pub(crate) async fn register_route( warn!( "Guest account attempted to register before a real admin user has been registered, \ rejecting registration. Guest's initial device name: \"{}\"", - body.initial_device_display_name.as_deref().unwrap_or("") + body.initial_device_display_name + .as_deref() + .unwrap_or("") ); return Err!(Request(Forbidden("Registration is temporarily disabled."))); } @@ -195,13 +212,24 @@ pub(crate) async fn register_route( | (Some(username), false) => { // workaround for https://github.com/matrix-org/matrix-appservice-irc/issues/1780 due to inactivity of fixing the issue let is_matrix_appservice_irc = - body.appservice_info.as_ref().is_some_and(|appservice| { - appservice.registration.id == "irc" - || appservice.registration.id.contains("matrix-appservice-irc") - || appservice.registration.id.contains("matrix_appservice_irc") - }); + body.appservice_info + .as_ref() + .is_some_and(|appservice| { + appservice.registration.id == "irc" + || appservice + .registration + .id + .contains("matrix-appservice-irc") + || appservice + .registration + .id + .contains("matrix_appservice_irc") + }); - if services.globals.forbidden_usernames().is_match(username) + if services + .globals + .forbidden_usernames() + .is_match(username) && !emergency_mode_enabled { return Err!(Request(Forbidden("Username is forbidden"))); @@ -270,7 +298,10 @@ pub(crate) async fn register_route( return Err!(Request(MissingToken("Missing appservice token."))); }, } - } else if services.appservice.is_exclusive_user_id(&user_id).await && !emergency_mode_enabled + } else if services + .appservice + .is_exclusive_user_id(&user_id) + .await && !emergency_mode_enabled { return Err!(Request(Exclusive("Username is reserved by an appservice."))); } @@ -348,7 +379,10 @@ pub(crate) async fn register_route( // If `new_user_displayname_suffix` is set, registration will push whatever // content is set to the user's display name with a space before it - if !services.globals.new_user_displayname_suffix().is_empty() + if !services + .globals + .new_user_displayname_suffix() + .is_empty() && body.appservice_info.is_none() { write!(displayname, " {}", services.server.config.new_user_displayname_suffix) @@ -365,7 +399,9 @@ pub(crate) async fn register_route( .update( None, &user_id, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(ruma::events::push_rules::PushRulesEvent { content: ruma::events::push_rules::PushRulesEventContent { global: push::Ruleset::server_default(&user_id), @@ -411,7 +447,10 @@ pub(crate) async fn register_route( debug_info!(%user_id, %device_id, "User account was created"); - let device_display_name = body.initial_device_display_name.as_deref().unwrap_or(""); + let device_display_name = body + .initial_device_display_name + .as_deref() + .unwrap_or(""); // log in conduit admin channel if a non-guest user registered if body.appservice_info.is_none() && !is_guest { @@ -651,7 +690,10 @@ pub(crate) async fn change_password_route( .then_some(pushkey) }) .for_each(|pushkey| async move { - services.pusher.delete_pusher(sender_user, &pushkey).await; + services + .pusher + .delete_pusher(sender_user, &pushkey) + .await; }) .await; } @@ -680,7 +722,10 @@ pub(crate) async fn whoami_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let device_id = body.sender_device.clone(); Ok(whoami::v3::Response { @@ -790,7 +835,10 @@ pub(crate) async fn deactivate_route( pub(crate) async fn third_party_route( body: Ruma, ) -> Result { - let _sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let _sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); Ok(get_3pids::v3::Response::new(Vec::new())) } @@ -850,7 +898,11 @@ pub async fn full_user_deactivate( user_id: &UserId, all_joined_rooms: &[OwnedRoomId], ) -> Result<()> { - services.users.deactivate_account(user_id).await.ok(); + services + .users + .deactivate_account(user_id) + .await + .ok(); super::update_displayname(services, user_id, None, all_joined_rooms).await; super::update_avatar_url(services, user_id, None, None, all_joined_rooms).await; @@ -858,7 +910,9 @@ pub async fn full_user_deactivate( .users .all_profile_keys(user_id) .ready_for_each(|(profile_key, _)| { - services.users.set_profile_key(user_id, &profile_key, None); + services + .users + .set_profile_key(user_id, &profile_key, None); }) .await; diff --git a/src/api/client/alias.rs b/src/api/client/alias.rs index 5bb4f529..05479dff 100644 --- a/src/api/client/alias.rs +++ b/src/api/client/alias.rs @@ -17,7 +17,10 @@ pub(crate) async fn create_alias_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); services .rooms @@ -62,7 +65,10 @@ pub(crate) async fn delete_alias_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); services .rooms @@ -90,7 +96,11 @@ pub(crate) async fn get_alias_route( ) -> Result { let room_alias = body.body.room_alias; - let Ok((room_id, servers)) = services.rooms.alias.resolve_alias(&room_alias, None).await + let Ok((room_id, servers)) = services + .rooms + .alias + .resolve_alias(&room_alias, None) + .await else { return Err!(Request(NotFound("Room with alias not found."))); }; diff --git a/src/api/client/capabilities.rs b/src/api/client/capabilities.rs index fab7ac22..82ed8f94 100644 --- a/src/api/client/capabilities.rs +++ b/src/api/client/capabilities.rs @@ -26,7 +26,11 @@ pub(crate) async fn get_capabilities_route( let mut capabilities = Capabilities::default(); capabilities.room_versions = RoomVersionsCapability { - default: services.server.config.default_room_version.clone(), + default: services + .server + .config + .default_room_version + .clone(), available, }; diff --git a/src/api/client/context.rs b/src/api/client/context.rs index b5e50d85..8bbbb440 100644 --- a/src/api/client/context.rs +++ b/src/api/client/context.rs @@ -107,7 +107,9 @@ pub(crate) async fn get_context_route( .collect(); let (base_event, events_before, events_after): (_, Vec<_>, Vec<_>) = - join3(base_event, events_before, events_after).boxed().await; + join3(base_event, events_before, events_after) + .boxed() + .await; let lazy_loading_context = lazy_loading::Context { user_id: sender_user, @@ -138,7 +140,12 @@ pub(crate) async fn get_context_route( .rooms .state_accessor .pdu_shortstatehash(state_at) - .or_else(|_| services.rooms.state.get_room_shortstatehash(room_id)) + .or_else(|_| { + services + .rooms + .state + .get_room_shortstatehash(room_id) + }) .map_ok(|shortstatehash| { services .rooms @@ -177,14 +184,20 @@ pub(crate) async fn get_context_route( Some(event_id) }) .broad_filter_map(|event_id: &OwnedEventId| { - services.rooms.timeline.get_pdu(event_id.as_ref()).ok() + services + .rooms + .timeline + .get_pdu(event_id.as_ref()) + .ok() }) .map(PduEvent::into_state_event) .collect() .await; Ok(get_context::v3::Response { - event: base_event.map(at!(1)).map(PduEvent::into_room_event), + event: base_event + .map(at!(1)) + .map(PduEvent::into_room_event), start: events_before .last() diff --git a/src/api/client/device.rs b/src/api/client/device.rs index 1d62745c..9d671d87 100644 --- a/src/api/client/device.rs +++ b/src/api/client/device.rs @@ -21,7 +21,10 @@ pub(crate) async fn get_devices_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let devices: Vec = services .users @@ -39,7 +42,10 @@ pub(crate) async fn get_device_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let device = services .users @@ -69,7 +75,9 @@ pub(crate) async fn update_device_route( { | Ok(mut device) => { device.display_name.clone_from(&body.display_name); - device.last_seen_ip.clone_from(&Some(client.to_string())); + device + .last_seen_ip + .clone_from(&Some(client.to_string())); device .last_seen_ts .clone_from(&Some(MilliSecondsSinceUnixEpoch::now())); @@ -213,7 +221,10 @@ pub(crate) async fn delete_devices_route( enabled" ); for device_id in &body.devices { - services.users.remove_device(sender_user, device_id).await; + services + .users + .remove_device(sender_user, device_id) + .await; } return Ok(delete_devices::v3::Response {}); @@ -256,7 +267,10 @@ pub(crate) async fn delete_devices_route( } for device_id in &body.devices { - services.users.remove_device(sender_user, device_id).await; + services + .users + .remove_device(sender_user, device_id) + .await; } Ok(delete_devices::v3::Response {}) diff --git a/src/api/client/directory.rs b/src/api/client/directory.rs index 55580f1a..b3569a71 100644 --- a/src/api/client/directory.rs +++ b/src/api/client/directory.rs @@ -137,7 +137,12 @@ pub(crate) async fn set_room_visibility_route( ) -> Result { let sender_user = body.sender_user(); - if !services.rooms.metadata.exists(&body.room_id).await { + if !services + .rooms + .metadata + .exists(&body.room_id) + .await + { // Return 404 if the room doesn't exist return Err!(Request(NotFound("Room not found"))); } @@ -158,7 +163,10 @@ pub(crate) async fn set_room_visibility_route( match &body.visibility { | room::Visibility::Public => { - if services.server.config.lockdown_public_room_directory + if services + .server + .config + .lockdown_public_room_directory && !services.users.is_admin(sender_user).await && body.appservice_info.is_none() { @@ -197,7 +205,10 @@ pub(crate) async fn set_room_visibility_route( } info!("{sender_user} made {0} public to the room directory", body.room_id); }, - | room::Visibility::Private => services.rooms.directory.set_not_public(&body.room_id), + | room::Visibility::Private => services + .rooms + .directory + .set_not_public(&body.room_id), | _ => { return Err!(Request(InvalidParam("Room visibility type is not supported.",))); }, @@ -213,13 +224,23 @@ pub(crate) async fn get_room_visibility_route( State(services): State, body: Ruma, ) -> Result { - if !services.rooms.metadata.exists(&body.room_id).await { + if !services + .rooms + .metadata + .exists(&body.room_id) + .await + { // Return 404 if the room doesn't exist return Err!(Request(NotFound("Room not found"))); } Ok(get_room_visibility::v3::Response { - visibility: if services.rooms.directory.is_public_room(&body.room_id).await { + visibility: if services + .rooms + .directory + .is_public_room(&body.room_id) + .await + { room::Visibility::Public } else { room::Visibility::Private @@ -332,9 +353,15 @@ pub(crate) async fn get_public_rooms_filtered_helper( .unwrap_or_else(|_| uint!(0)) .into(); - let chunk: Vec<_> = all_rooms.into_iter().skip(num_since).take(limit).collect(); + let chunk: Vec<_> = all_rooms + .into_iter() + .skip(num_since) + .take(limit) + .collect(); - let prev_batch = num_since.ne(&0).then_some(format!("p{num_since}")); + let prev_batch = num_since + .ne(&0) + .then_some(format!("p{num_since}")); let next_batch = chunk .len() @@ -383,9 +410,17 @@ async fn user_can_publish_room( } async fn public_rooms_chunk(services: &Services, room_id: OwnedRoomId) -> PublicRoomsChunk { - let name = services.rooms.state_accessor.get_name(&room_id).ok(); + let name = services + .rooms + .state_accessor + .get_name(&room_id) + .ok(); - let room_type = services.rooms.state_accessor.get_room_type(&room_id).ok(); + let room_type = services + .rooms + .state_accessor + .get_room_type(&room_id) + .ok(); let canonical_alias = services .rooms @@ -395,9 +430,16 @@ async fn public_rooms_chunk(services: &Services, room_id: OwnedRoomId) -> Public let avatar_url = services.rooms.state_accessor.get_avatar(&room_id); - let topic = services.rooms.state_accessor.get_room_topic(&room_id).ok(); + let topic = services + .rooms + .state_accessor + .get_room_topic(&room_id) + .ok(); - let world_readable = services.rooms.state_accessor.is_world_readable(&room_id); + let world_readable = services + .rooms + .state_accessor + .is_world_readable(&room_id); let join_rule = services .rooms @@ -410,9 +452,15 @@ async fn public_rooms_chunk(services: &Services, room_id: OwnedRoomId) -> Public | _ => "invite".into(), }); - let guest_can_join = services.rooms.state_accessor.guest_can_join(&room_id); + let guest_can_join = services + .rooms + .state_accessor + .guest_can_join(&room_id); - let num_joined_members = services.rooms.state_cache.room_joined_count(&room_id); + let num_joined_members = services + .rooms + .state_cache + .room_joined_count(&room_id); let ( (avatar_url, canonical_alias, guest_can_join, join_rule, name), diff --git a/src/api/client/filter.rs b/src/api/client/filter.rs index 48fc8e4c..9735897e 100644 --- a/src/api/client/filter.rs +++ b/src/api/client/filter.rs @@ -13,7 +13,10 @@ pub(crate) async fn get_filter_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); services .users @@ -30,9 +33,14 @@ pub(crate) async fn create_filter_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); - let filter_id = services.users.create_filter(sender_user, &body.filter); + let filter_id = services + .users + .create_filter(sender_user, &body.filter); Ok(create_filter::v3::Response::new(filter_id)) } diff --git a/src/api/client/keys.rs b/src/api/client/keys.rs index 2b4db65b..4a26a717 100644 --- a/src/api/client/keys.rs +++ b/src/api/client/keys.rs @@ -126,7 +126,10 @@ pub(crate) async fn get_keys_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); get_keys_helper( &services, @@ -157,8 +160,14 @@ pub(crate) async fn upload_signing_keys_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); - let sender_device = body.sender_device.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); + let sender_device = body + .sender_device + .as_ref() + .expect("user is authenticated"); // UIAA let mut uiaainfo = UiaaInfo { @@ -373,7 +382,10 @@ pub(crate) async fn get_key_changes_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let mut device_list_updates = HashSet::new(); @@ -396,7 +408,11 @@ pub(crate) async fn get_key_changes_route( .await, ); - let mut rooms_joined = services.rooms.state_cache.rooms_joined(sender_user).boxed(); + let mut rooms_joined = services + .rooms + .state_cache + .rooms_joined(sender_user) + .boxed(); while let Some(room_id) = rooms_joined.next().await { device_list_updates.extend( @@ -449,7 +465,11 @@ where let mut devices = services.users.all_device_ids(user_id).boxed(); while let Some(device_id) = devices.next().await { - if let Ok(mut keys) = services.users.get_device_keys(user_id, device_id).await { + if let Ok(mut keys) = services + .users + .get_device_keys(user_id, device_id) + .await + { let metadata = services .users .get_device_metadata(user_id, device_id) @@ -469,7 +489,11 @@ where } else { for device_id in device_ids { let mut container = BTreeMap::new(); - if let Ok(mut keys) = services.users.get_device_keys(user_id, device_id).await { + if let Ok(mut keys) = services + .users + .get_device_keys(user_id, device_id) + .await + { let metadata = services .users .get_device_metadata(user_id, device_id) @@ -545,7 +569,9 @@ where .await { let (_, mut our_master_key) = parse_master_key(&user, &our_master_key)?; - master_key.signatures.append(&mut our_master_key.signatures); + master_key + .signatures + .append(&mut our_master_key.signatures); } let json = serde_json::to_value(master_key).expect("to_value always works"); let raw = serde_json::from_value(json).expect("Raw::from_value always works"); @@ -588,7 +614,9 @@ fn add_unsigned_device_display_name( if let Some(display_name) = metadata.display_name { let mut object = keys.deserialize_as::>()?; - let unsigned = object.entry("unsigned").or_insert_with(|| json!({})); + let unsigned = object + .entry("unsigned") + .or_insert_with(|| json!({})); if let serde_json::Value::Object(unsigned_object) = unsigned { if include_display_names { unsigned_object.insert("device_display_name".to_owned(), display_name.into()); diff --git a/src/api/client/media.rs b/src/api/client/media.rs index 9aae3ec7..c7101c37 100644 --- a/src/api/client/media.rs +++ b/src/api/client/media.rs @@ -51,7 +51,10 @@ pub(crate) async fn create_content_route( InsecureClientIp(client): InsecureClientIp, body: Ruma, ) -> Result { - let user = body.sender_user.as_ref().expect("user is authenticated"); + let user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let filename = body.filename.as_deref(); let content_type = body.content_type.as_deref(); @@ -94,7 +97,10 @@ pub(crate) async fn get_content_thumbnail_route( InsecureClientIp(client): InsecureClientIp, body: Ruma, ) -> Result { - let user = body.sender_user.as_ref().expect("user is authenticated"); + let user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let dim = Dim::from_ruma(body.width, body.height, body.method.clone())?; let mxc = Mxc { @@ -131,7 +137,10 @@ pub(crate) async fn get_content_route( InsecureClientIp(client): InsecureClientIp, body: Ruma, ) -> Result { - let user = body.sender_user.as_ref().expect("user is authenticated"); + let user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let mxc = Mxc { server_name: &body.server_name, @@ -167,7 +176,10 @@ pub(crate) async fn get_content_as_filename_route( InsecureClientIp(client): InsecureClientIp, body: Ruma, ) -> Result { - let user = body.sender_user.as_ref().expect("user is authenticated"); + let user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let mxc = Mxc { server_name: &body.server_name, @@ -203,7 +215,10 @@ pub(crate) async fn get_media_preview_route( InsecureClientIp(client): InsecureClientIp, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let url = &body.url; let url = Url::parse(&body.url).map_err(|e| { diff --git a/src/api/client/media_legacy.rs b/src/api/client/media_legacy.rs index ba7a5302..8b76d426 100644 --- a/src/api/client/media_legacy.rs +++ b/src/api/client/media_legacy.rs @@ -55,7 +55,10 @@ pub(crate) async fn get_media_preview_legacy_route( InsecureClientIp(client): InsecureClientIp, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let url = &body.url; let url = Url::parse(&body.url).map_err(|e| { @@ -70,11 +73,15 @@ pub(crate) async fn get_media_preview_legacy_route( ))); } - let preview = services.media.get_url_preview(&url).await.map_err(|e| { - err!(Request(Unknown( - debug_error!(%sender_user, %url, "Failed to fetch a URL preview: {e}") - ))) - })?; + let preview = services + .media + .get_url_preview(&url) + .await + .map_err(|e| { + err!(Request(Unknown( + debug_error!(%sender_user, %url, "Failed to fetch a URL preview: {e}") + ))) + })?; serde_json::value::to_raw_value(&preview) .map(get_media_preview::v3::Response::from_raw_value) diff --git a/src/api/client/membership.rs b/src/api/client/membership.rs index 8337d21a..b171df0e 100644 --- a/src/api/client/membership.rs +++ b/src/api/client/membership.rs @@ -85,14 +85,22 @@ async fn banned_room_check( || services .config .forbidden_remote_server_names - .is_match(room_id.server_name().expect("legacy room mxid").host()) - { + .is_match( + room_id + .server_name() + .expect("legacy room mxid") + .host(), + ) { warn!( "User {user_id} who is not an admin attempted to send an invite for or \ attempted to join a banned room or banned room server name: {room_id}" ); - if services.server.config.auto_deactivate_banned_room_attempts { + if services + .server + .config + .auto_deactivate_banned_room_attempts + { warn!( "Automatically deactivating user {user_id} due to attempted banned room join" ); @@ -131,7 +139,11 @@ async fn banned_room_check( name {server_name} that is globally forbidden. Rejecting.", ); - if services.server.config.auto_deactivate_banned_room_attempts { + if services + .server + .config + .auto_deactivate_banned_room_attempts + { warn!( "Automatically deactivating user {user_id} due to attempted banned room join" ); @@ -247,7 +259,10 @@ pub(crate) async fn join_room_by_id_or_alias_route( InsecureClientIp(client): InsecureClientIp, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_deref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_deref() + .expect("user is authenticated"); let appservice_info = &body.appservice_info; let body = body.body; @@ -513,9 +528,12 @@ pub(crate) async fn invite_user_route( match &body.recipient { | invite_user::v3::InvitationRecipient::UserId { user_id } => { - let sender_ignored_recipient = services.users.user_is_ignored(sender_user, user_id); - let recipient_ignored_by_sender = - services.users.user_is_ignored(user_id, sender_user); + let sender_ignored_recipient = services + .users + .user_is_ignored(sender_user, user_id); + let recipient_ignored_by_sender = services + .users + .user_is_ignored(user_id, sender_user); let (sender_ignored_recipient, recipient_ignored_by_sender) = join!(sender_ignored_recipient, recipient_ignored_by_sender); @@ -567,7 +585,12 @@ pub(crate) async fn kick_user_route( State(services): State, body: Ruma, ) -> Result { - let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; + let state_lock = services + .rooms + .state + .mutex + .lock(&body.room_id) + .await; let Ok(event) = services .rooms @@ -626,7 +649,12 @@ pub(crate) async fn ban_user_route( return Err!(Request(Forbidden("You cannot ban yourself."))); } - let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; + let state_lock = services + .rooms + .state + .mutex + .lock(&body.room_id) + .await; let current_member_content = services .rooms @@ -667,7 +695,12 @@ pub(crate) async fn unban_user_route( State(services): State, body: Ruma, ) -> Result { - let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; + let state_lock = services + .rooms + .state + .mutex + .lock(&body.room_id) + .await; let current_member_content = services .rooms @@ -722,9 +755,18 @@ pub(crate) async fn forget_room_route( let user_id = body.sender_user(); let room_id = &body.room_id; - let joined = services.rooms.state_cache.is_joined(user_id, room_id); - let knocked = services.rooms.state_cache.is_knocked(user_id, room_id); - let invited = services.rooms.state_cache.is_invited(user_id, room_id); + let joined = services + .rooms + .state_cache + .is_joined(user_id, room_id); + let knocked = services + .rooms + .state_cache + .is_knocked(user_id, room_id); + let invited = services + .rooms + .state_cache + .is_invited(user_id, room_id); pin_mut!(joined, knocked, invited); if joined.or(knocked).or(invited).await { @@ -745,8 +787,17 @@ pub(crate) async fn forget_room_route( .map(|member| member.membership) .is_ok_and(is_matching!(MembershipState::Leave | MembershipState::Ban)); - if non_membership || services.rooms.state_cache.is_left(user_id, room_id).await { - services.rooms.state_cache.forget(room_id, user_id); + if non_membership + || services + .rooms + .state_cache + .is_left(user_id, room_id) + .await + { + services + .rooms + .state_cache + .forget(room_id, user_id); } Ok(forget_room::v3::Response::new()) @@ -791,7 +842,10 @@ fn membership_filter( | Some(_) | None => MembershipState::Leave, }; - let evt_membership = pdu.get_content::().ok()?.membership; + let evt_membership = pdu + .get_content::() + .ok()? + .membership; if for_membership.is_some() && not_membership.is_some() { if membership_state_filter != evt_membership @@ -912,7 +966,13 @@ pub async fn join_room_by_id_helper( .unwrap_or(false) && appservice_info.is_none(); - if user_is_guest && !services.rooms.state_accessor.guest_can_join(room_id).await { + if user_is_guest + && !services + .rooms + .state_accessor + .guest_can_join(room_id) + .await + { return Err!(Request(Forbidden("Guests are not allowed to join this room"))); } @@ -999,7 +1059,10 @@ async fn join_room_by_id_helper_remote( return Err!(BadServerResponse("Remote room version is not supported by conduwuit")); }; - if !services.server.supported_room_version(&room_version_id) { + if !services + .server + .supported_room_version(&room_version_id) + { return Err!(BadServerResponse( "Remote room version {room_version_id} is not supported by conduwuit" )); @@ -1198,7 +1261,10 @@ async fn join_room_by_id_helper_remote( }, }; - 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 @@ -1229,7 +1295,10 @@ async fn join_room_by_id_helper_remote( }) .ready_filter_map(Result::ok) .ready_for_each(|(event_id, value)| { - services.rooms.outlier.add_pdu_outlier(&event_id, &value); + services + .rooms + .outlier + .add_pdu_outlier(&event_id, &value); }) .await; @@ -1238,10 +1307,20 @@ async fn join_room_by_id_helper_remote( debug!("Running send_join auth check"); let fetch_state = &state; let state_fetch = |k: StateEventType, s: StateKey| async move { - let shortstatekey = services.rooms.short.get_shortstatekey(&k, &s).await.ok()?; + let shortstatekey = services + .rooms + .short + .get_shortstatekey(&k, &s) + .await + .ok()?; let event_id = fetch_state.get(&shortstatekey)?; - services.rooms.timeline.get_pdu(event_id).await.ok() + services + .rooms + .timeline + .get_pdu(event_id) + .await + .ok() }; let auth_check = state_res::event_auth::auth_check( @@ -1436,7 +1515,10 @@ async fn join_room_by_id_helper_local( return Err!(BadServerResponse("Remote room version is not supported by conduwuit")); }; - if !services.server.supported_room_version(&room_version_id) { + if !services + .server + .supported_room_version(&room_version_id) + { return Err!(BadServerResponse( "Remote room version {room_version_id} is not supported by conduwuit" )); @@ -1572,7 +1654,10 @@ async fn make_join_request( federation::membership::prepare_join_event::v1::Request { room_id: room_id.to_owned(), user_id: sender_user.to_owned(), - ver: services.server.supported_room_versions().collect(), + ver: services + .server + .supported_room_versions() + .collect(), }, ) .await; @@ -1667,7 +1752,11 @@ pub(crate) async fn invite_helper( (pdu, pdu_json, invite_room_state) }; - let room_version_id = services.rooms.state.get_room_version(room_id).await?; + let room_version_id = services + .rooms + .state + .get_room_version(room_id) + .await?; let response = services .sending @@ -1723,7 +1812,10 @@ pub(crate) async fn invite_helper( err!(Request(InvalidParam("Could not accept incoming PDU as timeline event."))) })?; - return services.sending.send_pdu_room(room_id, &pdu_id).await; + return services + .sending + .send_pdu_room(room_id, &pdu_id) + .await; } if !services @@ -1797,7 +1889,10 @@ pub async fn leave_all_rooms(services: &Services, user_id: &UserId) { warn!(%user_id, "Failed to leave {room_id} remotely: {e}"); } - services.rooms.state_cache.forget(&room_id, user_id); + services + .rooms + .state_cache + .forget(&room_id, user_id); } } @@ -1856,7 +1951,10 @@ pub async fn leave_room( // Ask a remote server if we don't have this room and are not knocking on it if dont_have_room.and(not_knocked).await { - if let Err(e) = remote_leave_room(services, user_id, room_id).boxed().await { + if let Err(e) = remote_leave_room(services, user_id, room_id) + .boxed() + .await + { warn!(%user_id, "Failed to leave room {room_id} remotely: {e}"); // Don't tell the client about this error } @@ -1865,8 +1963,18 @@ pub async fn leave_room( .rooms .state_cache .invite_state(user_id, room_id) - .or_else(|_| services.rooms.state_cache.knock_state(user_id, room_id)) - .or_else(|_| services.rooms.state_cache.left_state(user_id, room_id)) + .or_else(|_| { + services + .rooms + .state_cache + .knock_state(user_id, room_id) + }) + .or_else(|_| { + services + .rooms + .state_cache + .left_state(user_id, room_id) + }) .await .ok(); @@ -2029,7 +2137,10 @@ async fn remote_leave_room( ))); }; - if !services.server.supported_room_version(&room_version_id) { + if !services + .server + .supported_room_version(&room_version_id) + { return Err!(BadServerResponse(warn!( "Remote room version {room_version_id} for {room_id} is not supported by conduwuit", ))); @@ -2186,7 +2297,11 @@ async fn knock_room_helper_local( ) -> Result { debug_info!("We can knock locally"); - let room_version_id = services.rooms.state.get_room_version(room_id).await?; + let room_version_id = services + .rooms + .state + .get_room_version(room_id) + .await?; if matches!( room_version_id, @@ -2237,7 +2352,10 @@ async fn knock_room_helper_local( let room_version_id = make_knock_response.room_version; - if !services.server.supported_room_version(&room_version_id) { + if !services + .server + .supported_room_version(&room_version_id) + { return Err!(BadServerResponse( "Remote room version {room_version_id} is not supported by conduwuit" )); @@ -2367,7 +2485,10 @@ async fn knock_room_helper_remote( let room_version_id = make_knock_response.room_version; - if !services.server.supported_room_version(&room_version_id) { + if !services + .server + .supported_room_version(&room_version_id) + { return Err!(BadServerResponse( "Remote room version {room_version_id} is not supported by conduwuit" )); @@ -2481,7 +2602,10 @@ async fn knock_room_helper_remote( .get_or_create_shortstatekey(&event_type, &state_key) .await; - services.rooms.outlier.add_pdu_outlier(&event_id, &event); + services + .rooms + .outlier + .add_pdu_outlier(&event_id, &event); state_map.insert(shortstatekey, event_id.clone()); } @@ -2489,7 +2613,11 @@ async fn knock_room_helper_remote( let compressed: CompressedState = services .rooms .state_compressor - .compress_state_events(state_map.iter().map(|(ssk, eid)| (ssk, eid.borrow()))) + .compress_state_events( + state_map + .iter() + .map(|(ssk, eid)| (ssk, eid.borrow())), + ) .collect() .await; @@ -2582,7 +2710,10 @@ async fn make_knock_request( federation::knock::create_knock_event_template::v1::Request { room_id: room_id.to_owned(), user_id: sender_user.to_owned(), - ver: services.server.supported_room_versions().collect(), + ver: services + .server + .supported_room_versions() + .collect(), }, ) .await; diff --git a/src/api/client/message.rs b/src/api/client/message.rs index 089eb540..f110632a 100644 --- a/src/api/client/message.rs +++ b/src/api/client/message.rs @@ -258,7 +258,9 @@ pub(crate) async fn is_ignored_pdu( return true; } - let ignored_type = IGNORED_MESSAGE_TYPES.binary_search(&pdu.kind).is_ok(); + let ignored_type = IGNORED_MESSAGE_TYPES + .binary_search(&pdu.kind) + .is_ok(); let ignored_server = services .config @@ -266,7 +268,11 @@ pub(crate) async fn is_ignored_pdu( .is_match(pdu.sender().server_name().host()); if ignored_type - && (ignored_server || services.users.user_is_ignored(&pdu.sender, user_id).await) + && (ignored_server + || services + .users + .user_is_ignored(&pdu.sender, user_id) + .await) { return true; } diff --git a/src/api/client/openid.rs b/src/api/client/openid.rs index cab53055..0448ecbf 100644 --- a/src/api/client/openid.rs +++ b/src/api/client/openid.rs @@ -19,7 +19,10 @@ pub(crate) async fn create_openid_token_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if sender_user != &body.user_id { return Err(Error::BadRequest( diff --git a/src/api/client/presence.rs b/src/api/client/presence.rs index 0176cdb8..1a8acdfb 100644 --- a/src/api/client/presence.rs +++ b/src/api/client/presence.rs @@ -50,7 +50,11 @@ pub(crate) async fn get_presence_route( .await; if has_shared_rooms { - if let Ok(presence) = services.presence.get_presence(&body.user_id).await { + if let Ok(presence) = services + .presence + .get_presence(&body.user_id) + .await + { presence_event = Some(presence); } } diff --git a/src/api/client/profile.rs b/src/api/client/profile.rs index 4ef248e8..e6a3023c 100644 --- a/src/api/client/profile.rs +++ b/src/api/client/profile.rs @@ -35,7 +35,10 @@ pub(crate) async fn set_displayname_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if *sender_user != body.user_id && body.appservice_info.is_none() { return Err!(Request(Forbidden("You cannot update the profile of another user"))); @@ -111,7 +114,11 @@ pub(crate) async fn get_displayname_route( } Ok(get_display_name::v3::Response { - displayname: services.users.displayname(&body.user_id).await.ok(), + displayname: services + .users + .displayname(&body.user_id) + .await + .ok(), }) } @@ -124,7 +131,10 @@ pub(crate) async fn set_avatar_url_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if *sender_user != body.user_id && body.appservice_info.is_none() { return Err!(Request(Forbidden("You cannot update the profile of another user"))); @@ -212,7 +222,11 @@ pub(crate) async fn get_avatar_url_route( } Ok(get_avatar_url::v3::Response { - avatar_url: services.users.avatar_url(&body.user_id).await.ok(), + avatar_url: services + .users + .avatar_url(&body.user_id) + .await + .ok(), blurhash: services.users.blurhash(&body.user_id).await.ok(), }) } @@ -295,9 +309,17 @@ pub(crate) async fn get_profile_route( custom_profile_fields.remove("m.tz"); Ok(get_profile::v3::Response { - avatar_url: services.users.avatar_url(&body.user_id).await.ok(), + avatar_url: services + .users + .avatar_url(&body.user_id) + .await + .ok(), blurhash: services.users.blurhash(&body.user_id).await.ok(), - displayname: services.users.displayname(&body.user_id).await.ok(), + displayname: services + .users + .displayname(&body.user_id) + .await + .ok(), tz: services.users.timezone(&body.user_id).await.ok(), custom_profile_fields, }) @@ -324,7 +346,9 @@ pub async fn update_displayname( return; } - services.users.set_displayname(user_id, displayname.clone()); + services + .users + .set_displayname(user_id, displayname.clone()); // Send a new join membership event into all joined rooms let avatar_url = ¤t_avatar_url; @@ -376,8 +400,12 @@ pub async fn update_avatar_url( return; } - services.users.set_avatar_url(user_id, avatar_url.clone()); - services.users.set_blurhash(user_id, blurhash.clone()); + services + .users + .set_avatar_url(user_id, avatar_url.clone()); + services + .users + .set_blurhash(user_id, blurhash.clone()); // Send a new join membership event into all joined rooms let avatar_url = &avatar_url; diff --git a/src/api/client/push.rs b/src/api/client/push.rs index 298232c8..d8c2a004 100644 --- a/src/api/client/push.rs +++ b/src/api/client/push.rs @@ -84,7 +84,9 @@ pub(crate) async fn get_pushrules_all_route( .update( None, sender_user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(PushRulesEvent { content: PushRulesEventContent { global: global_ruleset.clone() }, }) @@ -106,7 +108,10 @@ pub(crate) async fn get_pushrules_global_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let Some(content_value) = services .account_data @@ -123,7 +128,9 @@ pub(crate) async fn get_pushrules_global_route( .update( None, sender_user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(PushRulesEvent { content: PushRulesEventContent { global: Ruleset::server_default(sender_user), @@ -177,7 +184,9 @@ pub(crate) async fn get_pushrules_global_route( .update( None, sender_user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(PushRulesEvent { content: PushRulesEventContent { global: global_ruleset.clone() }, }) @@ -197,7 +206,10 @@ pub(crate) async fn get_pushrule_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); // remove old deprecated mentions push rules as per MSC4210 #[allow(deprecated)] @@ -234,7 +246,10 @@ pub(crate) async fn set_pushrule_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let body = body.body; let mut account_data: PushRulesEvent = services @@ -280,7 +295,9 @@ pub(crate) async fn set_pushrule_route( .update( None, sender_user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(account_data).expect("to json value always works"), ) .await?; @@ -295,7 +312,10 @@ pub(crate) async fn get_pushrule_actions_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); // remove old deprecated mentions push rules as per MSC4210 #[allow(deprecated)] @@ -329,7 +349,10 @@ pub(crate) async fn set_pushrule_actions_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let mut account_data: PushRulesEvent = services .account_data @@ -351,7 +374,9 @@ pub(crate) async fn set_pushrule_actions_route( .update( None, sender_user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(account_data).expect("to json value always works"), ) .await?; @@ -366,7 +391,10 @@ pub(crate) async fn get_pushrule_enabled_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); // remove old deprecated mentions push rules as per MSC4210 #[allow(deprecated)] @@ -400,7 +428,10 @@ pub(crate) async fn set_pushrule_enabled_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let mut account_data: PushRulesEvent = services .account_data @@ -422,7 +453,9 @@ pub(crate) async fn set_pushrule_enabled_route( .update( None, sender_user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(account_data).expect("to json value always works"), ) .await?; @@ -437,7 +470,10 @@ pub(crate) async fn delete_pushrule_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let mut account_data: PushRulesEvent = services .account_data @@ -468,7 +504,9 @@ pub(crate) async fn delete_pushrule_route( .update( None, sender_user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(account_data).expect("to json value always works"), ) .await?; @@ -483,7 +521,10 @@ pub(crate) async fn get_pushers_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); Ok(get_pushers::v3::Response { pushers: services.pusher.get_pushers(sender_user).await, @@ -499,7 +540,10 @@ pub(crate) async fn set_pushers_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); services .pusher @@ -520,7 +564,9 @@ async fn recreate_push_rules_and_return( .update( None, sender_user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(PushRulesEvent { content: PushRulesEventContent { global: Ruleset::server_default(sender_user), diff --git a/src/api/client/redact.rs b/src/api/client/redact.rs index 3666c7c9..acb6da49 100644 --- a/src/api/client/redact.rs +++ b/src/api/client/redact.rs @@ -15,10 +15,18 @@ pub(crate) async fn redact_event_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let body = body.body; - let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; + let state_lock = services + .rooms + .state + .mutex + .lock(&body.room_id) + .await; let event_id = services .rooms diff --git a/src/api/client/report.rs b/src/api/client/report.rs index 67367ed3..0e57342a 100644 --- a/src/api/client/report.rs +++ b/src/api/client/report.rs @@ -30,7 +30,10 @@ pub(crate) async fn report_room_route( body: Ruma, ) -> Result { // user authentication - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); info!( "Received room report by user {sender_user} for room {} with reason: \"{}\"", @@ -38,7 +41,11 @@ pub(crate) async fn report_room_route( body.reason.as_deref().unwrap_or("") ); - if body.reason.as_ref().is_some_and(|s| s.len() > 750) { + if body + .reason + .as_ref() + .is_some_and(|s| s.len() > 750) + { return Err(Error::BadRequest( ErrorKind::InvalidParam, "Reason too long, should be 750 characters or fewer", @@ -84,7 +91,10 @@ pub(crate) async fn report_event_route( body: Ruma, ) -> Result { // user authentication - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); info!( "Received event report by user {sender_user} for room {} and event ID {}, with reason: \ @@ -97,7 +107,12 @@ pub(crate) async fn report_event_route( delay_response().await; // check if we know about the reported event ID or if it's invalid - let Ok(pdu) = services.rooms.timeline.get_pdu(&body.event_id).await else { + let Ok(pdu) = services + .rooms + .timeline + .get_pdu(&body.event_id) + .await + else { return Err!(Request(NotFound("Event ID is not known to us or Event ID is invalid"))); }; diff --git a/src/api/client/room/aliases.rs b/src/api/client/room/aliases.rs index 0775c1e5..917a63c6 100644 --- a/src/api/client/room/aliases.rs +++ b/src/api/client/room/aliases.rs @@ -15,7 +15,10 @@ pub(crate) async fn get_room_aliases_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if !services .rooms diff --git a/src/api/client/room/create.rs b/src/api/client/room/create.rs index f5676884..696c7bdf 100644 --- a/src/api/client/room/create.rs +++ b/src/api/client/room/create.rs @@ -58,7 +58,10 @@ pub(crate) async fn create_room_route( ) -> Result { use create_room::v3::RoomPreset; - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if !services.globals.allow_room_creation() && body.appservice_info.is_none() @@ -76,7 +79,13 @@ pub(crate) async fn create_room_route( }; // check if room ID doesn't already exist instead of erroring on auth check - if services.rooms.short.get_shortroomid(&room_id).await.is_ok() { + if services + .rooms + .short + .get_shortroomid(&room_id) + .await + .is_ok() + { return Err(Error::BadRequest( ErrorKind::RoomInUse, "Room with that custom room ID already exists", @@ -84,7 +93,10 @@ pub(crate) async fn create_room_route( } if body.visibility == room::Visibility::Public - && services.server.config.lockdown_public_room_directory + && services + .server + .config + .lockdown_public_room_directory && !services.users.is_admin(sender_user).await && body.appservice_info.is_none() { @@ -123,7 +135,10 @@ pub(crate) async fn create_room_route( let room_version = match body.room_version.clone() { | Some(room_version) => - if services.server.supported_room_version(&room_version) { + if services + .server + .supported_room_version(&room_version) + { room_version } else { return Err(Error::BadRequest( @@ -131,7 +146,11 @@ pub(crate) async fn create_room_route( "This server does not support that room version.", )); }, - | None => services.server.config.default_room_version.clone(), + | None => services + .server + .config + .default_room_version + .clone(), }; let create_content = match &body.creation_content { @@ -160,9 +179,11 @@ pub(crate) async fn create_room_route( } content.insert( "room_version".into(), - json!(room_version.as_str()).try_into().map_err(|_| { - Error::BadRequest(ErrorKind::BadJson, "Invalid creation content") - })?, + json!(room_version.as_str()) + .try_into() + .map_err(|_| { + Error::BadRequest(ErrorKind::BadJson, "Invalid creation content") + })?, ); content }, @@ -231,18 +252,29 @@ pub(crate) async fn create_room_route( // 3. Power levels // Figure out preset. We need it for preset specific events - let preset = body.preset.clone().unwrap_or(match &body.visibility { - | room::Visibility::Public => RoomPreset::PublicChat, - | _ => RoomPreset::PrivateChat, // Room visibility should not be custom - }); + let preset = body + .preset + .clone() + .unwrap_or(match &body.visibility { + | room::Visibility::Public => RoomPreset::PublicChat, + | _ => RoomPreset::PrivateChat, // Room visibility should not be custom + }); let mut users = BTreeMap::from_iter([(sender_user.clone(), int!(100))]); if preset == RoomPreset::TrustedPrivateChat { for invite in &body.invite { - if services.users.user_is_ignored(sender_user, invite).await { + if services + .users + .user_is_ignored(sender_user, invite) + .await + { continue; - } else if services.users.user_is_ignored(invite, sender_user).await { + } else if services + .users + .user_is_ignored(invite, sender_user) + .await + { // silently drop the invite to the recipient if they've been ignored by the // sender, pretend it worked continue; @@ -353,10 +385,12 @@ pub(crate) async fn create_room_route( // 6. Events listed in initial_state for event in &body.initial_state { - let mut pdu_builder = event.deserialize_as::().map_err(|e| { - warn!("Invalid initial state event: {:?}", e); - Error::BadRequest(ErrorKind::InvalidParam, "Invalid initial state event.") - })?; + let mut pdu_builder = event + .deserialize_as::() + .map_err(|e| { + warn!("Invalid initial state event: {:?}", e); + Error::BadRequest(ErrorKind::InvalidParam, "Invalid initial state event.") + })?; debug_info!("Room creation initial state event: {event:?}"); @@ -370,7 +404,9 @@ pub(crate) async fn create_room_route( } // Implicit state key defaults to "" - pdu_builder.state_key.get_or_insert_with(StateKey::new); + pdu_builder + .state_key + .get_or_insert_with(StateKey::new); // Silently skip encryption events if they are not allowed if pdu_builder.event_type == TimelineEventType::RoomEncryption @@ -419,9 +455,17 @@ pub(crate) async fn create_room_route( // 8. Events implied by invite (and TODO: invite_3pid) drop(state_lock); for user_id in &body.invite { - if services.users.user_is_ignored(sender_user, user_id).await { + if services + .users + .user_is_ignored(sender_user, user_id) + .await + { continue; - } else if services.users.user_is_ignored(user_id, sender_user).await { + } else if services + .users + .user_is_ignored(user_id, sender_user) + .await + { // silently drop the invite to the recipient if they've been ignored by the // sender, pretend it worked continue; diff --git a/src/api/client/room/initial_sync.rs b/src/api/client/room/initial_sync.rs index 581dd96b..829c4ad0 100644 --- a/src/api/client/room/initial_sync.rs +++ b/src/api/client/room/initial_sync.rs @@ -43,7 +43,11 @@ pub(crate) async fn room_initial_sync_route( .await?; let messages = PaginationChunk { - start: events.last().map(at!(0)).as_ref().map(ToString::to_string), + start: events + .last() + .map(at!(0)) + .as_ref() + .map(ToString::to_string), end: events .first() @@ -64,7 +68,12 @@ pub(crate) async fn room_initial_sync_route( account_data: None, state: state.into(), messages: messages.chunk.is_empty().or_some(messages), - visibility: services.rooms.directory.visibility(room_id).await.into(), + visibility: services + .rooms + .directory + .visibility(room_id) + .await + .into(), membership: services .rooms .state_cache diff --git a/src/api/client/room/summary.rs b/src/api/client/room/summary.rs index 1809bc8e..c6f055eb 100644 --- a/src/api/client/room/summary.rs +++ b/src/api/client/room/summary.rs @@ -102,7 +102,9 @@ async fn room_summary_response( room_version: room.room_version, encryption: room.encryption, allowed_room_ids: room.allowed_room_ids, - membership: sender_user.is_some().then_some(MembershipState::Leave), + membership: sender_user + .is_some() + .then_some(MembershipState::Leave), }) } @@ -112,9 +114,18 @@ async fn local_room_summary_response( sender_user: Option<&UserId>, ) -> Result { trace!(?sender_user, "Sending local room summary response for {room_id:?}"); - let join_rule = services.rooms.state_accessor.get_join_rules(room_id); - let world_readable = services.rooms.state_accessor.is_world_readable(room_id); - let guest_can_join = services.rooms.state_accessor.guest_can_join(room_id); + let join_rule = services + .rooms + .state_accessor + .get_join_rules(room_id); + let world_readable = services + .rooms + .state_accessor + .is_world_readable(room_id); + let guest_can_join = services + .rooms + .state_accessor + .guest_can_join(room_id); let (join_rule, world_readable, guest_can_join) = join3(join_rule, world_readable, guest_can_join).await; @@ -137,11 +148,23 @@ async fn local_room_summary_response( .get_canonical_alias(room_id) .ok(); - let name = services.rooms.state_accessor.get_name(room_id).ok(); + let name = services + .rooms + .state_accessor + .get_name(room_id) + .ok(); - let topic = services.rooms.state_accessor.get_room_topic(room_id).ok(); + let topic = services + .rooms + .state_accessor + .get_room_topic(room_id) + .ok(); - let room_type = services.rooms.state_accessor.get_room_type(room_id).ok(); + let room_type = services + .rooms + .state_accessor + .get_room_type(room_id) + .ok(); let avatar_url = services .rooms @@ -149,7 +172,11 @@ async fn local_room_summary_response( .get_avatar(room_id) .map(|res| res.into_option().unwrap_or_default().url); - let room_version = services.rooms.state.get_room_version(room_id).ok(); + let room_version = services + .rooms + .state + .get_room_version(room_id) + .ok(); let encryption = services .rooms @@ -208,7 +235,10 @@ async fn local_room_summary_response( room_version, encryption, membership, - allowed_room_ids: join_rule.allowed_rooms().map(Into::into).collect(), + allowed_room_ids: join_rule + .allowed_rooms() + .map(Into::into) + .collect(), join_rule: join_rule.into(), }) } @@ -292,10 +322,16 @@ where .rooms .state_accessor .user_can_see_state_events(sender_user, room_id); - let is_guest = services.users.is_deactivated(sender_user).unwrap_or(false); - let user_in_allowed_restricted_room = allowed_room_ids - .stream() - .any(|room| services.rooms.state_cache.is_joined(sender_user, room)); + let is_guest = services + .users + .is_deactivated(sender_user) + .unwrap_or(false); + let user_in_allowed_restricted_room = allowed_room_ids.stream().any(|room| { + services + .rooms + .state_cache + .is_joined(sender_user, room) + }); let (user_can_see_state_events, is_guest, user_in_allowed_restricted_room) = join3(user_can_see_state_events, is_guest, user_in_allowed_restricted_room) diff --git a/src/api/client/room/upgrade.rs b/src/api/client/room/upgrade.rs index e9da2aff..d6172f80 100644 --- a/src/api/client/room/upgrade.rs +++ b/src/api/client/room/upgrade.rs @@ -54,9 +54,15 @@ pub(crate) async fn upgrade_room_route( TRANSFERABLE_STATE_EVENTS.is_sorted(), "TRANSFERABLE_STATE_EVENTS is not sorted" ); - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); - if !services.server.supported_room_version(&body.new_version) { + if !services + .server + .supported_room_version(&body.new_version) + { return Err(Error::BadRequest( ErrorKind::UnsupportedRoomVersion, "This server does not support that room version.", @@ -72,7 +78,12 @@ pub(crate) async fn upgrade_room_route( .get_or_create_shortroomid(&replacement_room) .await; - let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; + let state_lock = services + .rooms + .state + .mutex + .lock(&body.room_id) + .await; // Send a m.room.tombstone event to the old room to indicate that it is not // intended to be used any further Fail if the sender does not have the required @@ -93,7 +104,12 @@ pub(crate) async fn upgrade_room_route( // Change lock to replacement room drop(state_lock); - let state_lock = services.rooms.state.mutex.lock(&replacement_room).await; + let state_lock = services + .rooms + .state + .mutex + .lock(&replacement_room) + .await; // Get the old room creation event let mut create_event_content: CanonicalJsonObject = services diff --git a/src/api/client/search.rs b/src/api/client/search.rs index c4b2190e..2d41b4f2 100644 --- a/src/api/client/search.rs +++ b/src/api/client/search.rs @@ -110,7 +110,12 @@ async fn category_room_events( limit, }; - let (count, results) = services.rooms.search.search_pdus(&query).await.ok()?; + let (count, results) = services + .rooms + .search + .search_pdus(&query) + .await + .ok()?; results .collect::>() @@ -201,8 +206,12 @@ async fn check_room_visible( let check_visible = search.filter.rooms.is_some(); let check_state = check_visible && search.include_state.is_some_and(is_true!()); - let is_joined = - !check_visible || services.rooms.state_cache.is_joined(user_id, room_id).await; + let is_joined = !check_visible + || services + .rooms + .state_cache + .is_joined(user_id, room_id) + .await; let state_visible = !check_state || services diff --git a/src/api/client/send.rs b/src/api/client/send.rs index c806237e..0c02f28e 100644 --- a/src/api/client/send.rs +++ b/src/api/client/send.rs @@ -30,10 +30,19 @@ pub(crate) async fn send_message_event_route( return Err!(Request(Forbidden("Encryption has been disabled"))); } - let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; + let state_lock = services + .rooms + .state + .mutex + .lock(&body.room_id) + .await; if body.event_type == MessageLikeEventType::CallInvite - && services.rooms.directory.is_public_room(&body.room_id).await + && services + .rooms + .directory + .is_public_room(&body.room_id) + .await { return Err!(Request(Forbidden("Room call invites are not allowed in public rooms"))); } diff --git a/src/api/client/session.rs b/src/api/client/session.rs index baf72100..14293f43 100644 --- a/src/api/client/session.rs +++ b/src/api/client/session.rs @@ -100,7 +100,9 @@ pub(crate) async fn login_route( )?; if !services.globals.user_is_local(&user_id) - || !services.globals.user_is_local(&lowercased_user_id) + || !services + .globals + .user_is_local(&lowercased_user_id) { return Err!(Request(Unknown("User ID does not belong to this homeserver"))); } @@ -149,7 +151,10 @@ pub(crate) async fn login_route( if !services.server.config.login_via_existing_session { return Err!(Request(Unknown("Token login is not enabled."))); } - services.users.find_from_login_token(token).await? + services + .users + .find_from_login_token(token) + .await? }, #[allow(deprecated)] | login::v3::LoginInfo::ApplicationService(login::v3::ApplicationService { @@ -312,7 +317,9 @@ pub(crate) async fn login_token_route( } let login_token = utils::random_string(TOKEN_LENGTH); - let expires_in = services.users.create_login_token(sender_user, &login_token); + let expires_in = services + .users + .create_login_token(sender_user, &login_token); Ok(get_login_token::v1::Response { expires_in: Duration::from_millis(expires_in), @@ -335,8 +342,14 @@ pub(crate) async fn logout_route( InsecureClientIp(client): InsecureClientIp, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); - let sender_device = body.sender_device.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); + let sender_device = body + .sender_device + .as_ref() + .expect("user is authenticated"); services .users @@ -365,12 +378,19 @@ pub(crate) async fn logout_all_route( InsecureClientIp(client): InsecureClientIp, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); services .users .all_device_ids(sender_user) - .for_each(|device_id| services.users.remove_device(sender_user, device_id)) + .for_each(|device_id| { + services + .users + .remove_device(sender_user, device_id) + }) .await; Ok(logout_all::v3::Response::new()) diff --git a/src/api/client/state.rs b/src/api/client/state.rs index 2b6a89b0..ed43cacd 100644 --- a/src/api/client/state.rs +++ b/src/api/client/state.rs @@ -73,7 +73,10 @@ pub(crate) async fn get_state_events_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if !services .rooms diff --git a/src/api/client/sync/mod.rs b/src/api/client/sync/mod.rs index 10f5ad9d..0122bc06 100644 --- a/src/api/client/sync/mod.rs +++ b/src/api/client/sync/mod.rs @@ -51,7 +51,11 @@ async fn load_timeline( // Take the last events for the timeline pin_mut!(non_timeline_pdus); - let timeline_pdus: Vec<_> = non_timeline_pdus.by_ref().take(limit).collect().await; + let timeline_pdus: Vec<_> = non_timeline_pdus + .by_ref() + .take(limit) + .collect() + .await; let timeline_pdus: Vec<_> = timeline_pdus.into_iter().rev().collect(); diff --git a/src/api/client/sync/v3.rs b/src/api/client/sync/v3.rs index 4b40d03c..52338c65 100644 --- a/src/api/client/sync/v3.rs +++ b/src/api/client/sync/v3.rs @@ -480,7 +480,10 @@ async fn handle_left_room( let mut left_state_events = Vec::new(); - let since_shortstatehash = services.rooms.user.get_token_shortstatehash(room_id, since); + let since_shortstatehash = services + .rooms + .user + .get_token_shortstatehash(room_id, since); let since_state_ids: HashMap<_, OwnedEventId> = since_shortstatehash .map_ok(|since_shortstatehash| { @@ -640,7 +643,11 @@ async fn load_joined_room( let (timeline_pdus, limited) = timeline; let initial = since_shortstatehash.is_none(); let lazy_loading_enabled = filter.room.state.lazy_load_options.is_enabled() - || filter.room.timeline.lazy_load_options.is_enabled(); + || filter + .room + .timeline + .lazy_load_options + .is_enabled(); let lazy_loading_context = &lazy_loading::Context { user_id: sender_user, @@ -652,7 +659,12 @@ async fn load_joined_room( // Reset lazy loading because this is an initial sync let lazy_load_reset: OptionFuture<_> = initial - .then(|| services.rooms.lazy_loading.reset(lazy_loading_context)) + .then(|| { + services + .rooms + .lazy_loading + .reset(lazy_loading_context) + }) .into(); lazy_load_reset.await; @@ -964,15 +976,23 @@ async fn calculate_state_initial( .ready_filter_map(|((event_type, state_key), event_id)| { let lazy = !full_state && event_type == StateEventType::RoomMember - && state_key.as_str().try_into().is_ok_and(|user_id: &UserId| { - sender_user != user_id - && witness.is_some_and(|witness| !witness.contains(user_id)) - }); + && state_key + .as_str() + .try_into() + .is_ok_and(|user_id: &UserId| { + sender_user != user_id + && witness.is_some_and(|witness| !witness.contains(user_id)) + }); lazy.or_some(event_id) }) .broad_filter_map(|event_id: OwnedEventId| async move { - services.rooms.timeline.get_pdu(&event_id).await.ok() + services + .rooms + .timeline + .get_pdu(&event_id) + .await + .ok() }) .collect() .map(Ok); @@ -1085,7 +1105,12 @@ async fn calculate_state_incremental<'a>( .ok() }) .broad_filter_map(|event_id: OwnedEventId| async move { - services.rooms.timeline.get_pdu(&event_id).await.ok() + services + .rooms + .timeline + .get_pdu(&event_id) + .await + .ok() }) .collect::>() .await; @@ -1118,7 +1143,9 @@ async fn calculate_state_incremental<'a>( }) .await; - let send_member_count = state_events.iter().any(|event| event.kind == RoomMember); + let send_member_count = state_events + .iter() + .any(|event| event.kind == RoomMember); let (joined_member_count, invited_member_count, heroes) = if send_member_count { calculate_counts(services, room_id, sender_user).await? @@ -1205,8 +1232,11 @@ async fn fold_hero( sender_user: &UserId, pdu: PduEvent, ) -> Vec { - let Some(user_id): Option<&UserId> = - pdu.state_key.as_deref().map(TryInto::try_into).flat_ok() + let Some(user_id): Option<&UserId> = pdu + .state_key + .as_deref() + .map(TryInto::try_into) + .flat_ok() else { return heroes; }; @@ -1229,8 +1259,14 @@ async fn fold_hero( } let (is_invited, is_joined) = join( - services.rooms.state_cache.is_invited(user_id, room_id), - services.rooms.state_cache.is_joined(user_id, room_id), + services + .rooms + .state_cache + .is_invited(user_id, room_id), + services + .rooms + .state_cache + .is_joined(user_id, room_id), ) .await; diff --git a/src/api/client/sync/v4.rs b/src/api/client/sync/v4.rs index 060ef971..a695b95c 100644 --- a/src/api/client/sync/v4.rs +++ b/src/api/client/sync/v4.rs @@ -53,8 +53,14 @@ pub(crate) async fn sync_events_v4_route( body: Ruma, ) -> Result { debug_assert!(DEFAULT_BUMP_TYPES.is_sorted(), "DEFAULT_BUMP_TYPES is not sorted"); - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); - let sender_device = body.sender_device.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); + let sender_device = body + .sender_device + .as_ref() + .expect("user is authenticated"); let mut body = body.body; // Setup watchers, so if there's no response, we can wait for them @@ -80,7 +86,9 @@ pub(crate) async fn sync_events_v4_route( } if globalsince == 0 { - services.sync.forget_sync_request_connection(&db_key); + services + .sync + .forget_sync_request_connection(&db_key); } // Get sticky parameters from cache @@ -113,8 +121,14 @@ pub(crate) async fn sync_events_v4_route( .collect() .await; - let all_invited_rooms: Vec<&RoomId> = all_invited_rooms.iter().map(AsRef::as_ref).collect(); - let all_knocked_rooms: Vec<&RoomId> = all_knocked_rooms.iter().map(AsRef::as_ref).collect(); + let all_invited_rooms: Vec<&RoomId> = all_invited_rooms + .iter() + .map(AsRef::as_ref) + .collect(); + let all_knocked_rooms: Vec<&RoomId> = all_knocked_rooms + .iter() + .map(AsRef::as_ref) + .collect(); let all_rooms: Vec<&RoomId> = all_joined_rooms .iter() @@ -123,8 +137,14 @@ pub(crate) async fn sync_events_v4_route( .chain(all_knocked_rooms.iter().map(AsRef::as_ref)) .collect(); - let all_joined_rooms = all_joined_rooms.iter().map(AsRef::as_ref).collect(); - let all_invited_rooms = all_invited_rooms.iter().map(AsRef::as_ref).collect(); + let all_joined_rooms = all_joined_rooms + .iter() + .map(AsRef::as_ref) + .collect(); + let all_invited_rooms = all_invited_rooms + .iter() + .map(AsRef::as_ref) + .collect(); if body.extensions.to_device.enabled.unwrap_or(false) { services @@ -143,7 +163,12 @@ pub(crate) async fn sync_events_v4_route( global: Vec::new(), rooms: BTreeMap::new(), }; - if body.extensions.account_data.enabled.unwrap_or(false) { + if body + .extensions + .account_data + .enabled + .unwrap_or(false) + { account_data.global = services .account_data .changes_since(None, sender_user, globalsince, Some(next_batch)) @@ -179,8 +204,11 @@ pub(crate) async fn sync_events_v4_route( for room_id in &all_joined_rooms { let room_id: &&RoomId = room_id; - let Ok(current_shortstatehash) = - services.rooms.state.get_room_shortstatehash(room_id).await + let Ok(current_shortstatehash) = services + .rooms + .state + .get_room_shortstatehash(room_id) + .await else { error!("Room {room_id} has no state"); continue; @@ -373,13 +401,16 @@ pub(crate) async fn sync_events_v4_route( Vec::new() }; - new_known_rooms.extend(room_ids.clone().into_iter().map(ToOwned::to_owned)); + new_known_rooms.extend( + room_ids + .clone() + .into_iter() + .map(ToOwned::to_owned), + ); for room_id in &room_ids { - let todo_room = todo_rooms.entry((*room_id).to_owned()).or_insert(( - BTreeSet::new(), - 0_usize, - u64::MAX, - )); + let todo_room = todo_rooms + .entry((*room_id).to_owned()) + .or_insert((BTreeSet::new(), 0_usize, u64::MAX)); let limit: usize = list .room_details @@ -409,7 +440,10 @@ pub(crate) async fn sync_events_v4_route( op: SlidingOp::Sync, range: Some(r), index: None, - room_ids: room_ids.into_iter().map(ToOwned::to_owned).collect(), + room_ids: room_ids + .into_iter() + .map(ToOwned::to_owned) + .collect(), room_id: None, } }) @@ -575,7 +609,10 @@ pub(crate) async fn sync_events_v4_route( if roomsince != &0 && timeline_pdus.is_empty() - && account_data.rooms.get(room_id).is_some_and(Vec::is_empty) + && account_data + .rooms + .get(room_id) + .is_some_and(Vec::is_empty) && receipt_size == 0 { continue; @@ -610,8 +647,9 @@ pub(crate) async fn sync_events_v4_route( for (_, pdu) in timeline_pdus { let ts = MilliSecondsSinceUnixEpoch(pdu.origin_server_ts); - if DEFAULT_BUMP_TYPES.binary_search(&pdu.kind).is_ok() - && timestamp.is_none_or(|time| time <= ts) + if DEFAULT_BUMP_TYPES + .binary_search(&pdu.kind) + .is_ok() && timestamp.is_none_or(|time| time <= ts) { timestamp = Some(ts); } @@ -658,7 +696,11 @@ pub(crate) async fn sync_events_v4_route( | Ordering::Greater => { let firsts = heroes[1..] .iter() - .map(|h| h.name.clone().unwrap_or_else(|| h.user_id.to_string())) + .map(|h| { + h.name + .clone() + .unwrap_or_else(|| h.user_id.to_string()) + }) .collect::>() .join(", "); @@ -694,7 +736,12 @@ pub(crate) async fn sync_events_v4_route( .or(name), avatar: match heroes_avatar { | Some(heroes_avatar) => ruma::JsOption::Some(heroes_avatar), - | _ => match services.rooms.state_accessor.get_avatar(room_id).await { + | _ => match services + .rooms + .state_accessor + .get_avatar(room_id) + .await + { | ruma::JsOption::Some(avatar) => ruma::JsOption::from_option(avatar.url), | ruma::JsOption::Null => ruma::JsOption::Null, | ruma::JsOption::Undefined => ruma::JsOption::Undefined, @@ -817,9 +864,16 @@ async fn filter_rooms<'a>( .iter() .stream() .filter_map(|r| async move { - let room_type = services.rooms.state_accessor.get_room_type(r).await; + let room_type = services + .rooms + .state_accessor + .get_room_type(r) + .await; - if room_type.as_ref().is_err_and(|e| !e.is_not_found()) { + if room_type + .as_ref() + .is_err_and(|e| !e.is_not_found()) + { return None; } diff --git a/src/api/client/sync/v5.rs b/src/api/client/sync/v5.rs index 207a82a7..85b34afb 100644 --- a/src/api/client/sync/v5.rs +++ b/src/api/client/sync/v5.rs @@ -63,8 +63,14 @@ pub(crate) async fn sync_events_v5_route( body: Ruma, ) -> Result { debug_assert!(DEFAULT_BUMP_TYPES.is_sorted(), "DEFAULT_BUMP_TYPES is not sorted"); - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); - let sender_device = body.sender_device.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); + let sender_device = body + .sender_device + .as_ref() + .expect("user is authenticated"); let mut body = body.body; // Setup watchers, so if there's no response, we can wait for them @@ -90,7 +96,9 @@ pub(crate) async fn sync_events_v5_route( // Client / User requested an initial sync if globalsince == 0 { - services.sync.forget_snake_sync_connection(&snake_key); + services + .sync + .forget_snake_sync_connection(&snake_key); } // Get sticky parameters from cache @@ -191,7 +199,11 @@ pub(crate) async fn sync_events_v5_route( if response.rooms.iter().all(|(id, r)| { r.timeline.is_empty() && r.required_state.is_empty() - && !response.extensions.receipts.rooms.contains_key(id) + && !response + .extensions + .receipts + .rooms + .contains_key(id) }) && response .extensions .to_device @@ -322,8 +334,11 @@ where let room_ids = active_rooms[usize_from_ruma(range.0)..usize_from_ruma(range.1)].to_vec(); - let new_rooms: BTreeSet = - room_ids.clone().into_iter().map(From::from).collect(); + let new_rooms: BTreeSet = room_ids + .clone() + .into_iter() + .map(From::from) + .collect(); new_known_rooms.extend(new_rooms); //new_known_rooms.extend(room_ids..cloned()); @@ -394,7 +409,10 @@ where let mut invite_state = None; let (timeline_pdus, limited); let new_room_id: &RoomId = (*room_id).as_ref(); - if all_invited_rooms.clone().any(is_equal_to!(new_room_id)) { + if all_invited_rooms + .clone() + .any(is_equal_to!(new_room_id)) + { // TODO: figure out a timestamp we can use for remote invites invite_state = services .rooms @@ -521,8 +539,9 @@ where for (_, pdu) in timeline_pdus { let ts = pdu.origin_server_ts; - if DEFAULT_BUMP_TYPES.binary_search(&pdu.kind).is_ok() - && timestamp.is_none_or(|time| time <= ts) + if DEFAULT_BUMP_TYPES + .binary_search(&pdu.kind) + .is_ok() && timestamp.is_none_or(|time| time <= ts) { timestamp = Some(ts); } @@ -569,7 +588,11 @@ where | Ordering::Greater => { let firsts = heroes[1..] .iter() - .map(|h| h.name.clone().unwrap_or_else(|| h.user_id.to_string())) + .map(|h| { + h.name + .clone() + .unwrap_or_else(|| h.user_id.to_string()) + }) .collect::>() .join(", "); @@ -605,7 +628,12 @@ where .or(name), avatar: match heroes_avatar { | Some(heroes_avatar) => ruma::JsOption::Some(heroes_avatar), - | _ => match services.rooms.state_accessor.get_avatar(room_id).await { + | _ => match services + .rooms + .state_accessor + .get_avatar(room_id) + .await + { | ruma::JsOption::Some(avatar) => ruma::JsOption::from_option(avatar.url), | ruma::JsOption::Null => ruma::JsOption::Null, | ruma::JsOption::Undefined => ruma::JsOption::Undefined, @@ -674,7 +702,12 @@ async fn collect_account_data( rooms: BTreeMap::new(), }; - if !body.extensions.account_data.enabled.unwrap_or(false) { + if !body + .extensions + .account_data + .enabled + .unwrap_or(false) + { return sync_events::v5::response::AccountData::default(); } @@ -732,8 +765,11 @@ where ); for room_id in all_joined_rooms { - let Ok(current_shortstatehash) = - services.rooms.state.get_room_shortstatehash(room_id).await + let Ok(current_shortstatehash) = services + .rooms + .state + .get_room_shortstatehash(room_id) + .await else { error!("Room {room_id} has no state"); continue; @@ -934,9 +970,16 @@ where Rooms: Stream + Send + 'a, { rooms.filter_map(async |room_id| { - let room_type = services.rooms.state_accessor.get_room_type(room_id).await; + let room_type = services + .rooms + .state_accessor + .get_room_type(room_id) + .await; - if room_type.as_ref().is_err_and(|e| !e.is_not_found()) { + if room_type + .as_ref() + .is_err_and(|e| !e.is_not_found()) + { return None; } diff --git a/src/api/client/tag.rs b/src/api/client/tag.rs index 579c8d36..3919b393 100644 --- a/src/api/client/tag.rs +++ b/src/api/client/tag.rs @@ -21,7 +21,10 @@ pub(crate) async fn update_tag_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let mut tags_event = services .account_data @@ -58,7 +61,10 @@ pub(crate) async fn delete_tag_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let mut tags_event = services .account_data @@ -68,7 +74,10 @@ pub(crate) async fn delete_tag_route( content: TagEventContent { tags: BTreeMap::new() }, }); - tags_event.content.tags.remove(&body.tag.clone().into()); + tags_event + .content + .tags + .remove(&body.tag.clone().into()); services .account_data @@ -92,7 +101,10 @@ pub(crate) async fn get_tags_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let tags_event = services .account_data diff --git a/src/api/client/to_device.rs b/src/api/client/to_device.rs index 19d38627..003d01b3 100644 --- a/src/api/client/to_device.rs +++ b/src/api/client/to_device.rs @@ -21,7 +21,10 @@ pub(crate) async fn send_event_to_device_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); let sender_device = body.sender_device.as_deref(); // Check if this is a new transaction id diff --git a/src/api/client/typing.rs b/src/api/client/typing.rs index 78e5512c..6841b58f 100644 --- a/src/api/client/typing.rs +++ b/src/api/client/typing.rs @@ -30,7 +30,10 @@ pub(crate) async fn create_typing_event_route( match body.state { | Typing::Yes(duration) => { let duration = utils::clamp( - duration.as_millis().try_into().unwrap_or(u64::MAX), + duration + .as_millis() + .try_into() + .unwrap_or(u64::MAX), services .server .config diff --git a/src/api/client/unstable.rs b/src/api/client/unstable.rs index 47a2d1ff..2282f18f 100644 --- a/src/api/client/unstable.rs +++ b/src/api/client/unstable.rs @@ -69,7 +69,10 @@ pub(crate) async fn delete_timezone_key_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if *sender_user != body.user_id && body.appservice_info.is_none() { return Err!(Request(Forbidden("You cannot update the profile of another user"))); @@ -97,13 +100,18 @@ pub(crate) async fn set_timezone_key_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if *sender_user != body.user_id && body.appservice_info.is_none() { return Err!(Request(Forbidden("You cannot update the profile of another user"))); } - services.users.set_timezone(&body.user_id, body.tz.clone()); + services + .users + .set_timezone(&body.user_id, body.tz.clone()); if services.config.allow_local_presence { // Presence update @@ -125,7 +133,10 @@ pub(crate) async fn set_profile_key_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if *sender_user != body.user_id && body.appservice_info.is_none() { return Err!(Request(Forbidden("You cannot update the profile of another user"))); @@ -218,7 +229,10 @@ pub(crate) async fn delete_profile_key_route( State(services): State, body: Ruma, ) -> Result { - let sender_user = body.sender_user.as_ref().expect("user is authenticated"); + let sender_user = body + .sender_user + .as_ref() + .expect("user is authenticated"); if *sender_user != body.user_id && body.appservice_info.is_none() { return Err!(Request(Forbidden("You cannot update the profile of another user"))); diff --git a/src/api/client/user_directory.rs b/src/api/client/user_directory.rs index 31013c68..c0119f2b 100644 --- a/src/api/client/user_directory.rs +++ b/src/api/client/user_directory.rs @@ -37,7 +37,12 @@ pub(crate) async fn search_users_route( let mut users = services .users .stream() - .ready_filter(|user_id| user_id.as_str().to_lowercase().contains(&search_term)) + .ready_filter(|user_id| { + user_id + .as_str() + .to_lowercase() + .contains(&search_term) + }) .map(ToOwned::to_owned) .broad_filter_map(async |user_id| { let display_name = services.users.displayname(&user_id).await.ok(); diff --git a/src/api/client/well_known.rs b/src/api/client/well_known.rs index 64b4af67..9c6e0542 100644 --- a/src/api/client/well_known.rs +++ b/src/api/client/well_known.rs @@ -45,15 +45,30 @@ pub(crate) async fn well_known_support( .as_ref() .map(ToString::to_string); - let role = services.server.config.well_known.support_role.clone(); + let role = services + .server + .config + .well_known + .support_role + .clone(); // support page or role must be either defined for this to be valid if support_page.is_none() && role.is_none() { return Err(Error::BadRequest(ErrorKind::NotFound, "Not found.")); } - let email_address = services.server.config.well_known.support_email.clone(); - let matrix_id = services.server.config.well_known.support_mxid.clone(); + let email_address = services + .server + .config + .well_known + .support_email + .clone(); + let matrix_id = services + .server + .config + .well_known + .support_mxid + .clone(); // if a role is specified, an email address or matrix id is required if role.is_some() && (email_address.is_none() && matrix_id.is_none()) { diff --git a/src/api/router/args.rs b/src/api/router/args.rs index a10cdfd9..87c49bea 100644 --- a/src/api/router/args.rs +++ b/src/api/router/args.rs @@ -140,9 +140,13 @@ fn into_http_request(request: &Request, body: Bytes) -> hyper::Request { .uri(request.parts.uri.clone()) .method(request.parts.method.clone()); - *http_request.headers_mut().expect("mutable http headers") = request.parts.headers.clone(); + *http_request + .headers_mut() + .expect("mutable http headers") = request.parts.headers.clone(); - let http_request = http_request.body(body).expect("http request body"); + let http_request = http_request + .body(body) + .expect("http request body"); let headers = http_request.headers(); let method = http_request.method(); diff --git a/src/api/router/auth.rs b/src/api/router/auth.rs index b4a73fee..f8ca4d3f 100644 --- a/src/api/router/auth.rs +++ b/src/api/router/auth.rs @@ -93,7 +93,11 @@ pub(super) async fn auth( | &get_display_name::v3::Request::METADATA | &get_avatar_url::v3::Request::METADATA | &get_timezone_key::unstable::Request::METADATA => { - if services.server.config.require_auth_for_profile_requests { + if services + .server + .config + .require_auth_for_profile_requests + { match token { | Token::Appservice(_) | Token::User(_) => { // we should have validated the token above diff --git a/src/api/router/response.rs b/src/api/router/response.rs index 9468eb60..419d05cc 100644 --- a/src/api/router/response.rs +++ b/src/api/router/response.rs @@ -23,7 +23,11 @@ where .inspect_err(|e| error!("response error: {e}")) .map_or_else( |_| StatusCode::INTERNAL_SERVER_ERROR.into_response(), - |r| r.map(BytesMut::freeze).map(Full::new).into_response(), + |r| { + r.map(BytesMut::freeze) + .map(Full::new) + .into_response() + }, ) } } diff --git a/src/api/server/event_auth.rs b/src/api/server/event_auth.rs index 53965c97..09394362 100644 --- a/src/api/server/event_auth.rs +++ b/src/api/server/event_auth.rs @@ -49,8 +49,19 @@ pub(crate) async fn get_event_authorization_route( .auth_chain .event_ids_iter(room_id, once(body.event_id.borrow())) .ready_filter_map(Result::ok) - .filter_map(|id| async move { services.rooms.timeline.get_pdu_json(&id).await.ok() }) - .then(|pdu| services.sending.convert_to_outgoing_federation_event(pdu)) + .filter_map(|id| async move { + services + .rooms + .timeline + .get_pdu_json(&id) + .await + .ok() + }) + .then(|pdu| { + services + .sending + .convert_to_outgoing_federation_event(pdu) + }) .collect() .await; diff --git a/src/api/server/get_missing_events.rs b/src/api/server/get_missing_events.rs index 1737db57..9824b9ea 100644 --- a/src/api/server/get_missing_events.rs +++ b/src/api/server/get_missing_events.rs @@ -38,7 +38,12 @@ pub(crate) async fn get_missing_events_route( let mut i: usize = 0; while i < queued_events.len() && events.len() < limit { - let Ok(pdu) = services.rooms.timeline.get_pdu(&queued_events[i]).await else { + let Ok(pdu) = services + .rooms + .timeline + .get_pdu(&queued_events[i]) + .await + else { debug!( ?body.origin, "Event {} does not exist locally, skipping", &queued_events[i] diff --git a/src/api/server/hierarchy.rs b/src/api/server/hierarchy.rs index 2fa97fea..d53c5440 100644 --- a/src/api/server/hierarchy.rs +++ b/src/api/server/hierarchy.rs @@ -17,7 +17,12 @@ pub(crate) async fn get_hierarchy_route( State(services): State, body: Ruma, ) -> Result { - if !services.rooms.metadata.exists(&body.room_id).await { + if !services + .rooms + .metadata + .exists(&body.room_id) + .await + { return Err!(Request(NotFound("Room does not exist."))); } @@ -60,8 +65,15 @@ pub(crate) async fn get_hierarchy_route( .unzip() .map(|(children, inaccessible_children): (Vec<_>, Vec<_>)| { ( - children.into_iter().flatten().map(Into::into).collect(), - inaccessible_children.into_iter().flatten().collect(), + children + .into_iter() + .flatten() + .map(Into::into) + .collect(), + inaccessible_children + .into_iter() + .flatten() + .collect(), ) }) .await; diff --git a/src/api/server/invite.rs b/src/api/server/invite.rs index f7b9e9c2..3f722d3d 100644 --- a/src/api/server/invite.rs +++ b/src/api/server/invite.rs @@ -29,7 +29,10 @@ pub(crate) async fn create_invite_route( .acl_check(body.origin(), &body.room_id) .await?; - if !services.server.supported_room_version(&body.room_version) { + if !services + .server + .supported_room_version(&body.room_version) + { return Err(Error::BadRequest( ErrorKind::IncompatibleRoomVersion { room_version: body.room_version.clone() }, "Server does not support this room version.", @@ -69,7 +72,10 @@ pub(crate) async fn create_invite_route( .map(UserId::to_owned) .map_err(|e| err!(Request(InvalidParam("Invalid state_key property: {e}"))))?; - if !services.globals.server_is_ours(invited_user.server_name()) { + if !services + .globals + .server_is_ours(invited_user.server_name()) + { return Err!(Request(InvalidParam("User does not belong to this homeserver."))); } @@ -96,8 +102,11 @@ pub(crate) async fn create_invite_route( .try_into() .map_err(|e| err!(Request(InvalidParam("Invalid sender property: {e}"))))?; - if services.rooms.metadata.is_banned(&body.room_id).await - && !services.users.is_admin(&invited_user).await + if services + .rooms + .metadata + .is_banned(&body.room_id) + .await && !services.users.is_admin(&invited_user).await { return Err!(Request(Forbidden("This room is banned on this homeserver."))); } diff --git a/src/api/server/key.rs b/src/api/server/key.rs index 1655ec01..0ce7f9da 100644 --- a/src/api/server/key.rs +++ b/src/api/server/key.rs @@ -27,7 +27,10 @@ pub(crate) async fn get_server_keys_route( ) -> Result { let server_name = services.globals.server_name(); let active_key_id = services.server_keys.active_key_id(); - let mut all_keys = services.server_keys.verify_keys_for(server_name).await; + let mut all_keys = services + .server_keys + .verify_keys_for(server_name) + .await; let verify_keys = all_keys .remove_entry(active_key_id) diff --git a/src/api/server/make_join.rs b/src/api/server/make_join.rs index 0a46e83d..506a3038 100644 --- a/src/api/server/make_join.rs +++ b/src/api/server/make_join.rs @@ -26,7 +26,12 @@ pub(crate) async fn create_join_event_template_route( State(services): State, body: Ruma, ) -> Result { - if !services.rooms.metadata.exists(&body.room_id).await { + if !services + .rooms + .metadata + .exists(&body.room_id) + .await + { return Err!(Request(NotFound("Room is unknown to this server."))); } @@ -68,7 +73,11 @@ pub(crate) async fn create_join_event_template_route( } } - let room_version_id = services.rooms.state.get_room_version(&body.room_id).await?; + let room_version_id = services + .rooms + .state + .get_room_version(&body.room_id) + .await?; if !body.ver.contains(&room_version_id) { return Err(Error::BadRequest( ErrorKind::IncompatibleRoomVersion { room_version: room_version_id }, @@ -76,7 +85,12 @@ pub(crate) async fn create_join_event_template_route( )); } - let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; + let state_lock = services + .rooms + .state + .mutex + .lock(&body.room_id) + .await; let join_authorized_via_users_server: Option = { use RoomVersionId::*; @@ -157,7 +171,12 @@ pub(crate) async fn user_can_perform_restricted_join( return Ok(false); } - if services.rooms.state_cache.is_joined(user_id, room_id).await { + if services + .rooms + .state_cache + .is_joined(user_id, room_id) + .await + { // joining user is already joined, there is nothing we need to do return Ok(false); } @@ -196,7 +215,12 @@ pub(crate) async fn user_can_perform_restricted_join( } }) .stream() - .any(|m| services.rooms.state_cache.is_joined(user_id, &m.room_id)) + .any(|m| { + services + .rooms + .state_cache + .is_joined(user_id, &m.room_id) + }) .await { Ok(true) diff --git a/src/api/server/make_knock.rs b/src/api/server/make_knock.rs index 4a07e9f4..310bbd0e 100644 --- a/src/api/server/make_knock.rs +++ b/src/api/server/make_knock.rs @@ -17,7 +17,12 @@ pub(crate) async fn create_knock_event_template_route( State(services): State, body: Ruma, ) -> Result { - if !services.rooms.metadata.exists(&body.room_id).await { + if !services + .rooms + .metadata + .exists(&body.room_id) + .await + { return Err!(Request(NotFound("Room is unknown to this server."))); } @@ -57,7 +62,11 @@ pub(crate) async fn create_knock_event_template_route( } } - let room_version_id = services.rooms.state.get_room_version(&body.room_id).await?; + let room_version_id = services + .rooms + .state + .get_room_version(&body.room_id) + .await?; if matches!(room_version_id, V1 | V2 | V3 | V4 | V5 | V6) { return Err(Error::BadRequest( @@ -73,7 +82,12 @@ pub(crate) async fn create_knock_event_template_route( )); } - let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; + let state_lock = services + .rooms + .state + .mutex + .lock(&body.room_id) + .await; if let Ok(membership) = services .rooms diff --git a/src/api/server/make_leave.rs b/src/api/server/make_leave.rs index 50e32107..09e6586b 100644 --- a/src/api/server/make_leave.rs +++ b/src/api/server/make_leave.rs @@ -16,7 +16,12 @@ pub(crate) async fn create_leave_event_template_route( State(services): State, body: Ruma, ) -> Result { - if !services.rooms.metadata.exists(&body.room_id).await { + if !services + .rooms + .metadata + .exists(&body.room_id) + .await + { return Err!(Request(NotFound("Room is unknown to this server."))); } @@ -33,8 +38,17 @@ pub(crate) async fn create_leave_event_template_route( .acl_check(body.origin(), &body.room_id) .await?; - let room_version_id = services.rooms.state.get_room_version(&body.room_id).await?; - let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; + let room_version_id = services + .rooms + .state + .get_room_version(&body.room_id) + .await?; + let state_lock = services + .rooms + .state + .mutex + .lock(&body.room_id) + .await; let (_pdu, mut pdu_json) = services .rooms diff --git a/src/api/server/query.rs b/src/api/server/query.rs index 2862b65e..260d9a25 100644 --- a/src/api/server/query.rs +++ b/src/api/server/query.rs @@ -73,7 +73,10 @@ pub(crate) async fn get_profile_information_route( )); } - if !services.globals.server_is_ours(body.user_id.server_name()) { + if !services + .globals + .server_is_ours(body.user_id.server_name()) + { return Err(Error::BadRequest( ErrorKind::InvalidParam, "User does not belong to this server.", @@ -88,10 +91,18 @@ pub(crate) async fn get_profile_information_route( match &body.field { | Some(ProfileField::DisplayName) => { - displayname = services.users.displayname(&body.user_id).await.ok(); + displayname = services + .users + .displayname(&body.user_id) + .await + .ok(); }, | Some(ProfileField::AvatarUrl) => { - avatar_url = services.users.avatar_url(&body.user_id).await.ok(); + avatar_url = services + .users + .avatar_url(&body.user_id) + .await + .ok(); blurhash = services.users.blurhash(&body.user_id).await.ok(); }, | Some(custom_field) => { @@ -104,8 +115,16 @@ pub(crate) async fn get_profile_information_route( } }, | None => { - displayname = services.users.displayname(&body.user_id).await.ok(); - avatar_url = services.users.avatar_url(&body.user_id).await.ok(); + displayname = services + .users + .displayname(&body.user_id) + .await + .ok(); + avatar_url = services + .users + .avatar_url(&body.user_id) + .await + .ok(); blurhash = services.users.blurhash(&body.user_id).await.ok(); tz = services.users.timezone(&body.user_id).await.ok(); custom_profile_fields = services diff --git a/src/api/server/send.rs b/src/api/server/send.rs index 299d6c6a..3d5fe8a9 100644 --- a/src/api/server/send.rs +++ b/src/api/server/send.rs @@ -92,7 +92,12 @@ pub(crate) async fn send_transaction_message_route( .pdus .iter() .stream() - .broad_then(|pdu| services.rooms.event_handler.parse_incoming_pdu(pdu)) + .broad_then(|pdu| { + services + .rooms + .event_handler + .parse_incoming_pdu(pdu) + }) .inspect_err(|e| debug_warn!("Could not parse PDU: {e}")) .ready_filter_map(Result::ok); @@ -215,7 +220,11 @@ async fn handle_edu(services: &Services, client: &IpAddr, origin: &ServerName, e | Edu::Presence(presence) if services.server.config.allow_incoming_presence => handle_edu_presence(services, client, origin, presence).await, - | Edu::Receipt(receipt) if services.server.config.allow_incoming_read_receipts => + | Edu::Receipt(receipt) + if services + .server + .config + .allow_incoming_read_receipts => handle_edu_receipt(services, client, origin, receipt).await, | Edu::Typing(typing) if services.server.config.allow_incoming_typing => @@ -454,7 +463,10 @@ async fn handle_edu_device_list_update( return; } - services.users.mark_device_key_update(&user_id).await; + services + .users + .mark_device_key_update(&user_id) + .await; } async fn handle_edu_direct_to_device( diff --git a/src/api/server/send_join.rs b/src/api/server/send_join.rs index 97934cf7..58636887 100644 --- a/src/api/server/send_join.rs +++ b/src/api/server/send_join.rs @@ -53,7 +53,11 @@ async fn create_join_event( // We do not add the event_id field to the pdu here because of signature and // hashes checks - let room_version_id = services.rooms.state.get_room_version(room_id).await?; + let room_version_id = services + .rooms + .state + .get_room_version(room_id) + .await?; let Ok((event_id, mut value)) = gen_event_id_canonical_json(pdu, &room_version_id) else { // Event could not be converted to canonical json @@ -239,7 +243,11 @@ async fn create_join_event( .auth_chain .event_ids_iter(room_id, starting_events) .broad_and_then(|event_id| async move { - services.rooms.timeline.get_pdu_json(&event_id).await + services + .rooms + .timeline + .get_pdu_json(&event_id) + .await }) .broad_and_then(|pdu| { services @@ -251,7 +259,10 @@ async fn create_join_event( .boxed() .await?; - services.sending.send_pdu_room(room_id, &pdu_id).await?; + services + .sending + .send_pdu_room(room_id, &pdu_id) + .await?; Ok(create_join_event::v1::RoomState { auth_chain, diff --git a/src/api/server/send_knock.rs b/src/api/server/send_knock.rs index 8b9c50d7..bf7cc811 100644 --- a/src/api/server/send_knock.rs +++ b/src/api/server/send_knock.rs @@ -55,7 +55,12 @@ pub(crate) async fn create_knock_event_v1_route( } } - if !services.rooms.metadata.exists(&body.room_id).await { + if !services + .rooms + .metadata + .exists(&body.room_id) + .await + { return Err!(Request(NotFound("Room is unknown to this server."))); } @@ -66,7 +71,11 @@ pub(crate) async fn create_knock_event_v1_route( .acl_check(body.origin(), &body.room_id) .await?; - let room_version_id = services.rooms.state.get_room_version(&body.room_id).await?; + let room_version_id = services + .rooms + .state + .get_room_version(&body.room_id) + .await?; if matches!(room_version_id, V1 | V2 | V3 | V4 | V5 | V6) { return Err!(Request(Forbidden("Room version does not support knocking."))); diff --git a/src/api/server/send_leave.rs b/src/api/server/send_leave.rs index 8b2f26e0..dd98dccf 100644 --- a/src/api/server/send_leave.rs +++ b/src/api/server/send_leave.rs @@ -59,7 +59,11 @@ async fn create_leave_event( // We do not add the event_id field to the pdu here because of signature and // hashes checks - let room_version_id = services.rooms.state.get_room_version(room_id).await?; + let room_version_id = services + .rooms + .state + .get_room_version(room_id) + .await?; let Ok((event_id, value)) = gen_event_id_canonical_json(pdu, &room_version_id) else { // Event could not be converted to canonical json return Err!(Request(BadJson("Could not convert event to canonical json."))); diff --git a/src/api/server/utils.rs b/src/api/server/utils.rs index 9182b018..f7031678 100644 --- a/src/api/server/utils.rs +++ b/src/api/server/utils.rs @@ -43,11 +43,10 @@ pub(super) async fn check(&self) -> Result { let server_can_see: OptionFuture<_> = self .event_id .map(|event_id| { - self.services.rooms.state_accessor.server_can_see_event( - self.origin, - self.room_id, - event_id, - ) + self.services + .rooms + .state_accessor + .server_can_see_event(self.origin, self.room_id, event_id) }) .into(); diff --git a/src/core/alloc/je.rs b/src/core/alloc/je.rs index 2424e99c..ad1a6ce6 100644 --- a/src/core/alloc/je.rs +++ b/src/core/alloc/je.rs @@ -369,7 +369,11 @@ where fn key(name: &str) -> Result { // tikv asserts the output buffer length is tight to the number of required mibs // so we slice that down here. - let segs = name.chars().filter(is_equal_to!(&'.')).count().try_add(1)?; + let segs = name + .chars() + .filter(is_equal_to!(&'.')) + .count() + .try_add(1)?; let name = self::name(name)?; let mut buf = [0_usize; KEY_SEGS]; diff --git a/src/core/config/check.rs b/src/core/config/check.rs index 505dfd91..fdc4247e 100644 --- a/src/core/config/check.rs +++ b/src/core/config/check.rs @@ -150,15 +150,18 @@ pub fn check(config: &Config) -> Result { } // check if we can read the token file path, and check if the file is empty - if config.registration_token_file.as_ref().is_some_and(|path| { - let Ok(token) = std::fs::read_to_string(path).inspect_err(|e| { - error!("Failed to read the registration token file: {e}"); - }) else { - return true; - }; + if config + .registration_token_file + .as_ref() + .is_some_and(|path| { + let Ok(token) = std::fs::read_to_string(path).inspect_err(|e| { + error!("Failed to read the registration token file: {e}"); + }) else { + return true; + }; - token == String::new() - }) { + token == String::new() + }) { return Err!(Config( "registration_token_file", "Registration token file was specified but is empty or failed to be read" diff --git a/src/core/config/mod.rs b/src/core/config/mod.rs index 27885937..0a63105d 100644 --- a/src/core/config/mod.rs +++ b/src/core/config/mod.rs @@ -2218,8 +2218,12 @@ fn default_admin_room_tag() -> String { "m.server_notice".to_owned() } fn parallelism_scaled_f64(val: f64) -> f64 { val * (sys::available_parallelism() as f64) } fn parallelism_scaled_u32(val: u32) -> u32 { - let val = val.try_into().expect("failed to cast u32 to usize"); - parallelism_scaled(val).try_into().unwrap_or(u32::MAX) + let val = val + .try_into() + .expect("failed to cast u32 to usize"); + parallelism_scaled(val) + .try_into() + .unwrap_or(u32::MAX) } fn parallelism_scaled(val: usize) -> usize { val.saturating_mul(sys::available_parallelism()) } diff --git a/src/core/config/proxy.rs b/src/core/config/proxy.rs index ea388f24..a8023b46 100644 --- a/src/core/config/proxy.rs +++ b/src/core/config/proxy.rs @@ -46,7 +46,10 @@ impl ProxyConfig { | Self::Global { url } => Some(Proxy::all(url)?), | Self::ByDomain(proxies) => Some(Proxy::custom(move |url| { // first matching proxy - proxies.iter().find_map(|proxy| proxy.for_url(url)).cloned() + proxies + .iter() + .find_map(|proxy| proxy.for_url(url)) + .cloned() })), }) } diff --git a/src/core/debug.rs b/src/core/debug.rs index 8a850b4d..71e23801 100644 --- a/src/core/debug.rs +++ b/src/core/debug.rs @@ -100,7 +100,9 @@ pub fn trap() { #[must_use] pub fn panic_str(p: &Box) -> &'static str { - p.downcast_ref::<&str>().copied().unwrap_or_default() + p.downcast_ref::<&str>() + .copied() + .unwrap_or_default() } #[inline(always)] diff --git a/src/core/error/mod.rs b/src/core/error/mod.rs index 162165da..5c869249 100644 --- a/src/core/error/mod.rs +++ b/src/core/error/mod.rs @@ -184,7 +184,9 @@ impl Error { | Self::Request(kind, _, code) => response::status_code(kind, *code), | Self::BadRequest(kind, ..) => response::bad_request_code(kind), | Self::FeatureDisabled(..) => response::bad_request_code(&self.kind()), - | Self::Reqwest(error) => error.status().unwrap_or(StatusCode::INTERNAL_SERVER_ERROR), + | Self::Reqwest(error) => error + .status() + .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR), | Self::Conflict(_) => StatusCode::CONFLICT, | Self::Io(error) => response::io_error_code(error.kind()), | _ => StatusCode::INTERNAL_SERVER_ERROR, diff --git a/src/core/error/response.rs b/src/core/error/response.rs index ae6fce62..7d07b5a1 100644 --- a/src/core/error/response.rs +++ b/src/core/error/response.rs @@ -20,7 +20,11 @@ impl axum::response::IntoResponse for Error { .inspect_err(|e| error!("error response error: {e}")) .map_or_else( |_| StatusCode::INTERNAL_SERVER_ERROR.into_response(), - |r| r.map(BytesMut::freeze).map(Full::new).into_response(), + |r| { + r.map(BytesMut::freeze) + .map(Full::new) + .into_response() + }, ) } } diff --git a/src/core/info/cargo.rs b/src/core/info/cargo.rs index 0a747bb8..6da8fc30 100644 --- a/src/core/info/cargo.rs +++ b/src/core/info/cargo.rs @@ -42,7 +42,10 @@ static DEPENDENCIES: OnceLock = OnceLock::new(); #[must_use] pub fn dependencies_names() -> Vec<&'static str> { - dependencies().keys().map(String::as_str).collect() + dependencies() + .keys() + .map(String::as_str) + .collect() } pub fn dependencies() -> &'static DepsSet { diff --git a/src/core/info/room_version.rs b/src/core/info/room_version.rs index 51d5d3c6..e29eda2b 100644 --- a/src/core/info/room_version.rs +++ b/src/core/info/room_version.rs @@ -25,7 +25,8 @@ type RoomVersion = (RoomVersionId, RoomVersionStability); impl crate::Server { #[inline] pub fn supported_room_version(&self, version: &RoomVersionId) -> bool { - self.supported_room_versions().any(is_equal_to!(*version)) + self.supported_room_versions() + .any(is_equal_to!(*version)) } #[inline] diff --git a/src/core/log/capture/data.rs b/src/core/log/capture/data.rs index a4a1225b..9d9dae99 100644 --- a/src/core/log/capture/data.rs +++ b/src/core/log/capture/data.rs @@ -20,10 +20,19 @@ impl Data<'_> { pub fn level(&self) -> Level { *self.event.metadata().level() } #[must_use] - pub fn mod_name(&self) -> &str { self.event.metadata().module_path().unwrap_or_default() } + pub fn mod_name(&self) -> &str { + self.event + .metadata() + .module_path() + .unwrap_or_default() + } #[must_use] - pub fn span_name(&self) -> &str { self.current.metadata().map_or(EMPTY, |s| s.name()) } + pub fn span_name(&self) -> &str { + self.current + .metadata() + .map_or(EMPTY, |s| s.name()) + } #[must_use] pub fn message(&self) -> &str { diff --git a/src/core/log/console.rs b/src/core/log/console.rs index d91239ac..d5f03227 100644 --- a/src/core/log/console.rs +++ b/src/core/log/console.rs @@ -103,8 +103,10 @@ where writer: Writer<'_>, event: &Event<'_>, ) -> Result<(), std::fmt::Error> { - let is_debug = - cfg!(debug_assertions) && event.fields().any(|field| field.name() == "_debug"); + let is_debug = cfg!(debug_assertions) + && event + .fields() + .any(|field| field.name() == "_debug"); match *event.metadata().level() { | Level::ERROR if !is_debug => self.pretty.format_event(ctx, writer, event), diff --git a/src/core/log/reload.rs b/src/core/log/reload.rs index e6a16c9f..9dd3cd7b 100644 --- a/src/core/log/reload.rs +++ b/src/core/log/reload.rs @@ -56,7 +56,9 @@ impl LogLevelReloadHandles { .iter() .filter(|(name, _)| names.is_some_and(|names| names.contains(&name.as_str()))) .for_each(|(_, handle)| { - _ = handle.reload(new_value.clone()).or_else(error::else_log); + _ = handle + .reload(new_value.clone()) + .or_else(error::else_log); }); Ok(()) diff --git a/src/core/matrix/pdu/filter.rs b/src/core/matrix/pdu/filter.rs index aabf13db..d9c2c269 100644 --- a/src/core/matrix/pdu/filter.rs +++ b/src/core/matrix/pdu/filter.rs @@ -58,7 +58,11 @@ fn matches_sender(&self, filter: &RoomEventFilter) -> bool { #[implement(super::Pdu)] fn matches_type(&self, filter: &RoomEventFilter) -> bool { let event_type = &self.kind.to_cow_str(); - if filter.not_types.iter().any(is_equal_to!(event_type)) { + if filter + .not_types + .iter() + .any(is_equal_to!(event_type)) + { return false; } diff --git a/src/core/matrix/pdu/raw_id.rs b/src/core/matrix/pdu/raw_id.rs index 318a0cd7..effb72e4 100644 --- a/src/core/matrix/pdu/raw_id.rs +++ b/src/core/matrix/pdu/raw_id.rs @@ -97,7 +97,11 @@ impl From for RawId { match id.shorteventid { | Count::Normal(shorteventid) => { vec.extend(shorteventid.to_be_bytes()); - Self::Normal(vec.as_ref().try_into().expect("RawVec into RawId::Normal")) + Self::Normal( + vec.as_ref() + .try_into() + .expect("RawVec into RawId::Normal"), + ) }, | Count::Backfilled(shorteventid) => { vec.extend(0_u64.to_be_bytes()); diff --git a/src/core/matrix/pdu/unsigned.rs b/src/core/matrix/pdu/unsigned.rs index 23897519..6139ec71 100644 --- a/src/core/matrix/pdu/unsigned.rs +++ b/src/core/matrix/pdu/unsigned.rs @@ -102,7 +102,8 @@ where #[implement(Pdu)] #[must_use] pub fn get_unsigned_as_value(&self) -> JsonValue { - self.get_unsigned::().unwrap_or_default() + self.get_unsigned::() + .unwrap_or_default() } #[implement(Pdu)] diff --git a/src/core/matrix/state_res/event_auth.rs b/src/core/matrix/state_res/event_auth.rs index 8c9339ec..0328430c 100644 --- a/src/core/matrix/state_res/event_auth.rs +++ b/src/core/matrix/state_res/event_auth.rs @@ -104,7 +104,10 @@ pub fn auth_types_for_event( } if membership == MembershipState::Invite { - if let Some(Ok(t_id)) = content.third_party_invite.map(|t| t.deserialize()) { + if let Some(Ok(t_id)) = content + .third_party_invite + .map(|t| t.deserialize()) + { let key = (StateEventType::RoomThirdPartyInvite, t_id.signed.token.into()); if !auth_types.contains(&key) { @@ -564,9 +567,12 @@ fn valid_membership_change( } let power_levels_event_id = power_levels_event.as_ref().map(Event::event_id); - let sender_membership_event_id = sender_membership_event.as_ref().map(Event::event_id); - let target_user_membership_event_id = - target_user_membership_event.as_ref().map(Event::event_id); + let sender_membership_event_id = sender_membership_event + .as_ref() + .map(Event::event_id); + let target_user_membership_event_id = target_user_membership_event + .as_ref() + .map(Event::event_id); let user_for_join_auth_is_valid = if let Some(user_for_join_auth) = user_for_join_auth { // Is the authorised user allowed to invite users into this room @@ -725,7 +731,9 @@ fn valid_membership_change( allow } else if !sender_is_joined || target_user_current_membership == MembershipState::Ban - && sender_power.filter(|&p| p < &power_levels.ban).is_some() + && sender_power + .filter(|&p| p < &power_levels.ban) + .is_some() { warn!( ?target_user_membership_event_id, @@ -734,8 +742,9 @@ fn valid_membership_change( ); false } else { - let allow = sender_power.filter(|&p| p >= &power_levels.kick).is_some() - && target_power < sender_power; + let allow = sender_power + .filter(|&p| p >= &power_levels.kick) + .is_some() && target_power < sender_power; if !allow { warn!( ?target_user_membership_event_id, @@ -750,8 +759,9 @@ fn valid_membership_change( warn!(?sender_membership_event_id, "Can't ban user if sender is not joined"); false } else { - let allow = sender_power.filter(|&p| p >= &power_levels.ban).is_some() - && target_power < sender_power; + let allow = sender_power + .filter(|&p| p >= &power_levels.ban) + .is_some() && target_power < sender_power; if !allow { warn!( ?target_user_membership_event_id, @@ -829,7 +839,9 @@ fn can_send_event(event: impl Event, ple: Option, user_level: Int) - return false; } - if event.state_key().is_some_and(|k| k.starts_with('@')) + if event + .state_key() + .is_some_and(|k| k.starts_with('@')) && event.state_key() != Some(event.sender().as_str()) { return false; // permission required to post in this room @@ -1040,13 +1052,17 @@ fn get_send_level( .and_then(|ple| { from_json_str::(ple.content().get()) .map(|content| { - content.events.get(e_type).copied().unwrap_or_else(|| { - if state_key.is_some() { - content.state_default - } else { - content.events_default - } - }) + content + .events + .get(e_type) + .copied() + .unwrap_or_else(|| { + if state_key.is_some() { + content.state_default + } else { + content.events_default + } + }) }) .ok() }) @@ -1135,13 +1151,21 @@ mod tests { #[test] fn test_ban_pass() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = INITIAL_EVENTS(); let auth_events = events .values() - .map(|ev| (ev.event_type().with_state_key(ev.state_key().unwrap()), ev.clone())) + .map(|ev| { + ( + ev.event_type() + .with_state_key(ev.state_key().unwrap()), + ev.clone(), + ) + }) .collect::>(); let requester = to_pdu_event( @@ -1180,13 +1204,21 @@ mod tests { #[test] fn test_join_non_creator() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = INITIAL_EVENTS_CREATE_ROOM(); let auth_events = events .values() - .map(|ev| (ev.event_type().with_state_key(ev.state_key().unwrap()), ev.clone())) + .map(|ev| { + ( + ev.event_type() + .with_state_key(ev.state_key().unwrap()), + ev.clone(), + ) + }) .collect::>(); let requester = to_pdu_event( @@ -1225,13 +1257,21 @@ mod tests { #[test] fn test_join_creator() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = INITIAL_EVENTS_CREATE_ROOM(); let auth_events = events .values() - .map(|ev| (ev.event_type().with_state_key(ev.state_key().unwrap()), ev.clone())) + .map(|ev| { + ( + ev.event_type() + .with_state_key(ev.state_key().unwrap()), + ev.clone(), + ) + }) .collect::>(); let requester = to_pdu_event( @@ -1270,13 +1310,21 @@ mod tests { #[test] fn test_ban_fail() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = INITIAL_EVENTS(); let auth_events = events .values() - .map(|ev| (ev.event_type().with_state_key(ev.state_key().unwrap()), ev.clone())) + .map(|ev| { + ( + ev.event_type() + .with_state_key(ev.state_key().unwrap()), + ev.clone(), + ) + }) .collect::>(); let requester = to_pdu_event( @@ -1315,7 +1363,9 @@ mod tests { #[test] fn test_restricted_join_rule() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let mut events = INITIAL_EVENTS(); *events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event( @@ -1338,7 +1388,13 @@ mod tests { let auth_events = events .values() - .map(|ev| (ev.event_type().with_state_key(ev.state_key().unwrap()), ev.clone())) + .map(|ev| { + ( + ev.event_type() + .with_state_key(ev.state_key().unwrap()), + ev.clone(), + ) + }) .collect::>(); let requester = to_pdu_event( @@ -1395,7 +1451,9 @@ mod tests { #[test] fn test_knock() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let mut events = INITIAL_EVENTS(); *events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event( @@ -1410,7 +1468,13 @@ mod tests { let auth_events = events .values() - .map(|ev| (ev.event_type().with_state_key(ev.state_key().unwrap()), ev.clone())) + .map(|ev| { + ( + ev.event_type() + .with_state_key(ev.state_key().unwrap()), + ev.clone(), + ) + }) .collect::>(); let requester = to_pdu_event( diff --git a/src/core/matrix/state_res/mod.rs b/src/core/matrix/state_res/mod.rs index 2ab7cb64..20884c24 100644 --- a/src/core/matrix/state_res/mod.rs +++ b/src/core/matrix/state_res/mod.rs @@ -429,7 +429,10 @@ where reverse_graph.entry(node).or_default(); for edge in edges { - reverse_graph.entry(edge).or_default().insert(node); + reverse_graph + .entry(edge) + .or_default() + .insert(node); } } @@ -710,7 +713,9 @@ where .iter() .stream() .broad_filter_map(async |ev_id| { - fetch_event(ev_id.clone()).await.map(|event| (event, ev_id)) + fetch_event(ev_id.clone()) + .await + .map(|event| (event, ev_id)) }) .broad_filter_map(|(event, ev_id)| { get_mainline_depth(Some(event.clone()), &mainline_map, fetch_event) @@ -782,7 +787,11 @@ async fn add_event_and_auth_chain_to_graph( while let Some(eid) = state.pop() { graph.entry(eid.clone()).or_default(); let event = fetch_event(eid.clone()).await; - let auth_events = event.as_ref().map(Event::auth_events).into_iter().flatten(); + let auth_events = event + .as_ref() + .map(Event::auth_events) + .into_iter() + .flatten(); // Prefer the store to event as the store filters dedups the events for aid in auth_events { @@ -792,7 +801,10 @@ async fn add_event_and_auth_chain_to_graph( } // We just inserted this at the start of the while loop - graph.get_mut(eid.borrow()).unwrap().insert(aid.to_owned()); + graph + .get_mut(eid.borrow()) + .unwrap() + .insert(aid.to_owned()); } } } @@ -890,13 +902,21 @@ mod tests { use futures::future::ready; let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = INITIAL_EVENTS(); let event_map = events .values() - .map(|ev| (ev.event_type().with_state_key(ev.state_key().unwrap()), ev.clone())) + .map(|ev| { + ( + ev.event_type() + .with_state_key(ev.state_key().unwrap()), + ev.clone(), + ) + }) .collect::>(); let auth_chain: HashSet = HashSet::new(); @@ -965,7 +985,9 @@ mod tests { #[tokio::test] async fn ban_vs_power_level() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = &[ @@ -1015,7 +1037,9 @@ mod tests { #[tokio::test] async fn topic_basic() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = &[ @@ -1080,7 +1104,9 @@ mod tests { #[tokio::test] async fn topic_reset() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = &[ @@ -1130,7 +1156,9 @@ mod tests { #[tokio::test] async fn join_rule_evasion() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = &[ @@ -1163,7 +1191,9 @@ mod tests { #[tokio::test] async fn offtopic_power_level() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = &[ @@ -1199,7 +1229,10 @@ mod tests { .map(|list| list.into_iter().map(event_id).collect::>()) .collect::>(); - let expected_state_ids = vec!["PC"].into_iter().map(event_id).collect::>(); + let expected_state_ids = vec!["PC"] + .into_iter() + .map(event_id) + .collect::>(); do_check(events, edges, expected_state_ids).await; } @@ -1207,7 +1240,9 @@ mod tests { #[tokio::test] async fn topic_setting() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let events = &[ @@ -1289,7 +1324,9 @@ mod tests { use futures::future::ready; let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let mut store = TestStore::(hashmap! {}); @@ -1332,7 +1369,9 @@ mod tests { #[tokio::test] async fn test_lexicographical_sort() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let graph = hashmap! { @@ -1361,7 +1400,9 @@ mod tests { #[tokio::test] async fn ban_with_auth_chains() { let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let ban = BAN_STATE_SET(); @@ -1383,7 +1424,9 @@ mod tests { use futures::future::ready; let _ = tracing::subscriber::set_default( - tracing_subscriber::fmt().with_test_writer().finish(), + tracing_subscriber::fmt() + .with_test_writer() + .finish(), ); let init = INITIAL_EVENTS(); let ban = BAN_STATE_SET(); @@ -1402,7 +1445,13 @@ mod tests { inner.get(&event_id("PA")).unwrap(), ] .iter() - .map(|ev| (ev.event_type().with_state_key(ev.state_key().unwrap()), ev.event_id.clone())) + .map(|ev| { + ( + ev.event_type() + .with_state_key(ev.state_key().unwrap()), + ev.event_id.clone(), + ) + }) .collect::>(); let state_set_b = [ @@ -1415,7 +1464,13 @@ mod tests { inner.get(&event_id("PA")).unwrap(), ] .iter() - .map(|ev| (ev.event_type().with_state_key(ev.state_key().unwrap()), ev.event_id.clone())) + .map(|ev| { + ( + ev.event_type() + .with_state_key(ev.state_key().unwrap()), + ev.event_id.clone(), + ) + }) .collect::>(); let ev_map = &store.0; @@ -1479,7 +1534,10 @@ mod tests { .map(|list| list.into_iter().map(event_id).collect::>()) .collect::>(); - let expected_state_ids = vec!["JR"].into_iter().map(event_id).collect::>(); + let expected_state_ids = vec!["JR"] + .into_iter() + .map(event_id) + .collect::>(); do_check(&join_rule.values().cloned().collect::>(), edges, expected_state_ids) .await; diff --git a/src/core/matrix/state_res/test_utils.rs b/src/core/matrix/state_res/test_utils.rs index a666748a..1ab89267 100644 --- a/src/core/matrix/state_res/test_utils.rs +++ b/src/core/matrix/state_res/test_utils.rs @@ -206,12 +206,16 @@ pub(crate) async fn do_check( ) }); - let key = ev.event_type().with_state_key(ev.state_key().unwrap()); + let key = ev + .event_type() + .with_state_key(ev.state_key().unwrap()); expected_state.insert(key, node); } - let start_state = state_at_event.get(event_id!("$START:foo")).unwrap(); + let start_state = state_at_event + .get(event_id!("$START:foo")) + .unwrap(); let end_state = state_at_event .get(event_id!("$END:foo")) @@ -340,21 +344,33 @@ impl TestStore { let state_at_bob = [&create_event, &alice_mem, &join_rules, &bob_mem] .iter() .map(|e| { - (e.event_type().with_state_key(e.state_key().unwrap()), e.event_id().to_owned()) + ( + e.event_type() + .with_state_key(e.state_key().unwrap()), + e.event_id().to_owned(), + ) }) .collect::>(); let state_at_charlie = [&create_event, &alice_mem, &join_rules, &charlie_mem] .iter() .map(|e| { - (e.event_type().with_state_key(e.state_key().unwrap()), e.event_id().to_owned()) + ( + e.event_type() + .with_state_key(e.state_key().unwrap()), + e.event_id().to_owned(), + ) }) .collect::>(); let expected = [&create_event, &alice_mem, &join_rules, &bob_mem, &charlie_mem] .iter() .map(|e| { - (e.event_type().with_state_key(e.state_key().unwrap()), e.event_id().to_owned()) + ( + e.event_type() + .with_state_key(e.state_key().unwrap()), + e.event_id().to_owned(), + ) }) .collect::>(); diff --git a/src/core/metrics/mod.rs b/src/core/metrics/mod.rs index 8f7a5571..0ec5fb4c 100644 --- a/src/core/metrics/mod.rs +++ b/src/core/metrics/mod.rs @@ -31,7 +31,9 @@ impl Metrics { let runtime_monitor = runtime.as_ref().map(RuntimeMonitor::new); #[cfg(tokio_unstable)] - let runtime_intervals = runtime_monitor.as_ref().map(RuntimeMonitor::intervals); + let runtime_intervals = runtime_monitor + .as_ref() + .map(RuntimeMonitor::intervals); Self { _runtime: runtime.clone(), diff --git a/src/core/mods/path.rs b/src/core/mods/path.rs index cde251b3..d2319a64 100644 --- a/src/core/mods/path.rs +++ b/src/core/mods/path.rs @@ -27,7 +27,10 @@ pub fn to_name(path: &OsStr) -> Result { .expect("path file stem") .to_str() .expect("name string"); - let name = name.strip_prefix("lib").unwrap_or(name).to_owned(); + let name = name + .strip_prefix("lib") + .unwrap_or(name) + .to_owned(); Ok(name) } diff --git a/src/core/utils/bytes.rs b/src/core/utils/bytes.rs index 507b9b9a..93afa734 100644 --- a/src/core/utils/bytes.rs +++ b/src/core/utils/bytes.rs @@ -21,7 +21,9 @@ pub fn from_str(str: &str) -> Result { #[inline] #[must_use] pub fn pretty(bytes: usize) -> String { - let bytes: u64 = bytes.try_into().expect("failed to convert usize to u64"); + let bytes: u64 = bytes + .try_into() + .expect("failed to convert usize to u64"); ByteSize::b(bytes).display().iec().to_string() } diff --git a/src/core/utils/mutex_map.rs b/src/core/utils/mutex_map.rs index 01504ce6..c60f890f 100644 --- a/src/core/utils/mutex_map.rs +++ b/src/core/utils/mutex_map.rs @@ -73,7 +73,9 @@ where Ok(Guard:: { map: Arc::clone(&self.map), - val: val.try_lock_owned().map_err(|_| err!("would yield"))?, + val: val + .try_lock_owned() + .map_err(|_| err!("would yield"))?, }) } @@ -97,7 +99,9 @@ where Ok(Guard:: { map: Arc::clone(&self.map), - val: val.try_lock_owned().map_err(|_| err!("would yield"))?, + val: val + .try_lock_owned() + .map_err(|_| err!("would yield"))?, }) } diff --git a/src/core/utils/result/unwrap_infallible.rs b/src/core/utils/result/unwrap_infallible.rs index 99309e02..ef16c565 100644 --- a/src/core/utils/result/unwrap_infallible.rs +++ b/src/core/utils/result/unwrap_infallible.rs @@ -12,6 +12,9 @@ impl UnwrapInfallible for Result { fn unwrap_infallible(self) -> T { // SAFETY: Branchless unwrap for errors that can never happen. In debug // mode this is asserted. - unsafe { self.debug_inspect_err(error::infallible).unwrap_unchecked() } + unsafe { + self.debug_inspect_err(error::infallible) + .unwrap_unchecked() + } } } diff --git a/src/core/utils/set.rs b/src/core/utils/set.rs index 032a9835..9d2d8aea 100644 --- a/src/core/utils/set.rs +++ b/src/core/utils/set.rs @@ -68,7 +68,11 @@ where a.map(move |ai| (ai, b.clone())) .filter_map(|(ai, b)| async move { let mut lock = b.lock().await; - while let Some(bi) = Pin::new(&mut *lock).next_if(|bi| *bi <= ai).await.as_ref() { + while let Some(bi) = Pin::new(&mut *lock) + .next_if(|bi| *bi <= ai) + .await + .as_ref() + { if ai == *bi { return Some(ai); } diff --git a/src/core/utils/stream/try_parallel.rs b/src/core/utils/stream/try_parallel.rs index 60fef0ae..8c008b74 100644 --- a/src/core/utils/stream/try_parallel.rs +++ b/src/core/utils/stream/try_parallel.rs @@ -65,7 +65,11 @@ where let h = h.into().unwrap_or_else(runtime::Handle::current); self.broadn_and_then(n, move |val| { let (h, f) = (h.clone(), f.clone()); - async move { h.spawn_blocking(move || f(val)).map_err(E::from).await? } + async move { + h.spawn_blocking(move || f(val)) + .map_err(E::from) + .await? + } }) } } diff --git a/src/core/utils/string/unquote.rs b/src/core/utils/string/unquote.rs index ea7ddbf9..f0c78b9a 100644 --- a/src/core/utils/string/unquote.rs +++ b/src/core/utils/string/unquote.rs @@ -27,7 +27,8 @@ impl<'a> Unquote<'a> for &'a str { #[inline] fn unquote(&self) -> Option<&'a str> { - self.strip_prefix(QUOTE).and_then(|s| s.strip_suffix(QUOTE)) + self.strip_prefix(QUOTE) + .and_then(|s| s.strip_suffix(QUOTE)) } #[inline] diff --git a/src/core/utils/sys.rs b/src/core/utils/sys.rs index f795ccb8..f2367a38 100644 --- a/src/core/utils/sys.rs +++ b/src/core/utils/sys.rs @@ -51,6 +51,8 @@ pub unsafe fn current_exe() -> Result { /// accurate on all platforms; defaults to false. #[must_use] pub fn current_exe_deleted() -> bool { - std::env::current_exe() - .is_ok_and(|exe| exe.to_str().is_some_and(|exe| exe.ends_with(" (deleted)"))) + std::env::current_exe().is_ok_and(|exe| { + exe.to_str() + .is_some_and(|exe| exe.ends_with(" (deleted)")) + }) } diff --git a/src/core/utils/sys/compute.rs b/src/core/utils/sys/compute.rs index 5274cd66..3ac5943a 100644 --- a/src/core/utils/sys/compute.rs +++ b/src/core/utils/sys/compute.rs @@ -70,7 +70,9 @@ pub fn get_affinity() -> impl Iterator { from_mask(CORE_AFFINITY.get( /// List the cores sharing SMT-tier resources pub fn smt_siblings() -> impl Iterator { from_mask(get_affinity().fold(0_u128, |mask, id| { - mask | SMT_TOPOLOGY.get(id).expect("ID must not exceed max cpus") + mask | SMT_TOPOLOGY + .get(id) + .expect("ID must not exceed max cpus") })) } @@ -78,20 +80,30 @@ pub fn smt_siblings() -> impl Iterator { /// affinity. pub fn node_siblings() -> impl Iterator { from_mask(get_affinity().fold(0_u128, |mask, id| { - mask | NODE_TOPOLOGY.get(id).expect("Id must not exceed max cpus") + mask | NODE_TOPOLOGY + .get(id) + .expect("Id must not exceed max cpus") })) } /// Get the cores sharing SMT resources relative to id. #[inline] pub fn smt_affinity(id: Id) -> impl Iterator { - from_mask(*SMT_TOPOLOGY.get(id).expect("ID must not exceed max cpus")) + from_mask( + *SMT_TOPOLOGY + .get(id) + .expect("ID must not exceed max cpus"), + ) } /// Get the cores sharing Node resources relative to id. #[inline] pub fn node_affinity(id: Id) -> impl Iterator { - from_mask(*NODE_TOPOLOGY.get(id).expect("ID must not exceed max cpus")) + from_mask( + *NODE_TOPOLOGY + .get(id) + .expect("ID must not exceed max cpus"), + ) } /// Get the number of threads which could execute in parallel based on hardware diff --git a/src/core/utils/sys/storage.rs b/src/core/utils/sys/storage.rs index b71c3437..3be757e3 100644 --- a/src/core/utils/sys/storage.rs +++ b/src/core/utils/sys/storage.rs @@ -42,7 +42,9 @@ pub struct Queue { /// Get device characteristics useful for random access throughput by name. #[must_use] pub fn parallelism(path: &Path) -> Parallelism { - let dev_id = dev_from_path(path).log_debug_err().unwrap_or_default(); + let dev_id = dev_from_path(path) + .log_debug_err() + .unwrap_or_default(); let mq_path = block_path(dev_id).join("mq/"); @@ -60,7 +62,12 @@ pub fn parallelism(path: &Path) -> Parallelism { .into_iter() .flat_map(IntoIterator::into_iter) .filter_map(Result::ok) - .filter(|entry| entry.file_type().as_ref().is_ok_and(FileType::is_dir)) + .filter(|entry| { + entry + .file_type() + .as_ref() + .is_ok_and(FileType::is_dir) + }) .map(|dir| queue_parallelism(&dir.path())) .collect(), } diff --git a/src/database/engine.rs b/src/database/engine.rs index cfaa1c7c..a01525bd 100644 --- a/src/database/engine.rs +++ b/src/database/engine.rs @@ -77,7 +77,11 @@ impl Engine { sequence = ?self.current_sequence(), ), )] - pub fn update(&self) -> Result { self.db.try_catch_up_with_primary().map_err(map_err) } + pub fn update(&self) -> Result { + self.db + .try_catch_up_with_primary() + .map_err(map_err) + } #[tracing::instrument(level = "info", skip_all)] pub fn sync(&self) -> Result { result(DBCommon::flush_wal(&self.db, true)) } diff --git a/src/database/engine/backup.rs b/src/database/engine/backup.rs index 1c7de263..9707ce07 100644 --- a/src/database/engine/backup.rs +++ b/src/database/engine/backup.rs @@ -20,7 +20,9 @@ pub fn backup(&self) -> Result { .map_err(map_err)?; let engine_info = engine.get_backup_info(); - let info = &engine_info.last().expect("backup engine info is not empty"); + let info = &engine_info + .last() + .expect("backup engine info is not empty"); info!( "Created database backup #{} using {} bytes in {} files", info.backup_id, info.size, info.num_files, diff --git a/src/database/engine/cf_opts.rs b/src/database/engine/cf_opts.rs index e21e1681..e1947a7b 100644 --- a/src/database/engine/cf_opts.rs +++ b/src/database/engine/cf_opts.rs @@ -105,7 +105,8 @@ fn set_table_options(opts: &mut Options, desc: &Descriptor, cache: Option<&Cache prepopulate, ); - opts.set_options_from_string(&string).map_err(map_err)?; + opts.set_options_from_string(&string) + .map_err(map_err)?; opts.set_block_based_table_factory(&table); diff --git a/src/database/engine/open.rs b/src/database/engine/open.rs index b59bdcbd..4f74ea1a 100644 --- a/src/database/engine/open.rs +++ b/src/database/engine/open.rs @@ -78,7 +78,9 @@ fn configure_cfds( let path = &config.database_path; let existing = Self::discover_cfs(path, db_opts); - let creating = desc.iter().filter(|desc| !existing.contains(desc.name)); + let creating = desc + .iter() + .filter(|desc| !existing.contains(desc.name)); let missing = existing .iter() diff --git a/src/database/map/clear.rs b/src/database/map/clear.rs index 7ca164d9..12935ed2 100644 --- a/src/database/map/clear.rs +++ b/src/database/map/clear.rs @@ -14,7 +14,10 @@ use crate::keyval::Key; #[implement(super::Map)] #[tracing::instrument(level = "trace")] pub async fn clear(self: &Arc) { - self.for_clear().ignore_err().ready_for_each(|_| ()).await; + self.for_clear() + .ignore_err() + .ready_for_each(|_| ()) + .await; } /// Delete all data stored in this map. !!! USE WITH CAUTION !!! diff --git a/src/database/map/get.rs b/src/database/map/get.rs index b35d2966..186c7e83 100644 --- a/src/database/map/get.rs +++ b/src/database/map/get.rs @@ -77,7 +77,9 @@ fn get_blocking_opts( where K: AsRef<[u8]> + ?Sized, { - self.db.db.get_pinned_cf_opt(&self.cf(), key, read_options) + self.db + .db + .get_pinned_cf_opt(&self.cf(), key, read_options) } #[inline] diff --git a/src/database/map/get_batch.rs b/src/database/map/get_batch.rs index c0ef709d..a06c6e86 100644 --- a/src/database/map/get_batch.rs +++ b/src/database/map/get_batch.rs @@ -50,7 +50,11 @@ where .widen_then(automatic_width(), |chunk| { self.db.pool.execute_get(Get { map: self.clone(), - key: chunk.iter().map(AsRef::as_ref).map(Into::into).collect(), + key: chunk + .iter() + .map(AsRef::as_ref) + .map(Into::into) + .collect(), res: None, }) }) diff --git a/src/database/map/keys.rs b/src/database/map/keys.rs index a3a6c405..87c86188 100644 --- a/src/database/map/keys.rs +++ b/src/database/map/keys.rs @@ -14,7 +14,8 @@ pub fn keys<'a, K>(self: &'a Arc) -> impl Stream> where K: Deserialize<'a> + Send, { - self.raw_keys().map(keyval::result_deserialize_key::) + self.raw_keys() + .map(keyval::result_deserialize_key::) } #[implement(super::Map)] diff --git a/src/database/map/keys_from.rs b/src/database/map/keys_from.rs index d89bf99d..f6d3eee3 100644 --- a/src/database/map/keys_from.rs +++ b/src/database/map/keys_from.rs @@ -20,7 +20,8 @@ where P: Serialize + ?Sized + Debug, K: Deserialize<'a> + Send, { - self.keys_from_raw(from).map(result_deserialize_key::) + self.keys_from_raw(from) + .map(result_deserialize_key::) } #[implement(super::Map)] @@ -45,7 +46,8 @@ where P: AsRef<[u8]> + ?Sized + Debug + Sync, K: Deserialize<'a> + Send, { - self.raw_keys_from(from).map(result_deserialize_key::) + self.raw_keys_from(from) + .map(result_deserialize_key::) } #[implement(super::Map)] diff --git a/src/database/map/rev_keys.rs b/src/database/map/rev_keys.rs index adfd5b7c..3bf1a531 100644 --- a/src/database/map/rev_keys.rs +++ b/src/database/map/rev_keys.rs @@ -14,7 +14,8 @@ pub fn rev_keys<'a, K>(self: &'a Arc) -> impl Stream + Send, { - self.rev_raw_keys().map(keyval::result_deserialize_key::) + self.rev_raw_keys() + .map(keyval::result_deserialize_key::) } #[implement(super::Map)] diff --git a/src/database/map/stream.rs b/src/database/map/stream.rs index 2a610cd1..0fbfd09b 100644 --- a/src/database/map/stream.rs +++ b/src/database/map/stream.rs @@ -19,7 +19,8 @@ where K: Deserialize<'a> + Send, V: Deserialize<'a> + Send, { - self.raw_stream().map(keyval::result_deserialize::) + self.raw_stream() + .map(keyval::result_deserialize::) } /// Iterate key-value entries in the map from the beginning. diff --git a/src/database/map/stream_from.rs b/src/database/map/stream_from.rs index f7888862..bef59331 100644 --- a/src/database/map/stream_from.rs +++ b/src/database/map/stream_from.rs @@ -25,7 +25,8 @@ where K: Deserialize<'a> + Send, V: Deserialize<'a> + Send, { - self.stream_from_raw(from).map(result_deserialize::) + self.stream_from_raw(from) + .map(result_deserialize::) } /// Iterate key-value entries in the map starting from lower-bound. @@ -59,7 +60,8 @@ where K: Deserialize<'a> + Send, V: Deserialize<'a> + Send, { - self.raw_stream_from(from).map(result_deserialize::) + self.raw_stream_from(from) + .map(result_deserialize::) } /// Iterate key-value entries in the map starting from lower-bound. diff --git a/src/database/pool.rs b/src/database/pool.rs index ff20d760..98ed943f 100644 --- a/src/database/pool.rs +++ b/src/database/pool.rs @@ -117,7 +117,11 @@ impl Drop for Pool { pub(crate) fn close(&self) { let workers = take(&mut *self.workers.lock().expect("locked")); - let senders = self.queues.iter().map(Sender::sender_count).sum::(); + let senders = self + .queues + .iter() + .map(Sender::sender_count) + .sum::(); let receivers = self .queues @@ -225,7 +229,9 @@ pub(crate) async fn execute_iter(self: &Arc, mut cmd: Seek) -> Result &Sender { let core_id = get_affinity().next().unwrap_or(0); let chan_id = self.topology[core_id]; - self.queues.get(chan_id).unwrap_or_else(|| &self.queues[0]) + self.queues + .get(chan_id) + .unwrap_or_else(|| &self.queues[0]) } #[implement(Pool)] @@ -242,7 +248,8 @@ fn select_queue(&self) -> &Sender { )] async fn execute(&self, queue: &Sender, cmd: Cmd) -> Result { if cfg!(debug_assertions) { - self.queued_max.fetch_max(queue.len(), Ordering::Relaxed); + self.queued_max + .fetch_max(queue.len(), Ordering::Relaxed); } queue diff --git a/src/database/pool/configure.rs b/src/database/pool/configure.rs index 3eaa51a4..e5f158c2 100644 --- a/src/database/pool/configure.rs +++ b/src/database/pool/configure.rs @@ -18,11 +18,16 @@ pub(super) fn configure(server: &Arc) -> (usize, Vec, Vec) // This finds the block device and gathers all the properties we need. let path: PathBuf = config.database_path.clone(); - let device_name = storage::name_from_path(&path).log_debug_err().ok(); + let device_name = storage::name_from_path(&path) + .log_debug_err() + .ok(); let device_prop = storage::parallelism(&path); // The default worker count is masked-on if we didn't find better information. - let default_worker_count = device_prop.mq.is_empty().then_some(config.db_pool_workers); + let default_worker_count = device_prop + .mq + .is_empty() + .then_some(config.db_pool_workers); // Determine the worker groupings. Each indice represents a hardware queue and // contains the number of workers which will service it. @@ -38,9 +43,13 @@ pub(super) fn configure(server: &Arc) -> (usize, Vec, Vec) .count() .max(1); - let limit = config.db_pool_workers_limit.saturating_mul(shares); + let limit = config + .db_pool_workers_limit + .saturating_mul(shares); - let limit = device_prop.nr_requests.map_or(limit, |nr| nr.min(limit)); + let limit = device_prop + .nr_requests + .map_or(limit, |nr| nr.min(limit)); mq.nr_tags.unwrap_or(WORKER_LIMIT.0).min(limit) }) diff --git a/src/database/watchers.rs b/src/database/watchers.rs index b3907833..9477db1b 100644 --- a/src/database/watchers.rs +++ b/src/database/watchers.rs @@ -19,7 +19,12 @@ impl Watchers { &'a self, prefix: &[u8], ) -> Pin + Send + 'a>> { - let mut rx = match self.watchers.write().unwrap().entry(prefix.to_vec()) { + let mut rx = match self + .watchers + .write() + .unwrap() + .entry(prefix.to_vec()) + { | hash_map::Entry::Occupied(o) => o.get().1.clone(), | hash_map::Entry::Vacant(v) => { let (tx, rx) = watch::channel(()); @@ -50,7 +55,8 @@ impl Watchers { let mut watchers = self.watchers.write().unwrap(); for prefix in triggered { if let Some(tx) = watchers.remove(prefix) { - tx.0.send(()).expect("channel should still be open"); + tx.0.send(()) + .expect("channel should still be open"); } } } diff --git a/src/macros/admin.rs b/src/macros/admin.rs index 719356ce..624d95d5 100644 --- a/src/macros/admin.rs +++ b/src/macros/admin.rs @@ -17,7 +17,11 @@ pub(super) fn command(mut item: ItemFn, _args: &[Meta]) -> Result { pub(super) fn command_dispatch(item: ItemEnum, _args: &[Meta]) -> Result { let name = &item.ident; - let arm: Vec = item.variants.iter().map(dispatch_arm).try_collect()?; + let arm: Vec = item + .variants + .iter() + .map(dispatch_arm) + .try_collect()?; let switch = quote! { #[allow(clippy::large_stack_frames)] //TODO: fixme pub(super) async fn process( @@ -44,7 +48,10 @@ fn dispatch_arm(v: &Variant) -> Result { let handler = Ident::new(&target, Span::call_site().into()); let res = match &v.fields { | Fields::Named(fields) => { - let field = fields.named.iter().filter_map(|f| f.ident.as_ref()); + let field = fields + .named + .iter() + .filter_map(|f| f.ident.as_ref()); let arg = field.clone(); quote! { #name { #( #field ),* } => { diff --git a/src/macros/config.rs b/src/macros/config.rs index 7b424325..293a895a 100644 --- a/src/macros/config.rs +++ b/src/macros/config.rs @@ -251,7 +251,12 @@ fn get_doc_comment_full(field: &Field) -> Option { continue; }; - if path.segments.iter().next().is_none_or(|s| s.ident != "doc") { + if path + .segments + .iter() + .next() + .is_none_or(|s| s.ident != "doc") + { continue; } diff --git a/src/macros/utils.rs b/src/macros/utils.rs index a45e5ecc..8e40863a 100644 --- a/src/macros/utils.rs +++ b/src/macros/utils.rs @@ -14,7 +14,12 @@ pub(crate) fn get_simple_settings(args: &[Meta]) -> HashMap { return map; }; - if let Some(key) = path.segments.iter().next().map(|s| s.ident.clone()) { + if let Some(key) = path + .segments + .iter() + .next() + .map(|s| s.ident.clone()) + { map.insert(key.to_string(), str.value()); } diff --git a/src/main/mods.rs b/src/main/mods.rs index 9cf22fee..98eeed7f 100644 --- a/src/main/mods.rs +++ b/src/main/mods.rs @@ -51,7 +51,10 @@ pub(crate) async fn run(server: &Arc, starts: bool) -> Result<(bool, boo }, }; } - server.server.stopping.store(false, Ordering::Release); + server + .server + .stopping + .store(false, Ordering::Release); let run = main_mod.get::("run")?; if let Err(error) = run(server .services @@ -64,7 +67,10 @@ pub(crate) async fn run(server: &Arc, starts: bool) -> Result<(bool, boo error!("Running server: {error}"); return Err(error); } - let reloads = server.server.reloading.swap(false, Ordering::AcqRel); + let reloads = server + .server + .reloading + .swap(false, Ordering::AcqRel); let stops = !reloads || stale(server).await? <= restart_thresh(); let starts = reloads && stops; if stops { diff --git a/src/main/runtime.rs b/src/main/runtime.rs index 0fed6003..d590f261 100644 --- a/src/main/runtime.rs +++ b/src/main/runtime.rs @@ -104,7 +104,11 @@ pub(super) fn shutdown(server: &Arc, runtime: tokio::runtime::Runtime) { ); runtime.shutdown_timeout(SHUTDOWN_TIMEOUT); - let runtime_metrics = server.server.metrics.runtime_interval().unwrap_or_default(); + let runtime_metrics = server + .server + .metrics + .runtime_interval() + .unwrap_or_default(); event!(LEVEL, ?runtime_metrics, "Final runtime metrics"); } diff --git a/src/main/sentry.rs b/src/main/sentry.rs index cf8e2fa1..b4c5f54a 100644 --- a/src/main/sentry.rs +++ b/src/main/sentry.rs @@ -18,7 +18,9 @@ static SEND_PANIC: OnceLock = OnceLock::new(); static SEND_ERROR: OnceLock = OnceLock::new(); pub(crate) fn init(config: &Config) -> Option { - config.sentry.then(|| sentry::init(options(config))) + config + .sentry + .then(|| sentry::init(options(config))) } fn options(config: &Config) -> ClientOptions { diff --git a/src/router/request.rs b/src/router/request.rs index 66346c7f..d927dcc5 100644 --- a/src/router/request.rs +++ b/src/router/request.rs @@ -98,7 +98,9 @@ async fn execute( fn handle_result(method: &Method, uri: &Uri, result: Response) -> Result { let status = result.status(); - let reason = status.canonical_reason().unwrap_or("Unknown Reason"); + let reason = status + .canonical_reason() + .unwrap_or("Unknown Reason"); let code = status.as_u16(); if status.is_server_error() { diff --git a/src/router/serve/plain.rs b/src/router/serve/plain.rs index f2b4f626..7e4a7e3f 100644 --- a/src/router/serve/plain.rs +++ b/src/router/serve/plain.rs @@ -17,8 +17,12 @@ pub(super) async fn serve( let app = app.into_make_service_with_connect_info::(); let mut join_set = JoinSet::new(); for addr in &addrs { - join_set - .spawn_on(bind(*addr).handle(handle.clone()).serve(app.clone()), server.runtime()); + join_set.spawn_on( + bind(*addr) + .handle(handle.clone()) + .serve(app.clone()), + server.runtime(), + ); } info!("Listening on {addrs:?}"); @@ -33,7 +37,10 @@ pub(super) async fn serve( .metrics .requests_handle_finished .load(Ordering::Relaxed), - panics = server.metrics.requests_panic.load(Ordering::Relaxed), + panics = server + .metrics + .requests_panic + .load(Ordering::Relaxed), handle_active, "Stopped listening on {addrs:?}", ); diff --git a/src/service/account_data/mod.rs b/src/service/account_data/mod.rs index 893187f1..7124aaf0 100644 --- a/src/service/account_data/mod.rs +++ b/src/service/account_data/mod.rs @@ -70,8 +70,14 @@ pub async fn update( .put(roomuserdataid, Json(data)); let key = (room_id, user_id, &event_type); - let prev = self.db.roomusertype_roomuserdataid.qry(&key).await; - self.db.roomusertype_roomuserdataid.put(key, roomuserdataid); + let prev = self + .db + .roomusertype_roomuserdataid + .qry(&key) + .await; + self.db + .roomusertype_roomuserdataid + .put(key, roomuserdataid); // Remove old entry if let Ok(prev) = prev { @@ -119,7 +125,11 @@ pub async fn get_raw( self.db .roomusertype_roomuserdataid .qry(&key) - .and_then(|roomuserdataid| self.db.roomuserdataid_accountdata.get(&roomuserdataid)) + .and_then(|roomuserdataid| { + self.db + .roomuserdataid_accountdata + .get(&roomuserdataid) + }) .await } diff --git a/src/service/admin/console.rs b/src/service/admin/console.rs index 5465f7ca..455197f4 100644 --- a/src/service/admin/console.rs +++ b/src/service/admin/console.rs @@ -106,8 +106,10 @@ impl Console { | ReadlineEvent::Line(string) => self.clone().handle(string).await, | ReadlineEvent::Interrupted => continue, | ReadlineEvent::Eof => break, - | ReadlineEvent::Quit => - self.server.shutdown().unwrap_or_else(error::default_log), + | ReadlineEvent::Quit => self + .server + .shutdown() + .unwrap_or_else(error::default_log), }, | Err(error) => match error { | ReadlineError::Closed => break, @@ -135,7 +137,11 @@ impl Console { let (abort, abort_reg) = AbortHandle::new_pair(); let future = Abortable::new(future, abort_reg); - _ = self.input_abort.lock().expect("locked").insert(abort); + _ = self + .input_abort + .lock() + .expect("locked") + .insert(abort); defer! {{ _ = self.input_abort.lock().expect("locked").take(); }} @@ -158,7 +164,11 @@ impl Console { let (abort, abort_reg) = AbortHandle::new_pair(); let future = Abortable::new(future, abort_reg); - _ = self.command_abort.lock().expect("locked").insert(abort); + _ = self + .command_abort + .lock() + .expect("locked") + .insert(abort); defer! {{ _ = self.command_abort.lock().expect("locked").take(); }} diff --git a/src/service/admin/execute.rs b/src/service/admin/execute.rs index 8c209e79..ab7cc24b 100644 --- a/src/service/admin/execute.rs +++ b/src/service/admin/execute.rs @@ -8,7 +8,12 @@ pub(super) const SIGNAL: &str = "SIGUSR2"; #[implement(super::Service)] pub(super) async fn console_auto_start(&self) { #[cfg(feature = "console")] - if self.services.server.config.admin_console_automatic { + if self + .services + .server + .config + .admin_console_automatic + { // Allow more of the startup sequence to execute before spawning tokio::task::yield_now().await; self.console.start().await; @@ -32,7 +37,12 @@ pub(super) async fn startup_execute(&self) -> Result { let smoketest = self.services.server.config.test.contains("smoke"); // When true, errors are ignored and startup continues. - let errors = !smoketest && self.services.server.config.admin_execute_errors_ignore; + let errors = !smoketest + && self + .services + .server + .config + .admin_execute_errors_ignore; //TODO: remove this after run-states are broadcast sleep(Duration::from_millis(500)).await; @@ -65,10 +75,19 @@ pub(super) async fn startup_execute(&self) -> Result { #[implement(super::Service)] pub(super) async fn signal_execute(&self) -> Result { // List of comamnds to execute - let commands = self.services.server.config.admin_signal_execute.clone(); + let commands = self + .services + .server + .config + .admin_signal_execute + .clone(); // When true, errors are ignored and execution continues. - let ignore_errors = self.services.server.config.admin_execute_errors_ignore; + let ignore_errors = self + .services + .server + .config + .admin_execute_errors_ignore; for (i, command) in commands.iter().enumerate() { if let Err(e) = self.execute_command(i, command.clone()).await { diff --git a/src/service/admin/grant.rs b/src/service/admin/grant.rs index fce4d030..cce98740 100644 --- a/src/service/admin/grant.rs +++ b/src/service/admin/grant.rs @@ -30,7 +30,12 @@ pub async fn make_user_admin(&self, user_id: &UserId) -> Result { let state_lock = self.services.state.mutex.lock(&room_id).await; - if self.services.state_cache.is_joined(user_id, &room_id).await { + if self + .services + .state_cache + .is_joined(user_id, &room_id) + .await + { return Err!(debug_warn!("User is already joined in the admin room")); } if self @@ -106,7 +111,9 @@ pub async fn make_user_admin(&self, user_id: &UserId) -> Result { room_power_levels .users .insert(server_user.into(), 69420.into()); - room_power_levels.users.insert(user_id.into(), 100.into()); + room_power_levels + .users + .insert(user_id.into(), 100.into()); self.services .timeline @@ -119,9 +126,17 @@ pub async fn make_user_admin(&self, user_id: &UserId) -> Result { .await?; // Set room tag - let room_tag = self.services.server.config.admin_room_tag.as_str(); + let room_tag = self + .services + .server + .config + .admin_room_tag + .as_str(); if !room_tag.is_empty() { - if let Err(e) = self.set_room_tag(&room_id, user_id, room_tag).await { + if let Err(e) = self + .set_room_tag(&room_id, user_id, room_tag) + .await + { error!(?room_id, ?user_id, ?room_tag, "Failed to set tag for admin grant: {e}"); } } diff --git a/src/service/admin/mod.rs b/src/service/admin/mod.rs index a48f7fe9..a09371d9 100644 --- a/src/service/admin/mod.rs +++ b/src/service/admin/mod.rs @@ -260,7 +260,12 @@ impl Service { return Ok(()); }; - let Ok(pdu) = self.services.timeline.get_pdu(&in_reply_to.event_id).await else { + let Ok(pdu) = self + .services + .timeline + .get_pdu(&in_reply_to.event_id) + .await + else { error!( event_id = ?in_reply_to.event_id, "Missing admin command in_reply_to event" @@ -327,7 +332,10 @@ impl Service { pub async fn is_admin_command(&self, pdu: &PduEvent, body: &str) -> bool { // Server-side command-escape with public echo let is_escape = body.starts_with('\\'); - let is_public_escape = is_escape && body.trim_start_matches('\\').starts_with("!admin"); + let is_public_escape = is_escape + && body + .trim_start_matches('\\') + .starts_with("!admin"); // Admin command with public echo (in admin room) let server_user = &self.services.globals.server_user; @@ -361,7 +369,12 @@ impl Service { // This will evaluate to false if the emergency password is set up so that // the administrator can execute commands as the server user - let emergency_password_set = self.services.server.config.emergency_password.is_some(); + let emergency_password_set = self + .services + .server + .config + .emergency_password + .is_some(); let from_server = pdu.sender == *server_user && !emergency_password_set; if from_server && self.is_admin_room(&pdu.room_id).await { return false; @@ -382,7 +395,11 @@ impl Service { /// Sets the self-reference to crate::Services which will provide context to /// the admin commands. pub(super) fn set_services(&self, services: Option<&Arc>) { - let receiver = &mut *self.services.services.write().expect("locked for writing"); + let receiver = &mut *self + .services + .services + .write() + .expect("locked for writing"); let weak = services.map(Arc::downgrade); *receiver = weak; } diff --git a/src/service/appservice/mod.rs b/src/service/appservice/mod.rs index 3ec454d3..99f0276c 100644 --- a/src/service/appservice/mod.rs +++ b/src/service/appservice/mod.rs @@ -94,7 +94,9 @@ impl Service { .ok_or_else(|| err!("Appservice not found"))?; // remove the appservice from the database - self.db.id_appserviceregistrations.del(appservice_id); + self.db + .id_appserviceregistrations + .del(appservice_id); // deletes all active requests for the appservice if there are any so we stop // sending to the URL diff --git a/src/service/emergency/mod.rs b/src/service/emergency/mod.rs index 9ada8174..4ffa2bc2 100644 --- a/src/service/emergency/mod.rs +++ b/src/service/emergency/mod.rs @@ -41,9 +41,13 @@ impl crate::Service for Service { return Ok(()); } - self.set_emergency_access().await.inspect_err(|e| { - error!("Could not set the configured emergency password for the server user: {e}"); - }) + self.set_emergency_access() + .await + .inspect_err(|e| { + error!( + "Could not set the configured emergency password for the server user: {e}" + ); + }) } fn name(&self) -> &str { crate::service::make_name(std::module_path!()) } @@ -69,7 +73,9 @@ impl Service { .update( None, server_user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(&GlobalAccountDataEvent { content: PushRulesEventContent { global: ruleset }, }) @@ -86,7 +92,10 @@ impl Service { Ok(()) } else { // logs out any users still in the server service account and removes sessions - self.services.users.deactivate_account(server_user).await + self.services + .users + .deactivate_account(server_user) + .await } } } diff --git a/src/service/federation/execute.rs b/src/service/federation/execute.rs index 610262f4..aadf5fd4 100644 --- a/src/service/federation/execute.rs +++ b/src/service/federation/execute.rs @@ -74,10 +74,15 @@ where return Err!(Request(Forbidden(debug_warn!("Federation with {dest} is not allowed.")))); } - let actual = self.services.resolver.get_actual_dest(dest).await?; + let actual = self + .services + .resolver + .get_actual_dest(dest) + .await?; let request = into_http_request::(&actual, request)?; let request = self.prepare(dest, request)?; - self.perform::(dest, &actual, request, client).await + self.perform::(dest, &actual, request, client) + .await } #[implement(super::Service)] diff --git a/src/service/globals/mod.rs b/src/service/globals/mod.rs index aec88a53..5bd9da7f 100644 --- a/src/service/globals/mod.rs +++ b/src/service/globals/mod.rs @@ -140,19 +140,31 @@ impl Service { pub fn notification_push_path(&self) -> &String { &self.server.config.notification_push_path } pub fn url_preview_domain_contains_allowlist(&self) -> &Vec { - &self.server.config.url_preview_domain_contains_allowlist + &self + .server + .config + .url_preview_domain_contains_allowlist } pub fn url_preview_domain_explicit_allowlist(&self) -> &Vec { - &self.server.config.url_preview_domain_explicit_allowlist + &self + .server + .config + .url_preview_domain_explicit_allowlist } pub fn url_preview_domain_explicit_denylist(&self) -> &Vec { - &self.server.config.url_preview_domain_explicit_denylist + &self + .server + .config + .url_preview_domain_explicit_denylist } pub fn url_preview_url_contains_allowlist(&self) -> &Vec { - &self.server.config.url_preview_url_contains_allowlist + &self + .server + .config + .url_preview_url_contains_allowlist } pub fn url_preview_max_spider_size(&self) -> usize { diff --git a/src/service/key_backups/mod.rs b/src/service/key_backups/mod.rs index 2d94ac11..fff98585 100644 --- a/src/service/key_backups/mod.rs +++ b/src/service/key_backups/mod.rs @@ -56,7 +56,9 @@ pub fn create_backup( let count = self.services.globals.next_count()?; let key = (user_id, &version); - self.db.backupid_algorithm.put(key, Json(backup_metadata)); + self.db + .backupid_algorithm + .put(key, Json(backup_metadata)); self.db.backupid_etag.put(key, count); @@ -88,7 +90,13 @@ pub async fn update_backup<'a>( backup_metadata: &Raw, ) -> Result<&'a str> { let key = (user_id, version); - if self.db.backupid_algorithm.qry(&key).await.is_err() { + if self + .db + .backupid_algorithm + .qry(&key) + .await + .is_err() + { return Err!(Request(NotFound("Tried to update nonexistent backup."))); } @@ -140,7 +148,11 @@ pub async fn get_latest_backup( #[implement(Service)] pub async fn get_backup(&self, user_id: &UserId, version: &str) -> Result> { let key = (user_id, version); - self.db.backupid_algorithm.qry(&key).await.deserialized() + self.db + .backupid_algorithm + .qry(&key) + .await + .deserialized() } #[implement(Service)] @@ -153,7 +165,13 @@ pub async fn add_key( key_data: &Raw, ) -> Result<()> { let key = (user_id, version); - if self.db.backupid_algorithm.qry(&key).await.is_err() { + if self + .db + .backupid_algorithm + .qry(&key) + .await + .is_err() + { return Err!(Request(NotFound("Tried to update nonexistent backup."))); } @@ -251,7 +269,11 @@ pub async fn get_session( ) -> Result> { let key = (user_id, version, room_id, session_id); - self.db.backupkeyid_backup.qry(&key).await.deserialized() + self.db + .backupkeyid_backup + .qry(&key) + .await + .deserialized() } #[implement(Service)] diff --git a/src/service/media/mod.rs b/src/service/media/mod.rs index 250650c9..003781a4 100644 --- a/src/service/media/mod.rs +++ b/src/service/media/mod.rs @@ -159,7 +159,11 @@ impl Service { /// Downloads a file. pub async fn get(&self, mxc: &Mxc<'_>) -> Result> { - match self.db.search_file_metadata(mxc, &Dim::default()).await { + match self + .db + .search_file_metadata(mxc, &Dim::default()) + .await + { | Ok(Metadata { content_disposition, content_type, key }) => { let mut content = Vec::with_capacity(8192); let path = self.get_media_file(&key); diff --git a/src/service/media/preview.rs b/src/service/media/preview.rs index 582796fd..e97a9d35 100644 --- a/src/service/media/preview.rs +++ b/src/service/media/preview.rs @@ -82,7 +82,10 @@ async fn request_url_preview(&self, url: &Url) -> Result { } } - let Some(content_type) = response.headers().get(reqwest::header::CONTENT_TYPE) else { + let Some(content_type) = response + .headers() + .get(reqwest::header::CONTENT_TYPE) + else { return Err!(Request(Unknown("Unknown or invalid Content-Type header"))); }; @@ -108,14 +111,21 @@ pub async fn download_image(&self, url: &str) -> Result { use ruma::Mxc; use tuwunel_core::utils::random_string; - let image = self.services.client.url_preview.get(url).send().await?; + let image = self + .services + .client + .url_preview + .get(url) + .send() + .await?; let image = image.bytes().await?; let mxc = Mxc { server_name: self.services.globals.server_name(), media_id: &random_string(super::MXC_LENGTH), }; - self.create(&mxc, None, None, None, &image).await?; + self.create(&mxc, None, None, None, &image) + .await?; let cursor = std::io::Cursor::new(&image); let (width, height) = match ImageReader::new(cursor).with_guessed_format() { @@ -152,13 +162,20 @@ async fn download_html(&self, url: &str) -> Result { let mut bytes: Vec = Vec::new(); while let Some(chunk) = response.chunk().await? { bytes.extend_from_slice(&chunk); - if bytes.len() > self.services.globals.url_preview_max_spider_size() { + if bytes.len() + > self + .services + .globals + .url_preview_max_spider_size() + { debug!( "Response body from URL {} exceeds url_preview_max_spider_size ({}), not \ processing the rest of the response body and assuming our necessary data is in \ this range.", url, - self.services.globals.url_preview_max_spider_size() + self.services + .globals + .url_preview_max_spider_size() ); break; } @@ -177,7 +194,10 @@ async fn download_html(&self, url: &str) -> Result { /* use OpenGraph title/description, but fall back to HTML if not available */ data.title = props.get("title").cloned().or(html.title); - data.description = props.get("description").cloned().or(html.description); + data.description = props + .get("description") + .cloned() + .or(html.description); Ok(data) } @@ -214,8 +234,14 @@ pub fn url_preview_allowed(&self, url: &Url) -> bool { .services .globals .url_preview_domain_explicit_allowlist(); - let denylist_domain_explicit = self.services.globals.url_preview_domain_explicit_denylist(); - let allowlist_url_contains = self.services.globals.url_preview_url_contains_allowlist(); + let denylist_domain_explicit = self + .services + .globals + .url_preview_domain_explicit_denylist(); + let allowlist_url_contains = self + .services + .globals + .url_preview_url_contains_allowlist(); if allowlist_domain_contains.contains(&"*".to_owned()) || allowlist_domain_explicit.contains(&"*".to_owned()) @@ -262,7 +288,11 @@ pub fn url_preview_allowed(&self, url: &Url) -> bool { } // check root domain if available and if user has root domain checks - if self.services.globals.url_preview_check_root_domain() { + if self + .services + .globals + .url_preview_check_root_domain() + { debug!("Checking root domain"); match host.split_once('.') { | None => return false, diff --git a/src/service/media/remote.rs b/src/service/media/remote.rs index 4c63fe89..11685704 100644 --- a/src/service/media/remote.rs +++ b/src/service/media/remote.rs @@ -87,11 +87,14 @@ async fn fetch_thumbnail_authenticated( timeout_ms, }; - let Response { content, .. } = self.federation_request(mxc, user, server, request).await?; + let Response { content, .. } = self + .federation_request(mxc, user, server, request) + .await?; match content { | FileOrLocation::File(content) => - self.handle_thumbnail_file(mxc, user, dim, content).await, + self.handle_thumbnail_file(mxc, user, dim, content) + .await, | FileOrLocation::Location(location) => self.handle_location(mxc, user, &location).await, } } @@ -111,7 +114,9 @@ async fn fetch_content_authenticated( timeout_ms, }; - let Response { content, .. } = self.federation_request(mxc, user, server, request).await?; + let Response { content, .. } = self + .federation_request(mxc, user, server, request) + .await?; match content { | FileOrLocation::File(content) => self.handle_content_file(mxc, user, content).await, @@ -145,11 +150,14 @@ async fn fetch_thumbnail_unauthenticated( let Response { file, content_type, content_disposition, .. - } = self.federation_request(mxc, user, server, request).await?; + } = self + .federation_request(mxc, user, server, request) + .await?; let content = Content { file, content_type, content_disposition }; - self.handle_thumbnail_file(mxc, user, dim, content).await + self.handle_thumbnail_file(mxc, user, dim, content) + .await } #[allow(deprecated)] @@ -173,7 +181,9 @@ async fn fetch_content_unauthenticated( let Response { file, content_type, content_disposition, .. - } = self.federation_request(mxc, user, server, request).await?; + } = self + .federation_request(mxc, user, server, request) + .await?; let content = Content { file, content_type, content_disposition }; @@ -245,11 +255,13 @@ async fn handle_location( user: Option<&UserId>, location: &str, ) -> Result { - self.location_request(location).await.map_err(|error| { - err!(Request(NotFound( - debug_warn!(%mxc, ?user, ?location, ?error, "Fetching media from location failed") - ))) - }) + self.location_request(location) + .await + .map_err(|error| { + err!(Request(NotFound( + debug_warn!(%mxc, ?user, ?location, ?error, "Fetching media from location failed") + ))) + }) } #[implement(super::Service)] diff --git a/src/service/media/thumbnail.rs b/src/service/media/thumbnail.rs index 0357dd74..24a88d52 100644 --- a/src/service/media/thumbnail.rs +++ b/src/service/media/thumbnail.rs @@ -67,8 +67,14 @@ impl super::Service { match self.db.search_file_metadata(mxc, &dim).await { | Ok(metadata) => self.get_thumbnail_saved(metadata).await, - | _ => match self.db.search_file_metadata(mxc, &Dim::default()).await { - | Ok(metadata) => self.get_thumbnail_generate(mxc, &dim, metadata).await, + | _ => match self + .db + .search_file_metadata(mxc, &Dim::default()) + .await + { + | Ok(metadata) => + self.get_thumbnail_generate(mxc, &dim, metadata) + .await, | _ => Ok(None), }, } diff --git a/src/service/migrations.rs b/src/service/migrations.rs index 72baf063..ce4e6c56 100644 --- a/src/service/migrations.rs +++ b/src/service/migrations.rs @@ -55,7 +55,10 @@ pub(crate) async fn migrations(services: &Services) -> Result<()> { async fn fresh(services: &Services) -> Result<()> { let db = &services.db; - services.globals.db.bump_database_version(DATABASE_VERSION); + services + .globals + .db + .bump_database_version(DATABASE_VERSION); db["global"].insert(b"feat_sha256_media", []); db["global"].insert(b"fix_bad_double_separator_in_state_cache", []); @@ -64,7 +67,9 @@ async fn fresh(services: &Services) -> Result<()> { db["global"].insert(b"fix_readreceiptid_readreceipt_duplicates", []); // Create the admin room and server user on first run - crate::admin::create_admin_room(services).boxed().await?; + crate::admin::create_admin_room(services) + .boxed() + .await?; warn!("Created new RocksDB database with version {DATABASE_VERSION}"); @@ -93,7 +98,11 @@ async fn migrate(services: &Services) -> Result<()> { db_lt_13(services).await?; } - if db["global"].get(b"feat_sha256_media").await.is_not_found() { + if db["global"] + .get(b"feat_sha256_media") + .await + .is_not_found() + { media::migrations::migrate_sha256_media(services).await?; } else if config.media_startup_check { media::migrations::checkup_sha256_media(services).await?; @@ -241,7 +250,9 @@ async fn db_lt_12(services: &Services) -> Result<()> { let content_rule_transformation = [".m.rules.contains_user_name", ".m.rule.contains_user_name"]; - let rule = rules_list.content.get(content_rule_transformation[0]); + let rule = rules_list + .content + .get(content_rule_transformation[0]); if rule.is_some() { let mut rule = rule.unwrap().clone(); content_rule_transformation[1].clone_into(&mut rule.rule_id); @@ -267,7 +278,9 @@ async fn db_lt_12(services: &Services) -> Result<()> { if let Some(rule) = rule { let mut rule = rule.clone(); transformation[1].clone_into(&mut rule.rule_id); - rules_list.underride.shift_remove(transformation[0]); + rules_list + .underride + .shift_remove(transformation[0]); rules_list.underride.insert(rule); } } @@ -278,7 +291,9 @@ async fn db_lt_12(services: &Services) -> Result<()> { .update( None, &user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(account_data).expect("to json value always works"), ) .await?; @@ -323,7 +338,9 @@ async fn db_lt_13(services: &Services) -> Result<()> { .update( None, &user, - GlobalAccountDataEventType::PushRules.to_string().into(), + GlobalAccountDataEventType::PushRules + .to_string() + .into(), &serde_json::to_value(account_data).expect("to json value always works"), ) .await?; @@ -435,12 +452,18 @@ async fn retroactively_fix_bad_data_from_roomuserid_joined(services: &Services) for user_id in &joined_members { debug_info!("User is joined, marking as joined"); - services.rooms.state_cache.mark_as_joined(user_id, room_id); + services + .rooms + .state_cache + .mark_as_joined(user_id, room_id); } for user_id in &non_joined_members { debug_info!("User is left or banned, marking as left"); - services.rooms.state_cache.mark_as_left(user_id, room_id); + services + .rooms + .state_cache + .mark_as_left(user_id, room_id); } } diff --git a/src/service/presence/data.rs b/src/service/presence/data.rs index 5583bdf5..9878192d 100644 --- a/src/service/presence/data.rs +++ b/src/service/presence/data.rs @@ -84,8 +84,13 @@ impl Data { let now = utils::millis_since_unix_epoch(); let last_last_active_ts = match last_presence { | Err(_) => 0, - | Ok((_, ref presence)) => - now.saturating_sub(presence.content.last_active_ago.unwrap_or_default().into()), + | Ok((_, ref presence)) => now.saturating_sub( + presence + .content + .last_active_ago + .unwrap_or_default() + .into(), + ), }; let last_active_ts = match last_active_ago { @@ -118,7 +123,8 @@ impl Data { let count = self.services.globals.next_count()?; let key = presenceid_key(count, user_id); - self.presenceid_presence.raw_put(key, Json(presence)); + self.presenceid_presence + .raw_put(key, Json(presence)); self.userid_presenceid.raw_put(user_id, count); if let Ok((last_count, _)) = last_presence { diff --git a/src/service/presence/mod.rs b/src/service/presence/mod.rs index f530c051..b929fbd1 100644 --- a/src/service/presence/mod.rs +++ b/src/service/presence/mod.rs @@ -110,8 +110,11 @@ impl Service { let last_last_active_ago = match last_presence { | Err(_) => 0_u64, - | Ok((_, ref presence)) => - presence.content.last_active_ago.unwrap_or_default().into(), + | Ok((_, ref presence)) => presence + .content + .last_active_ago + .unwrap_or_default() + .into(), }; if !state_changed && last_last_active_ago < REFRESH_TIMEOUT { @@ -151,8 +154,16 @@ impl Service { && user_id != self.services.globals.server_user { let timeout = match presence_state { - | PresenceState::Online => self.services.server.config.presence_idle_timeout_s, - | _ => self.services.server.config.presence_offline_timeout_s, + | PresenceState::Online => + self.services + .server + .config + .presence_idle_timeout_s, + | _ => + self.services + .server + .config + .presence_offline_timeout_s, }; self.timer_channel diff --git a/src/service/pusher/mod.rs b/src/service/pusher/mod.rs index 09f2db90..ba9fb8c3 100644 --- a/src/service/pusher/mod.rs +++ b/src/service/pusher/mod.rs @@ -129,10 +129,13 @@ impl Service { let pushkey = data.pusher.ids.pushkey.as_str(); let key = (sender, pushkey); self.db.senderkey_pusher.put(key, Json(pusher)); - self.db.pushkey_deviceid.insert(pushkey, sender_device); + self.db + .pushkey_deviceid + .insert(pushkey, sender_device); }, | set_pusher::v3::PusherAction::Delete(ids) => { - self.delete_pusher(sender, ids.pushkey.as_str()).await; + self.delete_pusher(sender, ids.pushkey.as_str()) + .await; }, } @@ -152,7 +155,11 @@ impl Service { } pub async fn get_pusher_device(&self, pushkey: &str) -> Result { - self.db.pushkey_deviceid.get(pushkey).await.deserialized() + self.db + .pushkey_deviceid + .get(pushkey) + .await + .deserialized() } pub async fn get_pusher(&self, sender: &UserId, pushkey: &str) -> Result { @@ -217,7 +224,12 @@ impl Service { } } - let response = self.services.client.pusher.execute(reqwest_request).await; + let response = self + .services + .client + .pusher + .execute(reqwest_request) + .await; match response { | Ok(mut response) => { @@ -319,7 +331,8 @@ impl Service { } if notify == Some(true) { - self.send_notice(unread, pusher, tweaks, pdu).await?; + self.send_notice(unread, pusher, tweaks, pdu) + .await?; } // Else the event triggered no actions @@ -460,8 +473,12 @@ impl Service { event.state_key.as_deref() == Some(event.sender.as_str()); } - notifi.sender_display_name = - self.services.users.displayname(&event.sender).await.ok(); + notifi.sender_display_name = self + .services + .users + .displayname(&event.sender) + .await + .ok(); notifi.room_name = self .services diff --git a/src/service/resolver/actual.rs b/src/service/resolver/actual.rs index 5d11c776..bf97a6cb 100644 --- a/src/service/resolver/actual.rs +++ b/src/service/resolver/actual.rs @@ -77,10 +77,12 @@ impl super::Service { self.services.server.check_running()?; match self.request_well_known(dest.as_str()).await? { | Some(delegated) => - self.actual_dest_3(&mut host, cache, delegated).await?, + self.actual_dest_3(&mut host, cache, delegated) + .await?, | _ => match self.query_srv_record(dest.as_str()).await? { | Some(overrider) => - self.actual_dest_4(&host, cache, overrider).await?, + self.actual_dest_4(&host, cache, overrider) + .await?, | _ => self.actual_dest_5(dest, cache).await?, }, } @@ -97,7 +99,8 @@ impl super::Service { let (host, port) = host.split_at(pos); FedDest::Named( host.to_owned(), - port.try_into().unwrap_or_else(|_| FedDest::default_port()), + port.try_into() + .unwrap_or_else(|_| FedDest::default_port()), ) } else { FedDest::Named(host, FedDest::default_port()) @@ -124,7 +127,8 @@ impl super::Service { Ok(FedDest::Named( host.to_owned(), - port.try_into().unwrap_or_else(|_| FedDest::default_port()), + port.try_into() + .unwrap_or_else(|_| FedDest::default_port()), )) } @@ -145,7 +149,8 @@ impl super::Service { trace!("Delegated hostname has no port in this branch"); match self.query_srv_record(&delegated).await? { | Some(overrider) => - self.actual_dest_3_3(cache, delegated, overrider).await, + self.actual_dest_3_3(cache, delegated, overrider) + .await, | _ => self.actual_dest_3_4(cache, delegated).await, } }, @@ -170,7 +175,8 @@ impl super::Service { Ok(FedDest::Named( host.to_owned(), - port.try_into().unwrap_or_else(|_| FedDest::default_port()), + port.try_into() + .unwrap_or_else(|_| FedDest::default_port()), )) } @@ -287,17 +293,23 @@ impl super::Service { self.services.server.check_running()?; debug!("querying IP for {untername:?} ({hostname:?}:{port})"); - match self.resolver.resolver.lookup_ip(hostname.to_owned()).await { + match self + .resolver + .resolver + .lookup_ip(hostname.to_owned()) + .await + { | Err(e) => Self::handle_resolve_error(&e, hostname), | Ok(override_ip) => { - self.cache.set_override(untername, &CachedOverride { - ips: override_ip.into_iter().take(MAX_IPS).collect(), - port, - expire: CachedOverride::default_expire(), - overriding: (hostname != untername) - .then_some(hostname.into()) - .inspect(|_| debug_info!("{untername:?} overriden by {hostname:?}")), - }); + self.cache + .set_override(untername, &CachedOverride { + ips: override_ip.into_iter().take(MAX_IPS).collect(), + port, + expire: CachedOverride::default_expire(), + overriding: (hostname != untername) + .then_some(hostname.into()) + .inspect(|_| debug_info!("{untername:?} overriden by {hostname:?}")), + }); Ok(()) }, @@ -319,7 +331,11 @@ impl super::Service { | Ok(result) => { return Ok(result.iter().next().map(|result| { FedDest::Named( - result.target().to_string().trim_end_matches('.').to_owned(), + result + .target() + .to_string() + .trim_end_matches('.') + .to_owned(), format!(":{}", result.port()) .as_str() .try_into() diff --git a/src/service/resolver/dns.rs b/src/service/resolver/dns.rs index 1db96d7b..edd6417d 100644 --- a/src/service/resolver/dns.rs +++ b/src/service/resolver/dns.rs @@ -127,7 +127,10 @@ async fn hooked_resolve( .boxed() .await, - | _ => resolve_to_reqwest(server, resolver, name).boxed().await, + | _ => + resolve_to_reqwest(server, resolver, name) + .boxed() + .await, } } @@ -139,8 +142,13 @@ async fn resolve_to_reqwest( use std::{io, io::ErrorKind::Interrupted}; let handle_shutdown = || Box::new(io::Error::new(Interrupted, "Server shutting down")); - let handle_results = - |results: LookupIp| Box::new(results.into_iter().map(|ip| SocketAddr::new(ip, 0))); + let handle_results = |results: LookupIp| { + Box::new( + results + .into_iter() + .map(|ip| SocketAddr::new(ip, 0)), + ) + }; tokio::select! { results = resolver.lookup_ip(name.as_str()) => Ok(handle_results(results?)), diff --git a/src/service/rooms/alias/mod.rs b/src/service/rooms/alias/mod.rs index 605b2a88..4b51d331 100644 --- a/src/service/rooms/alias/mod.rs +++ b/src/service/rooms/alias/mod.rs @@ -87,7 +87,9 @@ impl Service { let mut aliasid = room_id.as_bytes().to_vec(); aliasid.push(0xFF); aliasid.extend_from_slice(&self.services.globals.next_count()?.to_be_bytes()); - self.db.aliasid_alias.insert(&aliasid, alias.as_bytes()); + self.db + .aliasid_alias + .insert(&aliasid, alias.as_bytes()); Ok(()) } @@ -171,7 +173,11 @@ impl Service { #[tracing::instrument(skip(self), level = "debug")] pub async fn resolve_local_alias(&self, alias: &RoomAliasId) -> Result { - self.db.alias_roomid.get(alias.alias()).await.deserialized() + self.db + .alias_roomid + .get(alias.alias()) + .await + .deserialized() } #[tracing::instrument(skip(self), level = "debug")] @@ -248,7 +254,11 @@ impl Service { } async fn who_created_alias(&self, alias: &RoomAliasId) -> Result { - self.db.alias_userid.get(alias.alias()).await.deserialized() + self.db + .alias_userid + .get(alias.alias()) + .await + .deserialized() } async fn resolve_appservice_alias( diff --git a/src/service/rooms/auth_chain/mod.rs b/src/service/rooms/auth_chain/mod.rs index 04b4a34e..ec519785 100644 --- a/src/service/rooms/auth_chain/mod.rs +++ b/src/service/rooms/auth_chain/mod.rs @@ -136,7 +136,10 @@ async fn get_auth_chain_outer( return Ok(Vec::new()); } - if let Ok(cached) = self.get_cached_eventid_authchain(&chunk_key).await { + if let Ok(cached) = self + .get_cached_eventid_authchain(&chunk_key) + .await + { return Ok(cached.to_vec()); } @@ -144,11 +147,16 @@ async fn get_auth_chain_outer( .into_iter() .try_stream() .broad_and_then(|(shortid, event_id)| async move { - if let Ok(cached) = self.get_cached_eventid_authchain(&[shortid]).await { + if let Ok(cached) = self + .get_cached_eventid_authchain(&[shortid]) + .await + { return Ok(cached.to_vec()); } - let auth_chain = self.get_auth_chain_inner(room_id, event_id).await?; + let auth_chain = self + .get_auth_chain_inner(room_id, event_id) + .await?; self.cache_auth_chain_vec(vec![shortid], auth_chain.as_slice()); debug!( ?event_id, @@ -254,4 +262,10 @@ pub fn get_cache_usage(&self) -> (usize, usize) { } #[implement(Service)] -pub fn clear_cache(&self) { self.db.auth_chain_cache.lock().expect("locked").clear(); } +pub fn clear_cache(&self) { + self.db + .auth_chain_cache + .lock() + .expect("locked") + .clear(); +} diff --git a/src/service/rooms/event_handler/acl_check.rs b/src/service/rooms/event_handler/acl_check.rs index 5cdfb100..6a8621fa 100644 --- a/src/service/rooms/event_handler/acl_check.rs +++ b/src/service/rooms/event_handler/acl_check.rs @@ -25,8 +25,12 @@ pub async fn acl_check(&self, server_name: &ServerName, room_id: &RoomId) -> Res return Ok(()); } - if acl_event_content.deny.contains(&String::from("*")) - && acl_event_content.allow.contains(&String::from("*")) + if acl_event_content + .deny + .contains(&String::from("*")) + && acl_event_content + .allow + .contains(&String::from("*")) { warn!(%room_id, "Ignoring broken ACL event (allow key and deny key both contain wildcard \"*\""); return Ok(()); diff --git a/src/service/rooms/event_handler/handle_incoming_pdu.rs b/src/service/rooms/event_handler/handle_incoming_pdu.rs index 999ab4f8..51a69d4c 100644 --- a/src/service/rooms/event_handler/handle_incoming_pdu.rs +++ b/src/service/rooms/event_handler/handle_incoming_pdu.rs @@ -66,7 +66,11 @@ pub async fn handle_incoming_pdu<'a>( let meta_exists = self.services.metadata.exists(room_id).map(Ok); // 1.2 Check if the room is disabled - let is_disabled = self.services.metadata.is_disabled(room_id).map(Ok); + let is_disabled = self + .services + .metadata + .is_disabled(room_id) + .map(Ok); // 1.3.1 Check room ACL on origin field/server let origin_acl_check = self.acl_check(origin, room_id); diff --git a/src/service/rooms/event_handler/mod.rs b/src/service/rooms/event_handler/mod.rs index e993505b..4e5eb31d 100644 --- a/src/service/rooms/event_handler/mod.rs +++ b/src/service/rooms/event_handler/mod.rs @@ -100,7 +100,11 @@ impl Service { } async fn event_fetch(&self, event_id: OwnedEventId) -> Option { - self.services.timeline.get_pdu(&event_id).await.ok() + self.services + .timeline + .get_pdu(&event_id) + .await + .ok() } } diff --git a/src/service/rooms/event_handler/resolve_state.rs b/src/service/rooms/event_handler/resolve_state.rs index a57ec1a8..b8a8fb9f 100644 --- a/src/service/rooms/event_handler/resolve_state.rs +++ b/src/service/rooms/event_handler/resolve_state.rs @@ -92,7 +92,11 @@ pub async fn resolve_state( let new_room_state: CompressedState = self .services .state_compressor - .compress_state_events(state_events.iter().map(|(ssk, eid)| (ssk, (*eid).borrow()))) + .compress_state_events( + state_events + .iter() + .map(|(ssk, eid)| (ssk, (*eid).borrow())), + ) .collect() .await; diff --git a/src/service/rooms/event_handler/upgrade_outlier_pdu.rs b/src/service/rooms/event_handler/upgrade_outlier_pdu.rs index 34f3e621..0cc1927e 100644 --- a/src/service/rooms/event_handler/upgrade_outlier_pdu.rs +++ b/src/service/rooms/event_handler/upgrade_outlier_pdu.rs @@ -54,7 +54,8 @@ pub(super) async fn upgrade_outlier_to_timeline_pdu( debug!("Resolving state at event"); let mut state_at_incoming_event = if incoming_pdu.prev_events.len() == 1 { - self.state_at_incoming_degree_one(&incoming_pdu).await? + self.state_at_incoming_degree_one(&incoming_pdu) + .await? } else { self.state_at_incoming_resolved(&incoming_pdu, room_id, &room_version_id) .await? @@ -74,10 +75,19 @@ pub(super) async fn upgrade_outlier_to_timeline_pdu( // 11. Check the auth of the event passes based on the state of the event let state_fetch_state = &state_at_incoming_event; let state_fetch = |k: StateEventType, s: StateKey| async move { - let shortstatekey = self.services.short.get_shortstatekey(&k, &s).await.ok()?; + let shortstatekey = self + .services + .short + .get_shortstatekey(&k, &s) + .await + .ok()?; let event_id = state_fetch_state.get(&shortstatekey)?; - self.services.timeline.get_pdu(event_id).await.ok() + self.services + .timeline + .get_pdu(event_id) + .await + .ok() }; let auth_check = state_res::event_auth::auth_check( diff --git a/src/service/rooms/lazy_loading/mod.rs b/src/service/rooms/lazy_loading/mod.rs index 368c376a..5b0389c5 100644 --- a/src/service/rooms/lazy_loading/mod.rs +++ b/src/service/rooms/lazy_loading/mod.rs @@ -76,7 +76,9 @@ pub async fn witness_retain(&self, senders: Witness, ctx: &Context<'_>) -> Witne ); let include_redundant = cfg!(feature = "element_hacks") - || ctx.options.is_some_and(Options::include_redundant_members); + || ctx + .options + .is_some_and(Options::include_redundant_members); let witness = self .witness(ctx, senders.iter().map(AsRef::as_ref)) diff --git a/src/service/rooms/outlier/mod.rs b/src/service/rooms/outlier/mod.rs index 7fcc5c27..35472e3e 100644 --- a/src/service/rooms/outlier/mod.rs +++ b/src/service/rooms/outlier/mod.rs @@ -48,5 +48,7 @@ pub async fn get_pdu_outlier(&self, event_id: &EventId) -> Result { #[implement(Service)] #[tracing::instrument(skip(self, pdu), level = "debug")] pub fn add_pdu_outlier(&self, event_id: &EventId, pdu: &CanonicalJsonObject) { - self.db.eventid_outlierpdu.raw_put(event_id, Json(pdu)); + self.db + .eventid_outlierpdu + .raw_put(event_id, Json(pdu)); } diff --git a/src/service/rooms/pdu_metadata/data.rs b/src/service/rooms/pdu_metadata/data.rs index 9e7f3a4f..734d0c47 100644 --- a/src/service/rooms/pdu_metadata/data.rs +++ b/src/service/rooms/pdu_metadata/data.rs @@ -52,7 +52,8 @@ impl Data { const BUFSIZE: usize = size_of::() * 2; let key: &[u64] = &[to, from]; - self.tofrom_relation.aput_raw::(key, []); + self.tofrom_relation + .aput_raw::(key, []); } pub(super) fn get_relations<'a>( @@ -65,11 +66,21 @@ impl Data { ) -> impl Stream + Send + '_ { let mut current = ArrayVec::::new(); current.extend(target.to_be_bytes()); - current.extend(from.saturating_inc(dir).into_unsigned().to_be_bytes()); + current.extend( + from.saturating_inc(dir) + .into_unsigned() + .to_be_bytes(), + ); let current = current.as_slice(); match dir { - | Direction::Forward => self.tofrom_relation.raw_keys_from(current).boxed(), - | Direction::Backward => self.tofrom_relation.rev_raw_keys_from(current).boxed(), + | Direction::Forward => self + .tofrom_relation + .raw_keys_from(current) + .boxed(), + | Direction::Backward => self + .tofrom_relation + .rev_raw_keys_from(current) + .boxed(), } .ignore_err() .ready_take_while(move |key| key.starts_with(&target.to_be_bytes())) @@ -78,7 +89,12 @@ impl Data { .wide_filter_map(move |shorteventid| async move { let pdu_id: RawPduId = PduId { shortroomid, shorteventid }.into(); - let mut pdu = self.services.timeline.get_pdu_from_id(&pdu_id).await.ok()?; + let mut pdu = self + .services + .timeline + .get_pdu_from_id(&pdu_id) + .await + .ok()?; if pdu.sender != user_id { pdu.remove_transaction_id().log_err().ok(); @@ -109,6 +125,9 @@ impl Data { } pub(super) async fn is_event_soft_failed(&self, event_id: &EventId) -> bool { - self.softfailedeventids.get(event_id).await.is_ok() + self.softfailedeventids + .get(event_id) + .await + .is_ok() } } diff --git a/src/service/rooms/pdu_metadata/mod.rs b/src/service/rooms/pdu_metadata/mod.rs index f46b41ee..45fcbda0 100644 --- a/src/service/rooms/pdu_metadata/mod.rs +++ b/src/service/rooms/pdu_metadata/mod.rs @@ -119,7 +119,9 @@ impl Service { #[inline] #[tracing::instrument(skip(self), level = "debug")] pub async fn is_event_referenced(&self, room_id: &RoomId, event_id: &EventId) -> bool { - self.db.is_event_referenced(room_id, event_id).await + self.db + .is_event_referenced(room_id, event_id) + .await } #[inline] diff --git a/src/service/rooms/read_receipt/data.rs b/src/service/rooms/read_receipt/data.rs index 844722fe..65436362 100644 --- a/src/service/rooms/read_receipt/data.rs +++ b/src/service/rooms/read_receipt/data.rs @@ -58,7 +58,8 @@ impl Data { let count = self.services.globals.next_count().unwrap(); let latest_id = (room_id, count, user_id); - self.readreceiptid_readreceipt.put(latest_id, Json(event)); + self.readreceiptid_readreceipt + .put(latest_id, Json(event)); } pub(super) fn readreceipts_since<'a>( @@ -91,7 +92,8 @@ impl Data { let next_count = self.services.globals.next_count().unwrap(); self.roomuserid_privateread.put(key, pdu_count); - self.roomuserid_lastprivatereadupdate.put(key, next_count); + self.roomuserid_lastprivatereadupdate + .put(key, next_count); } pub(super) async fn private_read_get_count( @@ -100,7 +102,10 @@ impl Data { user_id: &UserId, ) -> Result { let key = (room_id, user_id); - self.roomuserid_privateread.qry(&key).await.deserialized() + self.roomuserid_privateread + .qry(&key) + .await + .deserialized() } pub(super) async fn last_privateread_update( diff --git a/src/service/rooms/read_receipt/mod.rs b/src/service/rooms/read_receipt/mod.rs index 658568b0..14684612 100644 --- a/src/service/rooms/read_receipt/mod.rs +++ b/src/service/rooms/read_receipt/mod.rs @@ -54,7 +54,9 @@ impl Service { room_id: &RoomId, event: &ReceiptEvent, ) { - self.db.readreceipt_update(user_id, room_id, event).await; + self.db + .readreceipt_update(user_id, room_id, event) + .await; self.services .sending .flush_room(room_id) @@ -68,18 +70,30 @@ impl Service { room_id: &RoomId, user_id: &UserId, ) -> Result> { - let pdu_count = self.private_read_get_count(room_id, user_id).map_err(|e| { - err!(Database(warn!("No private read receipt was set in {room_id}: {e}"))) - }); - let shortroomid = self.services.short.get_shortroomid(room_id).map_err(|e| { - err!(Database(warn!("Short room ID does not exist in database for {room_id}: {e}"))) - }); + let pdu_count = self + .private_read_get_count(room_id, user_id) + .map_err(|e| { + err!(Database(warn!("No private read receipt was set in {room_id}: {e}"))) + }); + let shortroomid = self + .services + .short + .get_shortroomid(room_id) + .map_err(|e| { + err!(Database(warn!( + "Short room ID does not exist in database for {room_id}: {e}" + ))) + }); let (pdu_count, shortroomid) = try_join!(pdu_count, shortroomid)?; let shorteventid = PduCount::Normal(pdu_count); let pdu_id: RawPduId = PduId { shortroomid, shorteventid }.into(); - let pdu = self.services.timeline.get_pdu_from_id(&pdu_id).await?; + let pdu = self + .services + .timeline + .get_pdu_from_id(&pdu_id) + .await?; let event_id: OwnedEventId = pdu.event_id; let user_id: OwnedUserId = user_id.to_owned(); @@ -129,13 +143,17 @@ impl Service { room_id: &RoomId, user_id: &UserId, ) -> Result { - self.db.private_read_get_count(room_id, user_id).await + self.db + .private_read_get_count(room_id, user_id) + .await } /// Returns the PDU count of the last typing update in this room. #[inline] pub async fn last_privateread_update(&self, user_id: &UserId, room_id: &RoomId) -> u64 { - self.db.last_privateread_update(user_id, room_id).await + self.db + .last_privateread_update(user_id, room_id) + .await } } diff --git a/src/service/rooms/search/mod.rs b/src/service/rooms/search/mod.rs index 08cadb68..b128cba1 100644 --- a/src/service/rooms/search/mod.rs +++ b/src/service/rooms/search/mod.rs @@ -139,9 +139,15 @@ pub async fn search_pdu_ids( &self, query: &RoomQuery<'_>, ) -> Result + Send + '_ + use<'_>> { - let shortroomid = self.services.short.get_shortroomid(query.room_id).await?; + let shortroomid = self + .services + .short + .get_shortroomid(query.room_id) + .await?; - let pdu_ids = self.search_pdu_ids_query_room(query, shortroomid).await; + let pdu_ids = self + .search_pdu_ids_query_room(query, shortroomid) + .await; let iters = pdu_ids.into_iter().map(IntoIterator::into_iter); diff --git a/src/service/rooms/short/mod.rs b/src/service/rooms/short/mod.rs index a4d1243c..d968d03d 100644 --- a/src/service/rooms/short/mod.rs +++ b/src/service/rooms/short/mod.rs @@ -112,7 +112,10 @@ pub async fn get_or_create_shortstatekey( ) -> ShortStateKey { const BUFSIZE: usize = size_of::(); - if let Ok(shortstatekey) = self.get_shortstatekey(event_type, state_key).await { + if let Ok(shortstatekey) = self + .get_shortstatekey(event_type, state_key) + .await + { return shortstatekey; } @@ -235,7 +238,11 @@ pub async fn get_or_create_shortstatehash(&self, state_hash: &[u8]) -> (ShortSta #[implement(Service)] pub async fn get_shortroomid(&self, room_id: &RoomId) -> Result { - self.db.roomid_shortroomid.get(room_id).await.deserialized() + self.db + .roomid_shortroomid + .get(room_id) + .await + .deserialized() } #[implement(Service)] diff --git a/src/service/rooms/spaces/mod.rs b/src/service/rooms/spaces/mod.rs index 9e648acc..bbf6331f 100644 --- a/src/service/rooms/spaces/mod.rs +++ b/src/service/rooms/spaces/mod.rs @@ -92,14 +92,23 @@ impl crate::Service for Service { } async fn memory_usage(&self, out: &mut (dyn Write + Send)) -> Result { - let roomid_spacehierarchy_cache = self.roomid_spacehierarchy_cache.lock().await.len(); + let roomid_spacehierarchy_cache = self + .roomid_spacehierarchy_cache + .lock() + .await + .len(); writeln!(out, "roomid_spacehierarchy_cache: {roomid_spacehierarchy_cache}")?; Ok(()) } - async fn clear_cache(&self) { self.roomid_spacehierarchy_cache.lock().await.clear(); } + async fn clear_cache(&self) { + self.roomid_spacehierarchy_cache + .lock() + .await + .clear(); + } fn name(&self) -> &str { crate::service::make_name(std::module_path!()) } } @@ -121,7 +130,11 @@ pub async fn get_summary_and_children_local( | None => (), // cache miss | Some(None) => return Ok(None), | Some(Some(cached)) => { - let allowed_rooms = cached.summary.allowed_room_ids.iter().map(AsRef::as_ref); + let allowed_rooms = cached + .summary + .allowed_room_ids + .iter() + .map(AsRef::as_ref); let is_accessible_child = self.is_accessible_child( current_room, @@ -154,10 +167,13 @@ pub async fn get_summary_and_children_local( return Ok(None); }; - self.roomid_spacehierarchy_cache.lock().await.insert( - current_room.to_owned(), - Some(CachedSpaceHierarchySummary { summary: summary.clone() }), - ); + self.roomid_spacehierarchy_cache + .lock() + .await + .insert( + current_room.to_owned(), + Some(CachedSpaceHierarchySummary { summary: summary.clone() }), + ); Ok(Some(SummaryAccessibility::Accessible(summary))) } @@ -196,10 +212,13 @@ async fn get_summary_and_children_federation( }; let summary = response.room; - self.roomid_spacehierarchy_cache.lock().await.insert( - current_room.to_owned(), - Some(CachedSpaceHierarchySummary { summary: summary.clone() }), - ); + self.roomid_spacehierarchy_cache + .lock() + .await + .insert( + current_room.to_owned(), + Some(CachedSpaceHierarchySummary { summary: summary.clone() }), + ); response .children @@ -304,7 +323,11 @@ async fn get_room_summary( children_state: Vec>, identifier: &Identifier<'_>, ) -> Result { - let join_rule = self.services.state_accessor.get_join_rules(room_id).await; + let join_rule = self + .services + .state_accessor + .get_join_rules(room_id) + .await; let is_accessible_child = self .is_accessible_child( @@ -319,15 +342,33 @@ async fn get_room_summary( return Err!(Request(Forbidden("User is not allowed to see the room"))); } - let name = self.services.state_accessor.get_name(room_id).ok(); + let name = self + .services + .state_accessor + .get_name(room_id) + .ok(); - let topic = self.services.state_accessor.get_room_topic(room_id).ok(); + let topic = self + .services + .state_accessor + .get_room_topic(room_id) + .ok(); - let room_type = self.services.state_accessor.get_room_type(room_id).ok(); + let room_type = self + .services + .state_accessor + .get_room_type(room_id) + .ok(); - let world_readable = self.services.state_accessor.is_world_readable(room_id); + let world_readable = self + .services + .state_accessor + .is_world_readable(room_id); - let guest_can_join = self.services.state_accessor.guest_can_join(room_id); + let guest_can_join = self + .services + .state_accessor + .guest_can_join(room_id); let num_joined_members = self .services @@ -392,7 +433,10 @@ async fn get_room_summary( room_version, room_id: room_id.to_owned(), num_joined_members: num_joined_members.try_into().unwrap_or_default(), - allowed_room_ids: join_rule.allowed_rooms().map(Into::into).collect(), + allowed_room_ids: join_rule + .allowed_rooms() + .map(Into::into) + .collect(), join_rule: join_rule.clone().into(), }; @@ -425,9 +469,15 @@ where } if let Identifier::UserId(user_id) = identifier { - let is_joined = self.services.state_cache.is_joined(user_id, current_room); + let is_joined = self + .services + .state_cache + .is_joined(user_id, current_room); - let is_invited = self.services.state_cache.is_invited(user_id, current_room); + let is_invited = self + .services + .state_cache + .is_invited(user_id, current_room); pin_mut!(is_joined, is_invited); if is_joined.or(is_invited).await { @@ -444,9 +494,15 @@ where .stream() .any(async |room| match identifier { | Identifier::UserId(user) => - self.services.state_cache.is_joined(user, room).await, + self.services + .state_cache + .is_joined(user, room) + .await, | Identifier::ServerName(server) => - self.services.state_cache.server_in_room(server, room).await, + self.services + .state_cache + .server_in_room(server, room) + .await, }) .await, diff --git a/src/service/rooms/state/mod.rs b/src/service/rooms/state/mod.rs index 04fe78ba..659f515a 100644 --- a/src/service/rooms/state/mod.rs +++ b/src/service/rooms/state/mod.rs @@ -120,7 +120,11 @@ impl Service { match pdu.kind { | TimelineEventType::RoomMember => { - let Some(user_id) = pdu.state_key.as_ref().map(UserId::parse).flat_ok() + let Some(user_id) = pdu + .state_key + .as_ref() + .map(UserId::parse) + .flat_ok() else { continue; }; @@ -154,7 +158,10 @@ impl Service { } } - self.services.state_cache.update_joined_count(room_id).await; + self.services + .state_cache + .update_joined_count(room_id) + .await; self.set_room_state(room_id, shortstatehash, state_lock); @@ -218,13 +225,15 @@ impl Service { } else { (state_ids_compressed, Arc::new(CompressedState::new())) }; - self.services.state_compressor.save_state_from_diff( - shortstatehash, - statediffnew, - statediffremoved, - 1_000_000, // high number because no state will be based on this one - states_parents, - )?; + self.services + .state_compressor + .save_state_from_diff( + shortstatehash, + statediffnew, + statediffremoved, + 1_000_000, // high number because no state will be based on this one + states_parents, + )?; } self.db @@ -248,7 +257,9 @@ impl Service { .get_or_create_shorteventid(&new_pdu.event_id) .await; - let previous_shortstatehash = self.get_room_shortstatehash(&new_pdu.room_id).await; + let previous_shortstatehash = self + .get_room_shortstatehash(&new_pdu.room_id) + .await; if let Ok(p) = previous_shortstatehash { self.db @@ -303,13 +314,15 @@ impl Service { statediffremoved.insert(*replaces); } - self.services.state_compressor.save_state_from_diff( - shortstatehash, - Arc::new(statediffnew), - Arc::new(statediffremoved), - 2, - states_parents, - )?; + self.services + .state_compressor + .save_state_from_diff( + shortstatehash, + Arc::new(statediffnew), + Arc::new(statediffremoved), + 2, + states_parents, + )?; Ok(shortstatehash) }, diff --git a/src/service/rooms/state_accessor/room_state.rs b/src/service/rooms/state_accessor/room_state.rs index 8c6f2cf4..f4bde04a 100644 --- a/src/service/rooms/state_accessor/room_state.rs +++ b/src/service/rooms/state_accessor/room_state.rs @@ -49,7 +49,11 @@ pub fn room_state_full_pdus<'a>( self.services .state .get_room_shortstatehash(room_id) - .map_ok(|shortstatehash| self.state_full_pdus(shortstatehash).map(Ok).boxed()) + .map_ok(|shortstatehash| { + self.state_full_pdus(shortstatehash) + .map(Ok) + .boxed() + }) .map_err(move |e| err!(Database("Missing state for {room_id:?}: {e:?}"))) .try_flatten_stream() } diff --git a/src/service/rooms/state_accessor/state.rs b/src/service/rooms/state_accessor/state.rs index 8f20e1a3..fc9234bd 100644 --- a/src/service/rooms/state_accessor/state.rs +++ b/src/service/rooms/state_accessor/state.rs @@ -29,7 +29,8 @@ use crate::rooms::{ #[implement(super::Service)] #[inline] pub async fn user_was_joined(&self, shortstatehash: ShortStateHash, user_id: &UserId) -> bool { - self.user_membership(shortstatehash, user_id).await == MembershipState::Join + self.user_membership(shortstatehash, user_id) + .await == MembershipState::Join } /// The user was an invited or joined room member at this state (potentially @@ -37,7 +38,9 @@ pub async fn user_was_joined(&self, shortstatehash: ShortStateHash, user_id: &Us #[implement(super::Service)] #[inline] pub async fn user_was_invited(&self, shortstatehash: ShortStateHash, user_id: &UserId) -> bool { - let s = self.user_membership(shortstatehash, user_id).await; + let s = self + .user_membership(shortstatehash, user_id) + .await; s == MembershipState::Join || s == MembershipState::Invite } @@ -259,7 +262,9 @@ pub fn state_keys_with_shortids<'a>( .zip(shorteventids) .ready_filter_map(|(res, id)| res.map(|res| (res, id)).ok()) .ready_filter_map(move |((event_type_, state_key), event_id)| { - event_type_.eq(event_type).then_some((state_key, event_id)) + event_type_ + .eq(event_type) + .then_some((state_key, event_id)) }) } @@ -338,7 +343,11 @@ pub fn state_full_pdus( .multi_get_eventid_from_short(short_ids) .ready_filter_map(Result::ok) .broad_filter_map(move |event_id: OwnedEventId| async move { - self.services.timeline.get_pdu(&event_id).await.ok() + self.services + .timeline + .get_pdu(&event_id) + .await + .ok() }) } @@ -406,7 +415,12 @@ async fn load_full_state(&self, shortstatehash: ShortStateHash) -> Result { // Allow if any member on requesting server was AT LEAST invited, else deny - self.user_was_invited(shortstatehash, user_id).await + self.user_was_invited(shortstatehash, user_id) + .await }, | HistoryVisibility::Joined => { // Allow if any member on requested server was joined, else deny - self.user_was_joined(shortstatehash, user_id).await + self.user_was_joined(shortstatehash, user_id) + .await }, | HistoryVisibility::WorldReadable => true, | HistoryVisibility::Shared | _ => currently_member, @@ -126,7 +132,12 @@ pub async fn user_can_see_event( #[implement(super::Service)] #[tracing::instrument(skip_all, level = "trace")] pub async fn user_can_see_state_events(&self, user_id: &UserId, room_id: &RoomId) -> bool { - if self.services.state_cache.is_joined(user_id, room_id).await { + if self + .services + .state_cache + .is_joined(user_id, room_id) + .await + { return true; } @@ -139,7 +150,10 @@ pub async fn user_can_see_state_events(&self, user_id: &UserId, room_id: &RoomId match history_visibility { | HistoryVisibility::Invited => - self.services.state_cache.is_invited(user_id, room_id).await, + self.services + .state_cache + .is_invited(user_id, room_id) + .await, | HistoryVisibility::WorldReadable => true, | _ => false, } diff --git a/src/service/rooms/state_cache/mod.rs b/src/service/rooms/state_cache/mod.rs index f77af80b..dbb0691f 100644 --- a/src/service/rooms/state_cache/mod.rs +++ b/src/service/rooms/state_cache/mod.rs @@ -248,7 +248,9 @@ impl Service { .update( None, user_id, - GlobalAccountDataEventType::Direct.to_string().into(), + GlobalAccountDataEventType::Direct + .to_string() + .into(), &serde_json::to_value(&direct_event) .expect("to json always works"), ) @@ -262,7 +264,12 @@ impl Service { }, | MembershipState::Invite => { // We want to know if the sender is ignored by the receiver - if self.services.users.user_is_ignored(sender, user_id).await { + if self + .services + .users + .user_is_ignored(sender, user_id) + .await + { return Ok(()); } @@ -346,14 +353,22 @@ impl Service { self.db.userroomid_joined.insert(&userroom_id, []); self.db.roomuserid_joined.insert(&roomuser_id, []); - self.db.userroomid_invitestate.remove(&userroom_id); - self.db.roomuserid_invitecount.remove(&roomuser_id); + self.db + .userroomid_invitestate + .remove(&userroom_id); + self.db + .roomuserid_invitecount + .remove(&roomuser_id); self.db.userroomid_leftstate.remove(&userroom_id); self.db.roomuserid_leftcount.remove(&roomuser_id); - self.db.userroomid_knockedstate.remove(&userroom_id); - self.db.roomuserid_knockedcount.remove(&roomuser_id); + self.db + .userroomid_knockedstate + .remove(&userroom_id); + self.db + .roomuserid_knockedcount + .remove(&roomuser_id); self.db.roomid_inviteviaservers.remove(room_id); } @@ -382,11 +397,19 @@ impl Service { self.db.userroomid_joined.remove(&userroom_id); self.db.roomuserid_joined.remove(&roomuser_id); - self.db.userroomid_invitestate.remove(&userroom_id); - self.db.roomuserid_invitecount.remove(&roomuser_id); + self.db + .userroomid_invitestate + .remove(&userroom_id); + self.db + .roomuserid_invitecount + .remove(&roomuser_id); - self.db.userroomid_knockedstate.remove(&userroom_id); - self.db.roomuserid_knockedcount.remove(&roomuser_id); + self.db + .userroomid_knockedstate + .remove(&userroom_id); + self.db + .roomuserid_knockedcount + .remove(&roomuser_id); self.db.roomid_inviteviaservers.remove(room_id); } @@ -417,8 +440,12 @@ impl Service { self.db.userroomid_joined.remove(&userroom_id); self.db.roomuserid_joined.remove(&roomuser_id); - self.db.userroomid_invitestate.remove(&userroom_id); - self.db.roomuserid_invitecount.remove(&roomuser_id); + self.db + .userroomid_invitestate + .remove(&userroom_id); + self.db + .roomuserid_invitecount + .remove(&roomuser_id); self.db.userroomid_leftstate.remove(&userroom_id); self.db.roomuserid_leftcount.remove(&roomuser_id); @@ -523,7 +550,11 @@ impl Service { /// Returns the number of users which are currently in a room #[tracing::instrument(skip(self), level = "trace")] pub async fn room_joined_count(&self, room_id: &RoomId) -> Result { - self.db.roomid_joinedcount.get(room_id).await.deserialized() + self.db + .roomid_joinedcount + .get(room_id) + .await + .deserialized() } #[tracing::instrument(skip(self), level = "debug")] @@ -623,7 +654,11 @@ impl Service { #[tracing::instrument(skip(self), level = "trace")] pub async fn get_left_count(&self, room_id: &RoomId, user_id: &UserId) -> Result { let key = (room_id, user_id); - self.db.roomuserid_leftcount.qry(&key).await.deserialized() + self.db + .roomuserid_leftcount + .qry(&key) + .await + .deserialized() } /// Returns an iterator over all rooms this user joined. @@ -750,7 +785,11 @@ impl Service { #[tracing::instrument(skip(self), level = "debug")] pub async fn once_joined(&self, user_id: &UserId, room_id: &RoomId) -> bool { let key = (user_id, room_id); - self.db.roomuseroncejoinedids.qry(&key).await.is_ok() + self.db + .roomuseroncejoinedids + .qry(&key) + .await + .is_ok() } #[tracing::instrument(skip(self), level = "trace")] @@ -762,19 +801,31 @@ impl Service { #[tracing::instrument(skip(self), level = "trace")] pub async fn is_knocked<'a>(&'a self, user_id: &'a UserId, room_id: &'a RoomId) -> bool { let key = (user_id, room_id); - self.db.userroomid_knockedstate.qry(&key).await.is_ok() + self.db + .userroomid_knockedstate + .qry(&key) + .await + .is_ok() } #[tracing::instrument(skip(self), level = "trace")] pub async fn is_invited(&self, user_id: &UserId, room_id: &RoomId) -> bool { let key = (user_id, room_id); - self.db.userroomid_invitestate.qry(&key).await.is_ok() + self.db + .userroomid_invitestate + .qry(&key) + .await + .is_ok() } #[tracing::instrument(skip(self), level = "trace")] pub async fn is_left(&self, user_id: &UserId, room_id: &RoomId) -> bool { let key = (user_id, room_id); - self.db.userroomid_leftstate.qry(&key).await.is_ok() + self.db + .userroomid_leftstate + .qry(&key) + .await + .is_ok() } #[tracing::instrument(skip(self), level = "trace")] @@ -856,7 +907,10 @@ impl Service { } pub fn get_appservice_in_room_cache_usage(&self) -> (usize, usize) { - let cache = self.appservice_in_room_cache.read().expect("locked"); + let cache = self + .appservice_in_room_cache + .read() + .expect("locked"); (cache.len(), cache.capacity()) } @@ -899,8 +953,12 @@ impl Service { .unwrap_or(0), ); - self.db.roomid_joinedcount.raw_put(room_id, joinedcount); - self.db.roomid_invitedcount.raw_put(room_id, invitedcount); + self.db + .roomid_joinedcount + .raw_put(room_id, joinedcount); + self.db + .roomid_invitedcount + .raw_put(room_id, invitedcount); self.db .roomuserid_knockedcount .raw_put(room_id, knockedcount); @@ -968,11 +1026,16 @@ impl Service { self.db.userroomid_leftstate.remove(&userroom_id); self.db.roomuserid_leftcount.remove(&roomuser_id); - self.db.userroomid_knockedstate.remove(&userroom_id); - self.db.roomuserid_knockedcount.remove(&roomuser_id); + self.db + .userroomid_knockedstate + .remove(&userroom_id); + self.db + .roomuserid_knockedcount + .remove(&roomuser_id); if let Some(servers) = invite_via.filter(is_not_empty!()) { - self.add_servers_invite_via(room_id, servers).await; + self.add_servers_invite_via(room_id, servers) + .await; } } diff --git a/src/service/rooms/state_compressor/mod.rs b/src/service/rooms/state_compressor/mod.rs index 385cf0c2..52c90953 100644 --- a/src/service/rooms/state_compressor/mod.rs +++ b/src/service/rooms/state_compressor/mod.rs @@ -87,22 +87,26 @@ impl crate::Service for Service { async fn memory_usage(&self, out: &mut (dyn Write + Send)) -> Result { let (cache_len, ents) = { let cache = self.stateinfo_cache.lock().expect("locked"); - let ents = cache.iter().map(at!(1)).flat_map(|vec| vec.iter()).fold( - HashMap::new(), - |mut ents, ssi| { + let ents = cache + .iter() + .map(at!(1)) + .flat_map(|vec| vec.iter()) + .fold(HashMap::new(), |mut ents, ssi| { for cs in &[&ssi.added, &ssi.removed, &ssi.full_state] { ents.insert(Arc::as_ptr(cs), compressed_state_size(cs)); } ents - }, - ); + }); (cache.len(), ents) }; let ents_len = ents.len(); - let bytes = ents.values().copied().fold(0_usize, usize::saturating_add); + let bytes = ents + .values() + .copied() + .fold(0_usize, usize::saturating_add); let bytes = bytes::pretty(bytes); writeln!(out, "stateinfo_cache: {cache_len} {ents_len} ({bytes})")?; @@ -110,7 +114,12 @@ impl crate::Service for Service { Ok(()) } - async fn clear_cache(&self) { self.stateinfo_cache.lock().expect("locked").clear(); } + async fn clear_cache(&self) { + self.stateinfo_cache + .lock() + .expect("locked") + .clear(); + } fn name(&self) -> &str { crate::service::make_name(std::module_path!()) } } @@ -123,11 +132,17 @@ impl Service { &self, shortstatehash: ShortStateHash, ) -> Result { - if let Some(r) = self.stateinfo_cache.lock()?.get_mut(&shortstatehash) { + if let Some(r) = self + .stateinfo_cache + .lock()? + .get_mut(&shortstatehash) + { return Ok(r.clone()); } - let stack = self.new_shortstatehash_info(shortstatehash).await?; + let stack = self + .new_shortstatehash_info(shortstatehash) + .await?; self.cache_shortstatehash_info(shortstatehash, stack.clone()) .await?; @@ -151,7 +166,9 @@ impl Service { shortstatehash: ShortStateHash, stack: ShortStateInfoVec, ) -> Result { - self.stateinfo_cache.lock()?.insert(shortstatehash, stack); + self.stateinfo_cache + .lock()? + .insert(shortstatehash, stack); Ok(()) } @@ -262,7 +279,9 @@ impl Service { if parent_states.len() > 3 { // Number of layers // To many layers, we have to go deeper - let parent = parent_states.pop().expect("parent must have a state"); + let parent = parent_states + .pop() + .expect("parent must have a state"); let mut parent_new = (*parent.added).clone(); let mut parent_removed = (*parent.removed).clone(); @@ -311,7 +330,9 @@ impl Service { // 1. We add the current diff on top of the parent layer. // 2. We replace a layer above - let parent = parent_states.pop().expect("parent must have a state"); + let parent = parent_states + .pop() + .expect("parent must have a state"); let parent_added_len = parent.added.len(); let parent_removed_len = parent.removed.len(); let parent_diff = checked!(parent_added_len + parent_removed_len)?; @@ -373,8 +394,11 @@ impl Service { .await .ok(); - let state_hash = - utils::calculate_hash(new_state_ids_compressed.iter().map(|bytes| &bytes[..])); + let state_hash = utils::calculate_hash( + new_state_ids_compressed + .iter() + .map(|bytes| &bytes[..]), + ); let (new_shortstatehash, already_existed) = self .services @@ -390,7 +414,9 @@ impl Service { } let states_parents = if let Some(p) = previous_shortstatehash { - self.load_shortstatehash_info(p).await.unwrap_or_default() + self.load_shortstatehash_info(p) + .await + .unwrap_or_default() } else { ShortStateInfoVec::new() }; diff --git a/src/service/rooms/threads/mod.rs b/src/service/rooms/threads/mod.rs index a766779a..16549018 100644 --- a/src/service/rooms/threads/mod.rs +++ b/src/service/rooms/threads/mod.rs @@ -141,7 +141,11 @@ impl Service { shorteventid: PduCount, _inc: &'a IncludeThreads, ) -> Result + Send + 'a> { - let shortroomid: ShortRoomId = self.services.short.get_shortroomid(room_id).await?; + let shortroomid: ShortRoomId = self + .services + .short + .get_shortroomid(room_id) + .await?; let current: RawPduId = PduId { shortroomid, @@ -157,7 +161,12 @@ impl Service { .map(RawPduId::from) .ready_take_while(move |pdu_id| pdu_id.shortroomid() == shortroomid.to_be_bytes()) .wide_filter_map(move |pdu_id| async move { - let mut pdu = self.services.timeline.get_pdu_from_id(&pdu_id).await.ok()?; + let mut pdu = self + .services + .timeline + .get_pdu_from_id(&pdu_id) + .await + .ok()?; let pdu_id: PduId = pdu_id.into(); if pdu.sender != user_id { @@ -187,6 +196,10 @@ impl Service { } pub(super) async fn get_participants(&self, root_id: &RawPduId) -> Result> { - self.db.threadid_userids.get(root_id).await.deserialized() + self.db + .threadid_userids + .get(root_id) + .await + .deserialized() } } diff --git a/src/service/rooms/timeline/data.rs b/src/service/rooms/timeline/data.rs index 7f2caaae..643b1d7b 100644 --- a/src/service/rooms/timeline/data.rs +++ b/src/service/rooms/timeline/data.rs @@ -159,7 +159,9 @@ impl Data { let non_outlier = self.non_outlier_pdu_exists(event_id).boxed(); let outlier = self.outlier_pdu_exists(event_id).boxed(); - select_ok([non_outlier, outlier]).await.map(at!(0)) + select_ok([non_outlier, outlier]) + .await + .map(at!(0)) } /// Returns the pdu. @@ -187,8 +189,10 @@ impl Data { debug_assert!(matches!(count, PduCount::Normal(_)), "PduCount not Normal"); self.pduid_pdu.raw_put(pdu_id, Json(json)); - self.eventid_pduid.insert(pdu.event_id.as_bytes(), pdu_id); - self.eventid_outlierpdu.remove(pdu.event_id.as_bytes()); + self.eventid_pduid + .insert(pdu.event_id.as_bytes(), pdu_id); + self.eventid_outlierpdu + .remove(pdu.event_id.as_bytes()); } pub(super) fn prepend_backfill_pdu( diff --git a/src/service/rooms/timeline/mod.rs b/src/service/rooms/timeline/mod.rs index b6c7ad87..8e921f34 100644 --- a/src/service/rooms/timeline/mod.rs +++ b/src/service/rooms/timeline/mod.rs @@ -184,7 +184,9 @@ impl Service { sender_user: Option<&UserId>, room_id: &RoomId, ) -> Result { - self.db.last_timeline_count(sender_user, room_id).await + self.db + .last_timeline_count(sender_user, room_id) + .await } /// Returns the `count` of this pdu's id. @@ -363,7 +365,9 @@ impl Service { let pdu_id: RawPduId = PduId { shortroomid, shorteventid: count2 }.into(); // Insert pdu - self.db.append_pdu(&pdu_id, pdu, &pdu_json, count2).await; + self.db + .append_pdu(&pdu_id, pdu, &pdu_json, count2) + .await; drop(insert_lock); @@ -395,7 +399,12 @@ impl Service { if let Some(state_key) = &pdu.state_key { let target_user_id = UserId::parse(state_key)?; - if self.services.users.is_active_local(target_user_id).await { + if self + .services + .users + .is_active_local(target_user_id) + .await + { push_target.insert(target_user_id.to_owned()); } } @@ -462,7 +471,11 @@ impl Service { | TimelineEventType::RoomRedaction => { use RoomVersionId::*; - let room_version_id = self.services.state.get_room_version(&pdu.room_id).await?; + let room_version_id = self + .services + .state + .get_room_version(&pdu.room_id) + .await?; match room_version_id { | V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | V10 => { if let Some(redact_id) = &pdu.redacts { @@ -472,7 +485,8 @@ impl Service { .user_can_redact(redact_id, &pdu.sender, &pdu.room_id, false) .await? { - self.redact_pdu(redact_id, pdu, shortroomid).await?; + self.redact_pdu(redact_id, pdu, shortroomid) + .await?; } } }, @@ -485,7 +499,8 @@ impl Service { .user_can_redact(redact_id, &pdu.sender, &pdu.room_id, false) .await? { - self.redact_pdu(redact_id, pdu, shortroomid).await?; + self.redact_pdu(redact_id, pdu, shortroomid) + .await?; } } }, @@ -508,8 +523,12 @@ impl Service { let content: RoomMemberEventContent = pdu.get_content()?; let stripped_state = match content.membership { - | MembershipState::Invite | MembershipState::Knock => - self.services.state.summary_stripped(pdu).await.into(), + | MembershipState::Invite | MembershipState::Knock => self + .services + .state + .summary_stripped(pdu) + .await + .into(), | _ => None, }; @@ -533,9 +552,16 @@ impl Service { | TimelineEventType::RoomMessage => { let content: ExtractBody = pdu.get_content()?; if let Some(body) = content.body { - self.services.search.index_pdu(shortroomid, &pdu_id, &body); + self.services + .search + .index_pdu(shortroomid, &pdu_id, &body); - if self.services.admin.is_admin_command(pdu, &body).await { + if self + .services + .admin + .is_admin_command(pdu, &body) + .await + { self.services .admin .command(body, Some((*pdu.event_id).into()))?; @@ -546,7 +572,10 @@ impl Service { } if let Ok(content) = pdu.get_content::() { - if let Ok(related_pducount) = self.get_pdu_count(&content.relates_to.event_id).await { + if let Ok(related_pducount) = self + .get_pdu_count(&content.relates_to.event_id) + .await + { self.services .pdu_metadata .add_relation(count2, related_pducount); @@ -834,14 +863,26 @@ impl Service { .create_hash_and_sign_event(pdu_builder, sender, room_id, state_lock) .await?; - if self.services.admin.is_admin_room(&pdu.room_id).await { - self.check_pdu_for_admin_room(&pdu, sender).boxed().await?; + if self + .services + .admin + .is_admin_room(&pdu.room_id) + .await + { + self.check_pdu_for_admin_room(&pdu, sender) + .boxed() + .await?; } // If redaction event is not authorized, do not append it to the timeline if pdu.kind == TimelineEventType::RoomRedaction { use RoomVersionId::*; - match self.services.state.get_room_version(&pdu.room_id).await? { + match self + .services + .state + .get_room_version(&pdu.room_id) + .await? + { | V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | V10 => { if let Some(redact_id) = &pdu.redacts { if !self @@ -885,7 +926,10 @@ impl Service { .join_authorized_via_users_server .as_ref() .is_some_and(|authorising_user| { - !self.services.globals.user_is_local(authorising_user) + !self + .services + .globals + .user_is_local(authorising_user) }) { return Err!(Request(InvalidParam( "Authorising user does not belong to this homeserver" @@ -999,7 +1043,8 @@ impl Service { user_id: &'a UserId, room_id: &'a RoomId, ) -> impl Stream + Send + 'a { - self.pdus(Some(user_id), room_id, None).ignore_err() + self.pdus(Some(user_id), room_id, None) + .ignore_err() } /// Reverse iteration starting at from. @@ -1052,7 +1097,11 @@ impl Service { } } - let room_version_id = self.services.state.get_room_version(&pdu.room_id).await?; + let room_version_id = self + .services + .state + .get_room_version(&pdu.room_id) + .await?; pdu.redact(&room_version_id, reason)?; @@ -1098,15 +1147,18 @@ impl Service { .await .unwrap_or_default(); - let room_mods = power_levels.users.iter().filter_map(|(user_id, level)| { - if level > &power_levels.users_default - && !self.services.globals.user_is_local(user_id) - { - Some(user_id.server_name()) - } else { - None - } - }); + let room_mods = power_levels + .users + .iter() + .filter_map(|(user_id, level)| { + if level > &power_levels.users_default + && !self.services.globals.user_is_local(user_id) + { + Some(user_id.server_name()) + } else { + None + } + }); let canonical_room_alias_server = once( self.services @@ -1158,7 +1210,11 @@ impl Service { match response { | Ok(response) => { for pdu in response.pdus { - if let Err(e) = self.backfill_pdu(backfill_server, pdu).boxed().await { + if let Err(e) = self + .backfill_pdu(backfill_server, pdu) + .boxed() + .await + { debug_warn!("Failed to add backfilled pdu in room {room_id}: {e}"); } } @@ -1176,8 +1232,11 @@ impl Service { #[tracing::instrument(skip(self, pdu), level = "debug")] pub async fn backfill_pdu(&self, origin: &ServerName, pdu: Box) -> Result<()> { - let (room_id, event_id, value) = - self.services.event_handler.parse_incoming_pdu(&pdu).await?; + let (room_id, event_id, value) = self + .services + .event_handler + .parse_incoming_pdu(&pdu) + .await?; // Lock so we cannot backfill the same pdu twice at the same time let mutex_lock = self @@ -1203,11 +1262,20 @@ impl Service { let pdu = self.get_pdu(&event_id).await?; - let shortroomid = self.services.short.get_shortroomid(&room_id).await?; + let shortroomid = self + .services + .short + .get_shortroomid(&room_id) + .await?; let insert_lock = self.mutex_insert.lock(&room_id).await; - let count: i64 = self.services.globals.next_count().unwrap().try_into()?; + let count: i64 = self + .services + .globals + .next_count() + .unwrap() + .try_into()?; let pdu_id: RawPduId = PduId { shortroomid, @@ -1216,14 +1284,17 @@ impl Service { .into(); // Insert pdu - self.db.prepend_backfill_pdu(&pdu_id, &event_id, &value); + self.db + .prepend_backfill_pdu(&pdu_id, &event_id, &value); drop(insert_lock); if pdu.kind == TimelineEventType::RoomMessage { let content: ExtractBody = pdu.get_content()?; if let Some(body) = content.body { - self.services.search.index_pdu(shortroomid, &pdu_id, &body); + self.services + .search + .index_pdu(shortroomid, &pdu_id, &body); } } drop(mutex_lock); diff --git a/src/service/rooms/typing/mod.rs b/src/service/rooms/typing/mod.rs index b1071ce4..250aa0bb 100644 --- a/src/service/rooms/typing/mod.rs +++ b/src/service/rooms/typing/mod.rs @@ -71,13 +71,18 @@ impl Service { .await .insert(room_id.to_owned(), self.services.globals.next_count()?); - if self.typing_update_sender.send(room_id.to_owned()).is_err() { + if self + .typing_update_sender + .send(room_id.to_owned()) + .is_err() + { trace!("receiver found what it was looking for and is no longer interested"); } // update federation if self.services.globals.user_is_local(user_id) { - self.federation_send(room_id, user_id, true).await?; + self.federation_send(room_id, user_id, true) + .await?; } Ok(()) @@ -99,13 +104,18 @@ impl Service { .await .insert(room_id.to_owned(), self.services.globals.next_count()?); - if self.typing_update_sender.send(room_id.to_owned()).is_err() { + if self + .typing_update_sender + .send(room_id.to_owned()) + .is_err() + { trace!("receiver found what it was looking for and is no longer interested"); } // update federation if self.services.globals.user_is_local(user_id) { - self.federation_send(room_id, user_id, false).await?; + self.federation_send(room_id, user_id, false) + .await?; } Ok(()) @@ -152,7 +162,11 @@ impl Service { .await .insert(room_id.to_owned(), self.services.globals.next_count()?); - if self.typing_update_sender.send(room_id.to_owned()).is_err() { + if self + .typing_update_sender + .send(room_id.to_owned()) + .is_err() + { trace!("receiver found what it was looking for and is no longer interested"); } @@ -233,7 +247,10 @@ impl Service { let mut buf = EduBuf::new(); serde_json::to_writer(&mut buf, &edu).expect("Serialized Edu::Typing"); - self.services.sending.send_edu_room(room_id, buf).await?; + self.services + .sending + .send_edu_room(room_id, buf) + .await?; Ok(()) } diff --git a/src/service/rooms/user/mod.rs b/src/service/rooms/user/mod.rs index 9a92e900..61953e4d 100644 --- a/src/service/rooms/user/mod.rs +++ b/src/service/rooms/user/mod.rs @@ -48,8 +48,12 @@ impl crate::Service for Service { #[implement(Service)] pub fn reset_notification_counts(&self, user_id: &UserId, room_id: &RoomId) { let userroom_id = (user_id, room_id); - self.db.userroomid_highlightcount.put(userroom_id, 0_u64); - self.db.userroomid_notificationcount.put(userroom_id, 0_u64); + self.db + .userroomid_highlightcount + .put(userroom_id, 0_u64); + self.db + .userroomid_notificationcount + .put(userroom_id, 0_u64); let roomuser_id = (room_id, user_id); let count = self.services.globals.next_count().unwrap(); @@ -118,7 +122,11 @@ pub async fn get_token_shortstatehash( room_id: &RoomId, token: u64, ) -> Result { - let shortroomid = self.services.short.get_shortroomid(room_id).await?; + let shortroomid = self + .services + .short + .get_shortroomid(room_id) + .await?; let key: &[u64] = &[shortroomid, token]; self.db diff --git a/src/service/sending/appservice.rs b/src/service/sending/appservice.rs index f7b1f75e..9d868473 100644 --- a/src/service/sending/appservice.rs +++ b/src/service/sending/appservice.rs @@ -54,14 +54,22 @@ where .parse() .unwrap(), ); - *http_request.uri_mut() = parts.try_into().expect("our manipulation is always valid"); + *http_request.uri_mut() = parts + .try_into() + .expect("our manipulation is always valid"); let reqwest_request = reqwest::Request::try_from(http_request)?; - let mut response = client.execute(reqwest_request).await.map_err(|e| { - warn!("Could not send request to appservice \"{}\" at {dest}: {e:?}", registration.id); - e - })?; + let mut response = client + .execute(reqwest_request) + .await + .map_err(|e| { + warn!( + "Could not send request to appservice \"{}\" at {dest}: {e:?}", + registration.id + ); + e + })?; // reqwest::Response -> http::Response conversion let status = response.status(); diff --git a/src/service/sending/data.rs b/src/service/sending/data.rs index c1675d40..1f77d964 100644 --- a/src/service/sending/data.rs +++ b/src/service/sending/data.rs @@ -170,7 +170,8 @@ impl Data { } pub(super) fn set_latest_educount(&self, server_name: &ServerName, last_count: u64) { - self.servername_educount.raw_put(server_name, last_count); + self.servername_educount + .raw_put(server_name, last_count); } pub async fn get_latest_educount(&self, server_name: &ServerName) -> u64 { @@ -187,7 +188,9 @@ fn parse_servercurrentevent(key: &[u8], value: &[u8]) -> Result<(Destination, Se Ok::<_, Error>(if key.starts_with(b"+") { let mut parts = key[1..].splitn(2, |&b| b == 0xFF); - let server = parts.next().expect("splitn always returns one element"); + let server = parts + .next() + .expect("splitn always returns one element"); let event = parts .next() .ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?; @@ -207,7 +210,9 @@ fn parse_servercurrentevent(key: &[u8], value: &[u8]) -> Result<(Destination, Se } else if key.starts_with(b"$") { let mut parts = key[1..].splitn(3, |&b| b == 0xFF); - let user = parts.next().expect("splitn always returns one element"); + let user = parts + .next() + .expect("splitn always returns one element"); let user_string = utils::str_from_bytes(user) .map_err(|_| Error::bad_database("Invalid user string in servercurrentevent"))?; let user_id = UserId::parse(user_string) @@ -235,7 +240,9 @@ fn parse_servercurrentevent(key: &[u8], value: &[u8]) -> Result<(Destination, Se } else { let mut parts = key.splitn(2, |&b| b == 0xFF); - let server = parts.next().expect("splitn always returns one element"); + let server = parts + .next() + .expect("splitn always returns one element"); let event = parts .next() .ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?; diff --git a/src/service/sending/dest.rs b/src/service/sending/dest.rs index 52cad6fe..ad9de8c4 100644 --- a/src/service/sending/dest.rs +++ b/src/service/sending/dest.rs @@ -24,7 +24,10 @@ pub(super) fn get_prefix(&self) -> Vec { }, | Self::Appservice(server) => { let sigil = b"+"; - let len = sigil.len().saturating_add(server.len()).saturating_add(1); + let len = sigil + .len() + .saturating_add(server.len()) + .saturating_add(1); let mut p = Vec::with_capacity(len); p.extend_from_slice(sigil); diff --git a/src/service/sending/mod.rs b/src/service/sending/mod.rs index 7f5be21d..91d4a439 100644 --- a/src/service/sending/mod.rs +++ b/src/service/sending/mod.rs @@ -100,7 +100,9 @@ impl crate::Service for Service { pusher: args.depend::("pusher"), federation: args.depend::("federation"), }, - channels: (0..num_senders).map(|_| loole::unbounded()).collect(), + channels: (0..num_senders) + .map(|_| loole::unbounded()) + .collect(), })) } @@ -160,7 +162,10 @@ impl Service { self.dispatch(Msg { dest, event, - queue_id: keys.into_iter().next().expect("request queue key"), + queue_id: keys + .into_iter() + .next() + .expect("request queue key"), }) } @@ -173,7 +178,10 @@ impl Service { self.dispatch(Msg { dest, event, - queue_id: keys.into_iter().next().expect("request queue key"), + queue_id: keys + .into_iter() + .next() + .expect("request queue key"), }) } @@ -201,7 +209,9 @@ impl Service { .await; let _cork = self.db.db.cork(); - let keys = self.db.queue_requests(requests.iter().map(|(o, e)| (e, o))); + let keys = self + .db + .queue_requests(requests.iter().map(|(o, e)| (e, o))); for ((dest, event), queue_id) in requests.into_iter().zip(keys) { self.dispatch(Msg { dest, event, queue_id })?; @@ -219,7 +229,10 @@ impl Service { self.dispatch(Msg { dest, event, - queue_id: keys.into_iter().next().expect("request queue key"), + queue_id: keys + .into_iter() + .next() + .expect("request queue key"), }) } @@ -250,7 +263,9 @@ impl Service { .await; let _cork = self.db.db.cork(); - let keys = self.db.queue_requests(requests.iter().map(|(o, e)| (e, o))); + let keys = self + .db + .queue_requests(requests.iter().map(|(o, e)| (e, o))); for ((dest, event), queue_id) in requests.into_iter().zip(keys) { self.dispatch(Msg { dest, event, queue_id })?; @@ -299,7 +314,10 @@ impl Service { where T: OutgoingRequest + Debug + Send, { - self.services.federation.execute(dest, request).await + self.services + .federation + .execute(dest, request) + .await } /// Like send_federation_request() but with a very large timeout diff --git a/src/service/sending/sender.rs b/src/service/sending/sender.rs index 52f7a07a..f3613a82 100644 --- a/src/service/sending/sender.rs +++ b/src/service/sending/sender.rs @@ -85,7 +85,8 @@ impl Service { .boxed() .await; - self.work_loop(id, &mut futures, &mut statuses).await; + self.work_loop(id, &mut futures, &mut statuses) + .await; if !futures.is_empty() { self.finish_responses(&mut futures).boxed().await; @@ -136,7 +137,9 @@ impl Service { statuses: &mut CurTransactionStatus, ) { match response { - | Ok(dest) => self.handle_response_ok(&dest, futures, statuses).await, + | Ok(dest) => + self.handle_response_ok(&dest, futures, statuses) + .await, | Err((dest, e)) => Self::handle_response_err(dest, statuses, &e), } } @@ -177,7 +180,10 @@ impl Service { if !new_events.is_empty() { self.db.mark_as_active(new_events.iter()); - let new_events_vec = new_events.into_iter().map(|(_, event)| event).collect(); + let new_events_vec = new_events + .into_iter() + .map(|(_, event)| event) + .collect(); futures.push(self.send_events(dest.clone(), new_events_vec)); } else { statuses.remove(dest); @@ -322,7 +328,8 @@ impl Service { let select_edus = select_edus.into_iter().map(SendingEvent::Edu); events.extend(select_edus); - self.db.set_latest_educount(server_name, last_count); + self.db + .set_latest_educount(server_name, last_count); } } @@ -415,7 +422,10 @@ impl Service { events_len: &AtomicUsize, ) -> EduVec { let mut events = EduVec::new(); - let server_rooms = self.services.state_cache.server_rooms(server_name); + let server_rooms = self + .services + .state_cache + .server_rooms(server_name); pin_mut!(server_rooms); let mut device_list_changes = HashSet::::new(); @@ -562,7 +572,10 @@ impl Service { event_ids: vec![event_id.clone()], }; - if read.insert(user_id.to_owned(), receipt_data).is_none() { + if read + .insert(user_id.to_owned(), receipt_data) + .is_none() + { *num = num.saturating_add(1); if *num >= SELECT_RECEIPT_LIMIT { break; @@ -621,7 +634,10 @@ impl Service { let update = PresenceUpdate { user_id: user_id.into(), presence: presence_event.content.presence, - currently_active: presence_event.content.currently_active.unwrap_or(false), + currently_active: presence_event + .content + .currently_active + .unwrap_or(false), status_msg: presence_event.content.status_msg, last_active_ago: presence_event .content @@ -653,11 +669,15 @@ impl Service { fn send_events(&self, dest: Destination, events: Vec) -> SendingFuture<'_> { debug_assert!(!events.is_empty(), "sending empty transaction"); match dest { - | Destination::Federation(server) => - self.send_events_dest_federation(server, events).boxed(), - | Destination::Appservice(id) => self.send_events_dest_appservice(id, events).boxed(), - | Destination::Push(user_id, pushkey) => - self.send_events_dest_push(user_id, pushkey, events).boxed(), + | Destination::Federation(server) => self + .send_events_dest_federation(server, events) + .boxed(), + | Destination::Appservice(id) => self + .send_events_dest_appservice(id, events) + .boxed(), + | Destination::Push(user_id, pushkey) => self + .send_events_dest_push(user_id, pushkey, events) + .boxed(), } } @@ -674,7 +694,12 @@ impl Service { id: String, events: Vec, ) -> SendingResult { - let Some(appservice) = self.services.appservice.get_registration(&id).await else { + let Some(appservice) = self + .services + .appservice + .get_registration(&id) + .await + else { return Err(( Destination::Appservice(id.clone()), err!(Database(warn!(?id, "Missing appservice registration"))), @@ -696,7 +721,12 @@ impl Service { for event in &events { match event { | SendingEvent::Pdu(pdu_id) => { - if let Ok(pdu) = self.services.timeline.get_pdu_from_id(pdu_id).await { + if let Ok(pdu) = self + .services + .timeline + .get_pdu_from_id(pdu_id) + .await + { pdu_jsons.push(pdu.into_room_event()); } }, @@ -752,7 +782,12 @@ impl Service { pushkey: String, events: Vec, ) -> SendingResult { - let Ok(pusher) = self.services.pusher.get_pusher(&user_id, &pushkey).await else { + let Ok(pusher) = self + .services + .pusher + .get_pusher(&user_id, &pushkey) + .await + else { return Err(( Destination::Push(user_id.clone(), pushkey.clone()), err!(Database(error!(?user_id, ?pushkey, "Missing pusher"))), @@ -768,7 +803,12 @@ impl Service { for event in &events { match event { | SendingEvent::Pdu(pdu_id) => { - if let Ok(pdu) = self.services.timeline.get_pdu_from_id(pdu_id).await { + if let Ok(pdu) = self + .services + .timeline + .get_pdu_from_id(pdu_id) + .await + { pdus.push(pdu); } }, @@ -826,7 +866,12 @@ impl Service { | _ => None, }) .stream() - .wide_filter_map(|pdu_id| self.services.timeline.get_pdu_json_from_id(pdu_id).ok()) + .wide_filter_map(|pdu_id| { + self.services + .timeline + .get_pdu_json_from_id(pdu_id) + .ok() + }) .wide_then(|pdu| self.convert_to_outgoing_federation_event(pdu)) .collect() .await; @@ -898,7 +943,12 @@ impl Service { .get("room_id") .and_then(|val| RoomId::parse(val.as_str()?).ok()) { - match self.services.state.get_room_version(room_id).await { + match self + .services + .state + .get_room_version(room_id) + .await + { | Ok(room_version_id) => match room_version_id { | RoomVersionId::V1 | RoomVersionId::V2 => {}, | _ => _ = pdu_json.remove("event_id"), diff --git a/src/service/server_keys/acquire.rs b/src/service/server_keys/acquire.rs index 1ac2b9ff..1a6d374b 100644 --- a/src/service/server_keys/acquire.rs +++ b/src/service/server_keys/acquire.rs @@ -35,7 +35,10 @@ where .filter_map(FlatOk::flat_ok) .flat_map(IntoIterator::into_iter) .for_each(|(server, sigs)| { - batch.entry(server).or_default().extend(sigs.into_keys()); + batch + .entry(server) + .or_default() + .extend(sigs.into_keys()); }); let batch = batch @@ -51,8 +54,16 @@ where S: Iterator + Send + Clone, K: Iterator + Send + Clone, { - let notary_only = self.services.server.config.only_query_trusted_key_servers; - let notary_first_always = self.services.server.config.query_trusted_key_servers_first; + let notary_only = self + .services + .server + .config + .only_query_trusted_key_servers; + let notary_first_always = self + .services + .server + .config + .query_trusted_key_servers_first; let notary_first_on_join = self .services .server @@ -60,7 +71,10 @@ where .query_trusted_key_servers_first_on_join; let requested_servers = batch.clone().count(); - let requested_keys = batch.clone().flat_map(|(_, key_ids)| key_ids).count(); + let requested_keys = batch + .clone() + .flat_map(|(_, key_ids)| key_ids) + .count(); debug!("acquire {requested_keys} keys from {requested_servers}"); @@ -214,7 +228,8 @@ where | Err(e) => error!("Failed to contact notary {notary:?}: {e}"), | Ok(results) => for server_keys in results { - self.acquire_notary_result(&mut missing, server_keys).await; + self.acquire_notary_result(&mut missing, server_keys) + .await; }, } } @@ -236,5 +251,8 @@ async fn acquire_notary_result(&self, missing: &mut Batch, server_keys: ServerSi } fn keys_count(batch: &Batch) -> usize { - batch.iter().flat_map(|(_, key_ids)| key_ids.iter()).count() + batch + .iter() + .flat_map(|(_, key_ids)| key_ids.iter()) + .count() } diff --git a/src/service/server_keys/get.rs b/src/service/server_keys/get.rs index 0fe691d4..dfd1dd9e 100644 --- a/src/service/server_keys/get.rs +++ b/src/service/server_keys/get.rs @@ -66,27 +66,44 @@ pub async fn get_verify_key( origin: &ServerName, key_id: &ServerSigningKeyId, ) -> Result { - let notary_first = self.services.server.config.query_trusted_key_servers_first; - let notary_only = self.services.server.config.only_query_trusted_key_servers; + let notary_first = self + .services + .server + .config + .query_trusted_key_servers_first; + let notary_only = self + .services + .server + .config + .only_query_trusted_key_servers; if let Some(result) = self.verify_keys_for(origin).await.remove(key_id) { return Ok(result); } if notary_first { - if let Ok(result) = self.get_verify_key_from_notaries(origin, key_id).await { + if let Ok(result) = self + .get_verify_key_from_notaries(origin, key_id) + .await + { return Ok(result); } } if !notary_only { - if let Ok(result) = self.get_verify_key_from_origin(origin, key_id).await { + if let Ok(result) = self + .get_verify_key_from_origin(origin, key_id) + .await + { return Ok(result); } } if !notary_first { - if let Ok(result) = self.get_verify_key_from_notaries(origin, key_id).await { + if let Ok(result) = self + .get_verify_key_from_notaries(origin, key_id) + .await + { return Ok(result); } } diff --git a/src/service/server_keys/mod.rs b/src/service/server_keys/mod.rs index 5fae5e05..186940e4 100644 --- a/src/service/server_keys/mod.rs +++ b/src/service/server_keys/mod.rs @@ -107,8 +107,11 @@ async fn add_signing_keys(&self, new_keys: ServerSigningKeys) { }); keys.verify_keys.extend(new_keys.verify_keys); - keys.old_verify_keys.extend(new_keys.old_verify_keys); - self.db.server_signingkeys.raw_put(origin, Json(&keys)); + keys.old_verify_keys + .extend(new_keys.old_verify_keys); + self.db + .server_signingkeys + .raw_put(origin, Json(&keys)); } #[implement(Service)] @@ -177,7 +180,11 @@ pub async fn verify_keys_for(&self, origin: &ServerName) -> VerifyKeys { #[implement(Service)] pub async fn signing_keys_for(&self, origin: &ServerName) -> Result { - self.db.server_signingkeys.get(origin).await.deserialized() + self.db + .server_signingkeys + .get(origin) + .await + .deserialized() } #[implement(Service)] diff --git a/src/service/server_keys/request.rs b/src/service/server_keys/request.rs index 2cb0f52c..11f93d5f 100644 --- a/src/service/server_keys/request.rs +++ b/src/service/server_keys/request.rs @@ -42,7 +42,12 @@ where while let Some(batch) = server_keys .keys() .rev() - .take(self.services.server.config.trusted_server_batch_size) + .take( + self.services + .server + .config + .trusted_server_batch_size, + ) .next_back() .cloned() { diff --git a/src/service/server_keys/verify.rs b/src/service/server_keys/verify.rs index 7f77db0d..4fb60cc7 100644 --- a/src/service/server_keys/verify.rs +++ b/src/service/server_keys/verify.rs @@ -11,7 +11,10 @@ pub async fn validate_and_add_event_id( room_version: &RoomVersionId, ) -> Result<(OwnedEventId, CanonicalJsonObject)> { let (event_id, mut value) = gen_event_id_canonical_json(pdu, room_version)?; - if let Err(e) = self.verify_event(&value, Some(room_version)).await { + if let Err(e) = self + .verify_event(&value, Some(room_version)) + .await + { return Err!(BadServerResponse(debug_error!( "Event {event_id} failed verification: {e:?}" ))); @@ -29,13 +32,19 @@ pub async fn validate_and_add_event_id_no_fetch( room_version: &RoomVersionId, ) -> Result<(OwnedEventId, CanonicalJsonObject)> { let (event_id, mut value) = gen_event_id_canonical_json(pdu, room_version)?; - if !self.required_keys_exist(&value, room_version).await { + if !self + .required_keys_exist(&value, room_version) + .await + { return Err!(BadServerResponse(debug_warn!( "Event {event_id} cannot be verified: missing keys." ))); } - if let Err(e) = self.verify_event(&value, Some(room_version)).await { + if let Err(e) = self + .verify_event(&value, Some(room_version)) + .await + { return Err!(BadServerResponse(debug_error!( "Event {event_id} failed verification: {e:?}" ))); diff --git a/src/service/services.rs b/src/service/services.rs index a2d3fd3f..37229c11 100644 --- a/src/service/services.rs +++ b/src/service/services.rs @@ -115,7 +115,8 @@ impl Services { pub async fn start(self: &Arc) -> Result> { debug_info!("Starting services..."); - self.admin.set_services(Some(Arc::clone(self)).as_ref()); + self.admin + .set_services(Some(Arc::clone(self)).as_ref()); super::migrations::migrations(self).await?; self.manager .lock() @@ -188,7 +189,12 @@ impl Services { fn interrupt(&self) { debug!("Interrupting services..."); - for (name, (service, ..)) in self.service.read().expect("locked for reading").iter() { + for (name, (service, ..)) in self + .service + .read() + .expect("locked for reading") + .iter() + { if let Some(service) = service.upgrade() { trace!("Interrupting {name}"); service.interrupt(); diff --git a/src/service/sync/mod.rs b/src/service/sync/mod.rs index 001ed521..7226319c 100644 --- a/src/service/sync/mod.rs +++ b/src/service/sync/mod.rs @@ -107,15 +107,24 @@ impl Service { } pub fn forget_snake_sync_connection(&self, key: &SnakeConnectionsKey) { - self.snake_connections.lock().expect("locked").remove(key); + self.snake_connections + .lock() + .expect("locked") + .remove(key); } pub fn remembered(&self, key: &DbConnectionsKey) -> bool { - self.connections.lock().expect("locked").contains_key(key) + self.connections + .lock() + .expect("locked") + .contains_key(key) } pub fn forget_sync_request_connection(&self, key: &DbConnectionsKey) { - self.connections.lock().expect("locked").remove(key); + self.connections + .lock() + .expect("locked") + .remove(key); } pub fn update_snake_sync_request_with_cache( diff --git a/src/service/sync/watch.rs b/src/service/sync/watch.rs index 74ce0e5d..66330f6c 100644 --- a/src/service/sync/watch.rs +++ b/src/service/sync/watch.rs @@ -17,11 +17,27 @@ pub async fn watch(&self, user_id: &UserId, device_id: &DeviceId) -> Result { // Return when *any* user changed their key // TODO: only send for user they share a room with - futures.push(self.db.todeviceid_events.watch_prefix(&userdeviceid_prefix)); + futures.push( + self.db + .todeviceid_events + .watch_prefix(&userdeviceid_prefix), + ); - futures.push(self.db.userroomid_joined.watch_prefix(&userid_prefix)); - futures.push(self.db.userroomid_invitestate.watch_prefix(&userid_prefix)); - futures.push(self.db.userroomid_leftstate.watch_prefix(&userid_prefix)); + futures.push( + self.db + .userroomid_joined + .watch_prefix(&userid_prefix), + ); + futures.push( + self.db + .userroomid_invitestate + .watch_prefix(&userid_prefix), + ); + futures.push( + self.db + .userroomid_leftstate + .watch_prefix(&userid_prefix), + ); futures.push( self.db .userroomid_notificationcount @@ -47,7 +63,11 @@ pub async fn watch(&self, user_id: &UserId, device_id: &DeviceId) -> Result { roomid_prefix.push(0xFF); // Key changes - futures.push(self.db.keychangeid_userid.watch_prefix(&roomid_prefix)); + futures.push( + self.db + .keychangeid_userid + .watch_prefix(&roomid_prefix), + ); // Room account data let mut roomuser_prefix = roomid_prefix.clone(); @@ -66,7 +86,10 @@ pub async fn watch(&self, user_id: &UserId, device_id: &DeviceId) -> Result { // EDUs let typing_room_id = room_id.to_owned(); let typing_wait_for_update = async move { - self.services.typing.wait_for_update(&typing_room_id).await; + self.services + .typing + .wait_for_update(&typing_room_id) + .await; }; futures.push(typing_wait_for_update.boxed()); @@ -87,7 +110,11 @@ pub async fn watch(&self, user_id: &UserId, device_id: &DeviceId) -> Result { ); // More key changes (used when user is not joined to any rooms) - futures.push(self.db.keychangeid_userid.watch_prefix(&userid_prefix)); + futures.push( + self.db + .keychangeid_userid + .watch_prefix(&userid_prefix), + ); // One time keys futures.push( diff --git a/src/service/transaction_ids/mod.rs b/src/service/transaction_ids/mod.rs index 57e9e6ae..7ba9e303 100644 --- a/src/service/transaction_ids/mod.rs +++ b/src/service/transaction_ids/mod.rs @@ -34,11 +34,17 @@ pub fn add_txnid( ) { let mut key = user_id.as_bytes().to_vec(); key.push(0xFF); - key.extend_from_slice(device_id.map(DeviceId::as_bytes).unwrap_or_default()); + key.extend_from_slice( + device_id + .map(DeviceId::as_bytes) + .unwrap_or_default(), + ); key.push(0xFF); key.extend_from_slice(txn_id.as_bytes()); - self.db.userdevicetxnid_response.insert(&key, data); + self.db + .userdevicetxnid_response + .insert(&key, data); } // If there's no entry, this is a new transaction diff --git a/src/service/uiaa/mod.rs b/src/service/uiaa/mod.rs index b436880c..e33b3f89 100644 --- a/src/service/uiaa/mod.rs +++ b/src/service/uiaa/mod.rs @@ -60,7 +60,12 @@ impl crate::Service for Service { #[implement(Service)] pub async fn read_tokens(&self) -> Result> { let mut tokens = HashSet::new(); - if let Some(file) = &self.services.config.registration_token_file.as_ref() { + if let Some(file) = &self + .services + .config + .registration_token_file + .as_ref() + { match std::fs::read_to_string(file) { | Ok(text) => { text.split_ascii_whitespace().for_each(|token| { @@ -91,14 +96,20 @@ pub fn create( self.set_uiaa_request( user_id, device_id, - uiaainfo.session.as_ref().expect("session should be set"), + uiaainfo + .session + .as_ref() + .expect("session should be set"), json_body, ); self.update_uiaa_session( user_id, device_id, - uiaainfo.session.as_ref().expect("session should be set"), + uiaainfo + .session + .as_ref() + .expect("session should be set"), Some(uiaainfo), ); } @@ -112,7 +123,8 @@ pub async fn try_auth( uiaainfo: &UiaaInfo, ) -> Result<(bool, UiaaInfo)> { let mut uiaainfo = if let Some(session) = auth.session() { - self.get_uiaa_session(user_id, device_id, session).await? + self.get_uiaa_session(user_id, device_id, session) + .await? } else { uiaainfo.clone() }; @@ -180,7 +192,9 @@ pub async fn try_auth( | AuthData::RegistrationToken(t) => { let tokens = self.read_tokens().await?; if tokens.contains(t.token.trim()) { - uiaainfo.completed.push(AuthType::RegistrationToken); + uiaainfo + .completed + .push(AuthType::RegistrationToken); } else { uiaainfo.auth_error = Some(ruma::api::client::error::StandardErrorBody { kind: ErrorKind::forbidden(), @@ -211,7 +225,10 @@ pub async fn try_auth( self.update_uiaa_session( user_id, device_id, - uiaainfo.session.as_ref().expect("session is always set"), + uiaainfo + .session + .as_ref() + .expect("session is always set"), Some(&uiaainfo), ); @@ -222,7 +239,10 @@ pub async fn try_auth( self.update_uiaa_session( user_id, device_id, - uiaainfo.session.as_ref().expect("session is always set"), + uiaainfo + .session + .as_ref() + .expect("session is always set"), None, ); @@ -253,7 +273,9 @@ pub fn get_uiaa_request( ) -> Option { let key = ( user_id.to_owned(), - device_id.unwrap_or_else(|| EMPTY.into()).to_owned(), + device_id + .unwrap_or_else(|| EMPTY.into()) + .to_owned(), session.to_owned(), ); diff --git a/src/service/users/mod.rs b/src/service/users/mod.rs index 68278b2a..82ed9990 100644 --- a/src/service/users/mod.rs +++ b/src/service/users/mod.rs @@ -175,7 +175,11 @@ impl Service { /// Find out which user an access token belongs to. pub async fn find_from_token(&self, token: &str) -> Result<(OwnedUserId, OwnedDeviceId)> { - self.db.token_userdeviceid.get(token).await.deserialized() + self.db + .token_userdeviceid + .get(token) + .await + .deserialized() } /// Returns an iterator over all users on this homeserver (offered for @@ -204,7 +208,11 @@ impl Service { /// Returns the password hash for the given user. pub async fn password_hash(&self, user_id: &UserId) -> Result { - self.db.userid_password.get(user_id).await.deserialized() + self.db + .userid_password + .get(user_id) + .await + .deserialized() } /// Hash and set the user's password to the Argon2 hash @@ -225,14 +233,20 @@ impl Service { /// Returns the displayname of a user on this homeserver. pub async fn displayname(&self, user_id: &UserId) -> Result { - self.db.userid_displayname.get(user_id).await.deserialized() + self.db + .userid_displayname + .get(user_id) + .await + .deserialized() } /// Sets a new displayname or removes it if displayname is None. You still /// need to nofify all rooms of this change. pub fn set_displayname(&self, user_id: &UserId, displayname: Option) { if let Some(displayname) = displayname { - self.db.userid_displayname.insert(user_id, displayname); + self.db + .userid_displayname + .insert(user_id, displayname); } else { self.db.userid_displayname.remove(user_id); } @@ -240,14 +254,20 @@ impl Service { /// Get the `avatar_url` of a user. pub async fn avatar_url(&self, user_id: &UserId) -> Result { - self.db.userid_avatarurl.get(user_id).await.deserialized() + self.db + .userid_avatarurl + .get(user_id) + .await + .deserialized() } /// Sets a new avatar_url or removes it if avatar_url is None. pub fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option) { match avatar_url { | Some(avatar_url) => { - self.db.userid_avatarurl.insert(user_id, &avatar_url); + self.db + .userid_avatarurl + .insert(user_id, &avatar_url); }, | _ => { self.db.userid_avatarurl.remove(user_id); @@ -257,7 +277,11 @@ impl Service { /// Get the blurhash of a user. pub async fn blurhash(&self, user_id: &UserId) -> Result { - self.db.userid_blurhash.get(user_id).await.deserialized() + self.db + .userid_blurhash + .get(user_id) + .await + .deserialized() } /// Sets a new avatar_url or removes it if avatar_url is None. @@ -302,7 +326,12 @@ impl Service { let userdeviceid = (user_id, device_id); // Remove tokens - if let Ok(old_token) = self.db.userdeviceid_token.qry(&userdeviceid).await { + if let Ok(old_token) = self + .db + .userdeviceid_token + .qry(&userdeviceid) + .await + { self.db.userdeviceid_token.del(userdeviceid); self.db.token_userdeviceid.remove(&old_token); } @@ -339,7 +368,11 @@ impl Service { pub async fn get_token(&self, user_id: &UserId, device_id: &DeviceId) -> Result { let key = (user_id, device_id); - self.db.userdeviceid_token.qry(&key).await.deserialized() + self.db + .userdeviceid_token + .qry(&key) + .await + .deserialized() } /// Replaces the access token of one device. @@ -350,7 +383,13 @@ impl Service { token: &str, ) -> Result<()> { let key = (user_id, device_id); - if self.db.userdeviceid_metadata.qry(&key).await.is_err() { + if self + .db + .userdeviceid_metadata + .qry(&key) + .await + .is_err() + { return Err!(Database(error!( ?user_id, ?device_id, @@ -382,7 +421,13 @@ impl Service { // Only existing devices should be able to call this, but we shouldn't assert // either... let key = (user_id, device_id); - if self.db.userdeviceid_metadata.qry(&key).await.is_err() { + if self + .db + .userdeviceid_metadata + .qry(&key) + .await + .is_err() + { return Err!(Database(error!( ?user_id, ?device_id, @@ -407,7 +452,9 @@ impl Service { .raw_put(key, Json(one_time_key_value)); let count = self.services.globals.next_count().unwrap(); - self.db.userid_lastonetimekeyupdate.raw_put(user_id, count); + self.db + .userid_lastonetimekeyupdate + .raw_put(user_id, count); Ok(()) } @@ -428,7 +475,9 @@ impl Service { key_algorithm: &OneTimeKeyAlgorithm, ) -> Result<(OwnedKeyId, Raw)> { let count = self.services.globals.next_count()?.to_be_bytes(); - self.db.userid_lastonetimekeyupdate.insert(user_id, count); + self.db + .userid_lastonetimekeyupdate + .insert(user_id, count); let mut prefix = user_id.as_bytes().to_vec(); prefix.push(0xFF); @@ -542,10 +591,12 @@ impl Service { .keys .into_values(); - let self_signing_key_id = self_signing_key_ids.next().ok_or(Error::BadRequest( - ErrorKind::InvalidParam, - "Self signing key contained no key.", - ))?; + let self_signing_key_id = self_signing_key_ids + .next() + .ok_or(Error::BadRequest( + ErrorKind::InvalidParam, + "Self signing key contained no key.", + ))?; if self_signing_key_ids.next().is_some() { return Err(Error::BadRequest( @@ -625,7 +676,9 @@ impl Service { .insert(signature.0, signature.1.into()); let key = (target_id, key_id); - self.db.keyid_key.put(key, Json(cross_signing_key)); + self.db + .keyid_key + .put(key, Json(cross_signing_key)); self.mark_device_key_update(target_id).await; @@ -697,7 +750,11 @@ impl Service { device_id: &DeviceId, ) -> Result> { let key_id = (user_id, device_id); - self.db.keyid_key.qry(&key_id).await.deserialized() + self.db + .keyid_key + .qry(&key_id) + .await + .deserialized() } pub async fn get_key( @@ -710,7 +767,12 @@ impl Service { where F: Fn(&UserId) -> bool + Send + Sync, { - let key: serde_json::Value = self.db.keyid_key.get(key_id).await.deserialized()?; + let key: serde_json::Value = self + .db + .keyid_key + .get(key_id) + .await + .deserialized()?; let cleaned = clean_signatures(key, sender_user, user_id, allowed_signatures)?; let raw_value = serde_json::value::to_raw_value(&cleaned)?; @@ -741,7 +803,11 @@ impl Service { where F: Fn(&UserId) -> bool + Send + Sync, { - let key_id = self.db.userid_selfsigningkeyid.get(user_id).await?; + let key_id = self + .db + .userid_selfsigningkeyid + .get(user_id) + .await?; self.get_key(&key_id, sender_user, user_id, allowed_signatures) .await @@ -834,7 +900,9 @@ impl Service { increment(&self.db.userid_devicelistversion, user_id.as_bytes()); let key = (user_id, device_id); - self.db.userdeviceid_metadata.put(key, Json(device)); + self.db + .userdeviceid_metadata + .put(key, Json(device)); Ok(()) } @@ -888,7 +956,11 @@ impl Service { filter_id: &str, ) -> Result { let key = (user_id, filter_id); - self.db.userfilterid_filter.qry(&key).await.deserialized() + self.db + .userfilterid_filter + .qry(&key) + .await + .deserialized() } /// Creates an OpenID token, which can be used to prove that a user has @@ -911,7 +983,12 @@ impl Service { /// Find out which user an OpenID access token belongs to. pub async fn find_from_openid_token(&self, token: &str) -> Result { - let Ok(value) = self.db.openidtoken_expiresatuserid.get(token).await else { + let Ok(value) = self + .db + .openidtoken_expiresatuserid + .get(token) + .await + else { return Err!(Request(Unauthorized("OpenID token is unrecognised"))); }; @@ -923,7 +1000,9 @@ impl Service { if expires_at < utils::millis_since_unix_epoch() { debug_warn!("OpenID token is expired, removing"); - self.db.openidtoken_expiresatuserid.remove(token.as_bytes()); + self.db + .openidtoken_expiresatuserid + .remove(token.as_bytes()); return Err!(Request(Unauthorized("OpenID token is expired"))); } @@ -944,7 +1023,9 @@ impl Service { let expires_at = Sat(utils::millis_since_unix_epoch()) + Sat(expires_in); let value = (expires_at.0, user_id); - self.db.logintoken_expiresatuserid.raw_put(token, value); + self.db + .logintoken_expiresatuserid + .raw_put(token, value); expires_in } @@ -952,7 +1033,12 @@ impl Service { /// Find out which user a login token belongs to. /// Removes the token to prevent double-use attacks. pub async fn find_from_login_token(&self, token: &str) -> Result { - let Ok(value) = self.db.logintoken_expiresatuserid.get(token).await else { + let Ok(value) = self + .db + .logintoken_expiresatuserid + .get(token) + .await + else { return Err!(Request(Forbidden("Login token is unrecognised"))); }; let (expires_at, user_id): (u64, OwnedUserId) = value.deserialized()?; @@ -1010,7 +1096,9 @@ impl Service { let key = (user_id, profile_key); if let Some(value) = profile_key_value { - self.db.useridprofilekey_value.put(key, Json(value)); + self.db + .useridprofilekey_value + .put(key, Json(value)); } else { self.db.useridprofilekey_value.del(key); } @@ -1038,7 +1126,9 @@ impl Service { let key = (user_id, "us.cloke.msc4175.tz"); if let Some(timezone) = timezone { - self.db.useridprofilekey_value.put_raw(key, &timezone); + self.db + .useridprofilekey_value + .put_raw(key, &timezone); } else { self.db.useridprofilekey_value.del(key); }