cargo fmt

src/database/key_value/rooms/alias.rs

@@ -1,13 +1,9 @@
-use ruma::{RoomId, RoomAliasId, api::client::error::ErrorKind};
+use ruma::{api::client::error::ErrorKind, RoomAliasId, RoomId};
 
-use crate::{service, database::KeyValueDatabase, utils, Error, services, Result};
+use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
 impl service::rooms::alias::Data for KeyValueDatabase {
-    fn set_alias(
-        &self,
-        alias: &RoomAliasId,
-        room_id: &RoomId
-    ) -> Result<()> {
+    fn set_alias(&self, alias: &RoomAliasId, room_id: &RoomId) -> Result<()> {
         self.alias_roomid
             .insert(alias.alias().as_bytes(), room_id.as_bytes())?;
         let mut aliasid = room_id.as_bytes().to_vec();
@@ -17,10 +13,7 @@ impl service::rooms::alias::Data for KeyValueDatabase {
         Ok(())
     }
 
-    fn remove_alias(
-        &self,
-        alias: &RoomAliasId,
-    ) -> Result<()> {
+    fn remove_alias(&self, alias: &RoomAliasId) -> Result<()> {
         if let Some(room_id) = self.alias_roomid.get(alias.alias().as_bytes())? {
             let mut prefix = room_id.to_vec();
             prefix.push(0xff);
@@ -38,10 +31,7 @@ impl service::rooms::alias::Data for KeyValueDatabase {
         Ok(())
     }
 
-    fn resolve_local_alias(
-        &self,
-        alias: &RoomAliasId
-    ) -> Result<Option<Box<RoomId>>> {
+    fn resolve_local_alias(&self, alias: &RoomAliasId) -> Result<Option<Box<RoomId>>> {
         self.alias_roomid
             .get(alias.alias().as_bytes())?
             .map(|bytes| {

src/database/key_value/rooms/auth_chain.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashSet, mem::size_of, sync::Arc};
 
-use crate::{service, database::KeyValueDatabase, Result, utils};
+use crate::{database::KeyValueDatabase, service, utils, Result};
 
 impl service::rooms::auth_chain::Data for KeyValueDatabase {
     fn get_cached_eventid_authchain(&self, key: &[u64]) -> Result<Option<Arc<HashSet<u64>>>> {
@@ -12,14 +12,13 @@ impl service::rooms::auth_chain::Data for KeyValueDatabase {
         // We only save auth chains for single events in the db
         if key.len() == 1 {
             // Check DB cache
-            let chain = self.shorteventid_authchain
+            let chain = self
+                .shorteventid_authchain
                 .get(&key[0].to_be_bytes())?
                 .map(|chain| {
                     chain
                         .chunks_exact(size_of::<u64>())
-                        .map(|chunk| {
-                            utils::u64_from_bytes(chunk).expect("byte length is correct")
-                        })
+                        .map(|chunk| utils::u64_from_bytes(chunk).expect("byte length is correct"))
                         .collect()
                 });
 
@@ -37,7 +36,6 @@ impl service::rooms::auth_chain::Data for KeyValueDatabase {
         }
 
         Ok(None)
-
     }
 
     fn cache_auth_chain(&self, key: Vec<u64>, auth_chain: Arc<HashSet<u64>>) -> Result<()> {
@@ -53,7 +51,10 @@ impl service::rooms::auth_chain::Data for KeyValueDatabase {
         }
 
         // Cache in RAM
-        self.auth_chain_cache.lock().unwrap().insert(key, auth_chain);
+        self.auth_chain_cache
+            .lock()
+            .unwrap()
+            .insert(key, auth_chain);
 
         Ok(())
     }

src/database/key_value/rooms/directory.rs

@@ -1,6 +1,6 @@
 use ruma::RoomId;
 
-use crate::{service, database::KeyValueDatabase, utils, Error, Result};
+use crate::{database::KeyValueDatabase, service, utils, Error, Result};
 
 impl service::rooms::directory::Data for KeyValueDatabase {
     fn set_public(&self, room_id: &RoomId) -> Result<()> {

src/database/key_value/rooms/edus/mod.rs

@@ -1,7 +1,7 @@
 mod presence;
-mod typing;
 mod read_receipt;
+mod typing;
 
-use crate::{service, database::KeyValueDatabase};
+use crate::{database::KeyValueDatabase, service};
 
 impl service::rooms::edus::Data for KeyValueDatabase {}

src/database/key_value/rooms/edus/presence.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
-use ruma::{UserId, RoomId, events::presence::PresenceEvent, presence::PresenceState, UInt};
+use ruma::{events::presence::PresenceEvent, presence::PresenceState, RoomId, UInt, UserId};
 
-use crate::{service, database::KeyValueDatabase, utils, Error, services, Result};
+use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
 impl service::rooms::edus::presence::Data for KeyValueDatabase {
     fn update_presence(

src/database/key_value/rooms/edus/read_receipt.rs

@@ -1,8 +1,10 @@
 use std::mem;
 
-use ruma::{UserId, RoomId, events::receipt::ReceiptEvent, serde::Raw, signatures::CanonicalJsonObject};
+use ruma::{
+    events::receipt::ReceiptEvent, serde::Raw, signatures::CanonicalJsonObject, RoomId, UserId,
+};
 
-use crate::{database::KeyValueDatabase, service, utils, Error, services, Result};
+use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
 impl service::rooms::edus::read_receipt::Data for KeyValueDatabase {
     fn readreceipt_update(
@@ -50,13 +52,15 @@ impl service::rooms::edus::read_receipt::Data for KeyValueDatabase {
         &'a self,
         room_id: &RoomId,
         since: u64,
-    ) -> Box<dyn Iterator<
-        Item=Result<(
-            Box<UserId>,
-            u64,
-            Raw<ruma::events::AnySyncEphemeralRoomEvent>,
-        )>,
-    >> {
+    ) -> Box<
+        dyn Iterator<
+            Item = Result<(
+                Box<UserId>,
+                u64,
+                Raw<ruma::events::AnySyncEphemeralRoomEvent>,
+            )>,
+        >,
+    > {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
         let prefix2 = prefix.clone();
@@ -64,42 +68,44 @@ impl service::rooms::edus::read_receipt::Data for KeyValueDatabase {
         let mut first_possible_edu = prefix.clone();
         first_possible_edu.extend_from_slice(&(since + 1).to_be_bytes()); // +1 so we don't send the event at since
 
-        Box::new(self.readreceiptid_readreceipt
-            .iter_from(&first_possible_edu, false)
-            .take_while(move |(k, _)| k.starts_with(&prefix2))
-            .map(move |(k, v)| {
-                let count =
-                    utils::u64_from_bytes(&k[prefix.len()..prefix.len() + mem::size_of::<u64>()])
-                        .map_err(|_| Error::bad_database("Invalid readreceiptid count in db."))?;
-                let user_id = UserId::parse(
-                    utils::string_from_bytes(&k[prefix.len() + mem::size_of::<u64>() + 1..])
-                        .map_err(|_| {
-                            Error::bad_database("Invalid readreceiptid userid bytes in db.")
-                        })?,
-                )
+        Box::new(
+            self.readreceiptid_readreceipt
+                .iter_from(&first_possible_edu, false)
+                .take_while(move |(k, _)| k.starts_with(&prefix2))
+                .map(move |(k, v)| {
+                    let count = utils::u64_from_bytes(
+                        &k[prefix.len()..prefix.len() + mem::size_of::<u64>()],
+                    )
+                    .map_err(|_| Error::bad_database("Invalid readreceiptid count in db."))?;
+                    let user_id = UserId::parse(
+                        utils::string_from_bytes(&k[prefix.len() + mem::size_of::<u64>() + 1..])
+                            .map_err(|_| {
+                                Error::bad_database("Invalid readreceiptid userid bytes in db.")
+                            })?,
+                    )
                     .map_err(|_| Error::bad_database("Invalid readreceiptid userid in db."))?;
 
-                let mut json = serde_json::from_slice::<CanonicalJsonObject>(&v).map_err(|_| {
-                    Error::bad_database("Read receipt in roomlatestid_roomlatest is invalid json.")
-                })?;
-                json.remove("room_id");
+                    let mut json =
+                        serde_json::from_slice::<CanonicalJsonObject>(&v).map_err(|_| {
+                            Error::bad_database(
+                                "Read receipt in roomlatestid_roomlatest is invalid json.",
+                            )
+                        })?;
+                    json.remove("room_id");
 
-                Ok((
-                    user_id,
-                    count,
-                    Raw::from_json(
-                        serde_json::value::to_raw_value(&json).expect("json is valid raw value"),
-                    ),
-                ))
-            }))
+                    Ok((
+                        user_id,
+                        count,
+                        Raw::from_json(
+                            serde_json::value::to_raw_value(&json)
+                                .expect("json is valid raw value"),
+                        ),
+                    ))
+                }),
+        )
     }
 
-    fn private_read_set(
-        &self,
-        room_id: &RoomId,
-        user_id: &UserId,
-        count: u64,
-    ) -> Result<()> {
+    fn private_read_set(&self, room_id: &RoomId, user_id: &UserId, count: u64) -> Result<()> {
         let mut key = room_id.as_bytes().to_vec();
         key.push(0xff);
         key.extend_from_slice(user_id.as_bytes());

src/database/key_value/rooms/edus/typing.rs

@@ -1,16 +1,11 @@
 use std::collections::HashSet;
 
-use ruma::{UserId, RoomId};
+use ruma::{RoomId, UserId};
 
-use crate::{database::KeyValueDatabase, service, utils, Error, services, Result};
+use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
 impl service::rooms::edus::typing::Data for KeyValueDatabase {
-    fn typing_add(
-        &self,
-        user_id: &UserId,
-        room_id: &RoomId,
-        timeout: u64,
-    ) -> Result<()> {
+    fn typing_add(&self, user_id: &UserId, room_id: &RoomId, timeout: u64) -> Result<()> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -30,11 +25,7 @@ impl service::rooms::edus::typing::Data for KeyValueDatabase {
         Ok(())
     }
 
-    fn typing_remove(
-        &self,
-        user_id: &UserId,
-        room_id: &RoomId,
-    ) -> Result<()> {
+    fn typing_remove(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -53,17 +44,16 @@ impl service::rooms::edus::typing::Data for KeyValueDatabase {
         }
 
         if found_outdated {
-            self.roomid_lasttypingupdate
-                .insert(room_id.as_bytes(), &services().globals.next_count()?.to_be_bytes())?;
+            self.roomid_lasttypingupdate.insert(
+                room_id.as_bytes(),
+                &services().globals.next_count()?.to_be_bytes(),
+            )?;
         }
 
         Ok(())
     }
 
-    fn last_typing_update(
-        &self,
-        room_id: &RoomId,
-    ) -> Result<u64> {
+    fn last_typing_update(&self, room_id: &RoomId) -> Result<u64> {
         Ok(self
             .roomid_lasttypingupdate
             .get(room_id.as_bytes())?
@@ -76,10 +66,7 @@ impl service::rooms::edus::typing::Data for KeyValueDatabase {
             .unwrap_or(0))
     }
 
-    fn typings_all(
-        &self,
-        room_id: &RoomId,
-    ) -> Result<HashSet<Box<UserId>>> {
+    fn typings_all(&self, room_id: &RoomId) -> Result<HashSet<Box<UserId>>> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -89,7 +76,7 @@ impl service::rooms::edus::typing::Data for KeyValueDatabase {
             let user_id = UserId::parse(utils::string_from_bytes(&user_id).map_err(|_| {
                 Error::bad_database("User ID in typingid_userid is invalid unicode.")
             })?)
-                .map_err(|_| Error::bad_database("User ID in typingid_userid is invalid."))?;
+            .map_err(|_| Error::bad_database("User ID in typingid_userid is invalid."))?;
 
             user_ids.insert(user_id);
         }

src/database/key_value/rooms/lazy_load.rs

@@ -1,6 +1,6 @@
-use ruma::{UserId, DeviceId, RoomId};
+use ruma::{DeviceId, RoomId, UserId};
 
-use crate::{service, database::KeyValueDatabase, Result};
+use crate::{database::KeyValueDatabase, service, Result};
 
 impl service::rooms::lazy_loading::Data for KeyValueDatabase {
     fn lazy_load_was_sent_before(

src/database/key_value/rooms/metadata.rs

@@ -1,6 +1,6 @@
 use ruma::RoomId;
 
-use crate::{service, database::KeyValueDatabase, Result, services};
+use crate::{database::KeyValueDatabase, service, services, Result};
 
 impl service::rooms::metadata::Data for KeyValueDatabase {
     fn exists(&self, room_id: &RoomId) -> Result<bool> {

src/database/key_value/rooms/outlier.rs

@@ -1,6 +1,6 @@
-use ruma::{EventId, signatures::CanonicalJsonObject};
+use ruma::{signatures::CanonicalJsonObject, EventId};
 
-use crate::{service, database::KeyValueDatabase, PduEvent, Error, Result};
+use crate::{database::KeyValueDatabase, service, Error, PduEvent, Result};
 
 impl service::rooms::outlier::Data for KeyValueDatabase {
     fn get_outlier_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {

src/database/key_value/rooms/pdu_metadata.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use ruma::{RoomId, EventId};
+use ruma::{EventId, RoomId};
 
-use crate::{service, database::KeyValueDatabase, Result};
+use crate::{database::KeyValueDatabase, service, Result};
 
 impl service::rooms::pdu_metadata::Data for KeyValueDatabase {
     fn mark_as_referenced(&self, room_id: &RoomId, event_ids: &[Arc<EventId>]) -> Result<()> {

src/database/key_value/rooms/search.rs

@@ -2,7 +2,7 @@ use std::mem::size_of;
 
 use ruma::RoomId;
 
-use crate::{service, database::KeyValueDatabase, utils, Result, services};
+use crate::{database::KeyValueDatabase, service, services, utils, Result};
 
 impl service::rooms::search::Data for KeyValueDatabase {
     fn index_pdu<'a>(&self, shortroomid: u64, pdu_id: &[u8], message_body: String) -> Result<()> {
@@ -27,7 +27,9 @@ impl service::rooms::search::Data for KeyValueDatabase {
         room_id: &RoomId,
         search_string: &str,
     ) -> Result<Option<(Box<dyn Iterator<Item = Vec<u8>>>, Vec<String>)>> {
-        let prefix = services().rooms.short
+        let prefix = services()
+            .rooms
+            .short
             .get_shortroomid(room_id)?
             .expect("room exists")
             .to_be_bytes()
@@ -63,10 +65,10 @@ impl service::rooms::search::Data for KeyValueDatabase {
         };
 
         let mapped = common_elements.map(move |id| {
-                    let mut pduid = prefix_clone.clone();
-                    pduid.extend_from_slice(&id);
-                    pduid
-                });
+            let mut pduid = prefix_clone.clone();
+            pduid.extend_from_slice(&id);
+            pduid
+        });
 
         Ok(Some((Box::new(mapped), words)))
     }

src/database/key_value/rooms/short.rs

@@ -1,14 +1,11 @@
 use std::sync::Arc;
 
-use ruma::{EventId, events::StateEventType, RoomId};
+use ruma::{events::StateEventType, EventId, RoomId};
 
-use crate::{Result, database::KeyValueDatabase, service, utils, Error, services};
+use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
 impl service::rooms::short::Data for KeyValueDatabase {
-    fn get_or_create_shorteventid(
-        &self,
-        event_id: &EventId,
-    ) -> Result<u64> {
+    fn get_or_create_shorteventid(&self, event_id: &EventId) -> Result<u64> {
         if let Some(short) = self.eventidshort_cache.lock().unwrap().get_mut(event_id) {
             return Ok(*short);
         }
@@ -180,10 +177,7 @@ impl service::rooms::short::Data for KeyValueDatabase {
     }
 
     /// Returns (shortstatehash, already_existed)
-    fn get_or_create_shortstatehash(
-        &self,
-        state_hash: &[u8],
-    ) -> Result<(u64, bool)> {
+    fn get_or_create_shortstatehash(&self, state_hash: &[u8]) -> Result<(u64, bool)> {
         Ok(match self.statehash_shortstatehash.get(state_hash)? {
             Some(shortstatehash) => (
                 utils::u64_from_bytes(&shortstatehash)
@@ -209,10 +203,7 @@ impl service::rooms::short::Data for KeyValueDatabase {
             .transpose()
     }
 
-    fn get_or_create_shortroomid(
-        &self,
-        room_id: &RoomId,
-    ) -> Result<u64> {
+    fn get_or_create_shortroomid(&self, room_id: &RoomId) -> Result<u64> {
         Ok(match self.roomid_shortroomid.get(room_id.as_bytes())? {
             Some(short) => utils::u64_from_bytes(&short)
                 .map_err(|_| Error::bad_database("Invalid shortroomid in db."))?,

src/database/key_value/rooms/state.rs

@@ -1,10 +1,10 @@
-use ruma::{RoomId, EventId};
-use tokio::sync::MutexGuard;
-use std::sync::Arc;
+use ruma::{EventId, RoomId};
 use std::collections::HashSet;
 use std::fmt::Debug;
+use std::sync::Arc;
+use tokio::sync::MutexGuard;
 
-use crate::{service, database::KeyValueDatabase, utils, Error, Result};
+use crate::{database::KeyValueDatabase, service, utils, Error, Result};
 
 impl service::rooms::state::Data for KeyValueDatabase {
     fn get_room_shortstatehash(&self, room_id: &RoomId) -> Result<Option<u64>> {
@@ -17,9 +17,12 @@ impl service::rooms::state::Data for KeyValueDatabase {
             })
     }
 
-    fn set_room_state(&self, room_id: &RoomId, new_shortstatehash: u64,
+    fn set_room_state(
+        &self,
+        room_id: &RoomId,
+        new_shortstatehash: u64,
         _mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room state mutex
-        ) -> Result<()> {
+    ) -> Result<()> {
         self.roomid_shortstatehash
             .insert(room_id.as_bytes(), &new_shortstatehash.to_be_bytes())?;
         Ok(())

src/database/key_value/rooms/state_accessor.rs

@@ -1,13 +1,18 @@
-use std::{collections::{BTreeMap, HashMap}, sync::Arc};
+use std::{
+    collections::{BTreeMap, HashMap},
+    sync::Arc,
+};
 
-use crate::{database::KeyValueDatabase, service, PduEvent, Error, utils, Result, services};
+use crate::{database::KeyValueDatabase, service, services, utils, Error, PduEvent, Result};
 use async_trait::async_trait;
-use ruma::{EventId, events::StateEventType, RoomId};
+use ruma::{events::StateEventType, EventId, RoomId};
 
 #[async_trait]
 impl service::rooms::state_accessor::Data for KeyValueDatabase {
     async fn state_full_ids(&self, shortstatehash: u64) -> Result<BTreeMap<u64, Arc<EventId>>> {
-        let full_state = services().rooms.state_compressor
+        let full_state = services()
+            .rooms
+            .state_compressor
             .load_shortstatehash_info(shortstatehash)?
             .pop()
             .expect("there is always one layer")
@@ -15,7 +20,10 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
         let mut result = BTreeMap::new();
         let mut i = 0;
         for compressed in full_state.into_iter() {
-            let parsed = services().rooms.state_compressor.parse_compressed_state_event(compressed)?;
+            let parsed = services()
+                .rooms
+                .state_compressor
+                .parse_compressed_state_event(compressed)?;
             result.insert(parsed.0, parsed.1);
 
             i += 1;
@@ -30,7 +38,9 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
         &self,
         shortstatehash: u64,
     ) -> Result<HashMap<(StateEventType, String), Arc<PduEvent>>> {
-        let full_state = services().rooms.state_compressor
+        let full_state = services()
+            .rooms
+            .state_compressor
             .load_shortstatehash_info(shortstatehash)?
             .pop()
             .expect("there is always one layer")
@@ -39,7 +49,10 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
         let mut result = HashMap::new();
         let mut i = 0;
         for compressed in full_state {
-            let (_, eventid) = services().rooms.state_compressor.parse_compressed_state_event(compressed)?;
+            let (_, eventid) = services()
+                .rooms
+                .state_compressor
+                .parse_compressed_state_event(compressed)?;
             if let Some(pdu) = services().rooms.timeline.get_pdu(&eventid)? {
                 result.insert(
                     (
@@ -69,11 +82,17 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
         event_type: &StateEventType,
         state_key: &str,
     ) -> Result<Option<Arc<EventId>>> {
-        let shortstatekey = match services().rooms.short.get_shortstatekey(event_type, state_key)? {
+        let shortstatekey = match services()
+            .rooms
+            .short
+            .get_shortstatekey(event_type, state_key)?
+        {
             Some(s) => s,
             None => return Ok(None),
         };
-        let full_state = services().rooms.state_compressor
+        let full_state = services()
+            .rooms
+            .state_compressor
             .load_shortstatehash_info(shortstatehash)?
             .pop()
             .expect("there is always one layer")
@@ -82,7 +101,10 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
             .into_iter()
             .find(|bytes| bytes.starts_with(&shortstatekey.to_be_bytes()))
             .and_then(|compressed| {
-                services().rooms.state_compressor.parse_compressed_state_event(compressed)
+                services()
+                    .rooms
+                    .state_compressor
+                    .parse_compressed_state_event(compressed)
                     .ok()
                     .map(|(_, id)| id)
             }))
@@ -96,7 +118,9 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
         state_key: &str,
     ) -> Result<Option<Arc<PduEvent>>> {
         self.state_get_id(shortstatehash, event_type, state_key)?
-            .map_or(Ok(None), |event_id| services().rooms.timeline.get_pdu(&event_id))
+            .map_or(Ok(None), |event_id| {
+                services().rooms.timeline.get_pdu(&event_id)
+            })
     }
 
     /// Returns the state hash for this pdu.
@@ -122,7 +146,9 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
         &self,
         room_id: &RoomId,
     ) -> Result<HashMap<(StateEventType, String), Arc<PduEvent>>> {
-        if let Some(current_shortstatehash) = services().rooms.state.get_room_shortstatehash(room_id)? {
+        if let Some(current_shortstatehash) =
+            services().rooms.state.get_room_shortstatehash(room_id)?
+        {
             self.state_full(current_shortstatehash).await
         } else {
             Ok(HashMap::new())
@@ -136,7 +162,9 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
         event_type: &StateEventType,
         state_key: &str,
     ) -> Result<Option<Arc<EventId>>> {
-        if let Some(current_shortstatehash) = services().rooms.state.get_room_shortstatehash(room_id)? {
+        if let Some(current_shortstatehash) =
+            services().rooms.state.get_room_shortstatehash(room_id)?
+        {
             self.state_get_id(current_shortstatehash, event_type, state_key)
         } else {
             Ok(None)
@@ -150,7 +178,9 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
         event_type: &StateEventType,
         state_key: &str,
     ) -> Result<Option<Arc<PduEvent>>> {
-        if let Some(current_shortstatehash) = services().rooms.state.get_room_shortstatehash(room_id)? {
+        if let Some(current_shortstatehash) =
+            services().rooms.state.get_room_shortstatehash(room_id)?
+        {
             self.state_get(current_shortstatehash, event_type, state_key)
         } else {
             Ok(None)

src/database/key_value/rooms/state_cache.rs

@@ -1,9 +1,13 @@
 use std::{collections::HashSet, sync::Arc};
 
 use regex::Regex;
-use ruma::{UserId, RoomId, events::{AnyStrippedStateEvent, AnySyncStateEvent}, serde::Raw, ServerName};
+use ruma::{
+    events::{AnyStrippedStateEvent, AnySyncStateEvent},
+    serde::Raw,
+    RoomId, ServerName, UserId,
+};
 
-use crate::{service, database::KeyValueDatabase, services, Result, Error, utils};
+use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
 impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn mark_as_once_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
@@ -31,8 +35,13 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
 
         Ok(())
     }
-    
-    fn mark_as_invited(&self, user_id: &UserId, room_id: &RoomId, last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>) -> Result<()> {
+
+    fn mark_as_invited(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+        last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>,
+    ) -> Result<()> {
         let mut roomuser_id = room_id.as_bytes().to_vec();
         roomuser_id.push(0xff);
         roomuser_id.extend_from_slice(user_id.as_bytes());
@@ -46,8 +55,10 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
             &serde_json::to_vec(&last_state.unwrap_or_default())
                 .expect("state to bytes always works"),
         )?;
-        self.roomuserid_invitecount
-            .insert(&roomuser_id, &services().globals.next_count()?.to_be_bytes())?;
+        self.roomuserid_invitecount.insert(
+            &roomuser_id,
+            &services().globals.next_count()?.to_be_bytes(),
+        )?;
         self.userroomid_joined.remove(&userroom_id)?;
         self.roomuserid_joined.remove(&roomuser_id)?;
         self.userroomid_leftstate.remove(&userroom_id)?;
@@ -69,8 +80,10 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
             &userroom_id,
             &serde_json::to_vec(&Vec::<Raw<AnySyncStateEvent>>::new()).unwrap(),
         )?; // TODO
-        self.roomuserid_leftcount
-            .insert(&roomuser_id, &services().globals.next_count()?.to_be_bytes())?;
+        self.roomuserid_leftcount.insert(
+            &roomuser_id,
+            &services().globals.next_count()?.to_be_bytes(),
+        )?;
         self.userroomid_joined.remove(&userroom_id)?;
         self.roomuserid_joined.remove(&roomuser_id)?;
         self.userroomid_invitestate.remove(&userroom_id)?;
@@ -324,21 +337,25 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
-        Box::new(self.roomuseroncejoinedids
-            .scan_prefix(prefix)
-            .map(|(key, _)| {
-                UserId::parse(
-                    utils::string_from_bytes(
-                        key.rsplit(|&b| b == 0xff)
-                            .next()
-                            .expect("rsplit always returns an element"),
+        Box::new(
+            self.roomuseroncejoinedids
+                .scan_prefix(prefix)
+                .map(|(key, _)| {
+                    UserId::parse(
+                        utils::string_from_bytes(
+                            key.rsplit(|&b| b == 0xff)
+                                .next()
+                                .expect("rsplit always returns an element"),
+                        )
+                        .map_err(|_| {
+                            Error::bad_database(
+                                "User ID in room_useroncejoined is invalid unicode.",
+                            )
+                        })?,
                     )
-                    .map_err(|_| {
-                        Error::bad_database("User ID in room_useroncejoined is invalid unicode.")
-                    })?,
-                )
-                .map_err(|_| Error::bad_database("User ID in room_useroncejoined is invalid."))
-            }))
+                    .map_err(|_| Error::bad_database("User ID in room_useroncejoined is invalid."))
+                }),
+        )
     }
 
     /// Returns an iterator over all invited members of a room.
@@ -350,21 +367,23 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
-        Box::new(self.roomuserid_invitecount
-            .scan_prefix(prefix)
-            .map(|(key, _)| {
-                UserId::parse(
-                    utils::string_from_bytes(
-                        key.rsplit(|&b| b == 0xff)
-                            .next()
-                            .expect("rsplit always returns an element"),
+        Box::new(
+            self.roomuserid_invitecount
+                .scan_prefix(prefix)
+                .map(|(key, _)| {
+                    UserId::parse(
+                        utils::string_from_bytes(
+                            key.rsplit(|&b| b == 0xff)
+                                .next()
+                                .expect("rsplit always returns an element"),
+                        )
+                        .map_err(|_| {
+                            Error::bad_database("User ID in roomuserid_invited is invalid unicode.")
+                        })?,
                     )
-                    .map_err(|_| {
-                        Error::bad_database("User ID in roomuserid_invited is invalid unicode.")
-                    })?,
-                )
-                .map_err(|_| Error::bad_database("User ID in roomuserid_invited is invalid."))
-            }))
+                    .map_err(|_| Error::bad_database("User ID in roomuserid_invited is invalid."))
+                }),
+        )
     }
 
     #[tracing::instrument(skip(self))]
@@ -403,21 +422,23 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         &'a self,
         user_id: &UserId,
     ) -> Box<dyn Iterator<Item = Result<Box<RoomId>>> + 'a> {
-        Box::new(self.userroomid_joined
-            .scan_prefix(user_id.as_bytes().to_vec())
-            .map(|(key, _)| {
-                RoomId::parse(
-                    utils::string_from_bytes(
-                        key.rsplit(|&b| b == 0xff)
-                            .next()
-                            .expect("rsplit always returns an element"),
+        Box::new(
+            self.userroomid_joined
+                .scan_prefix(user_id.as_bytes().to_vec())
+                .map(|(key, _)| {
+                    RoomId::parse(
+                        utils::string_from_bytes(
+                            key.rsplit(|&b| b == 0xff)
+                                .next()
+                                .expect("rsplit always returns an element"),
+                        )
+                        .map_err(|_| {
+                            Error::bad_database("Room ID in userroomid_joined is invalid unicode.")
+                        })?,
                     )
-                    .map_err(|_| {
-                        Error::bad_database("Room ID in userroomid_joined is invalid unicode.")
-                    })?,
-                )
-                .map_err(|_| Error::bad_database("Room ID in userroomid_joined is invalid."))
-            }))
+                    .map_err(|_| Error::bad_database("Room ID in userroomid_joined is invalid."))
+                }),
+        )
     }
 
     /// Returns an iterator over all rooms a user was invited to.
@@ -429,26 +450,31 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
 
-        Box::new(self.userroomid_invitestate
-            .scan_prefix(prefix)
-            .map(|(key, state)| {
-                let room_id = RoomId::parse(
-                    utils::string_from_bytes(
-                        key.rsplit(|&b| b == 0xff)
-                            .next()
-                            .expect("rsplit always returns an element"),
+        Box::new(
+            self.userroomid_invitestate
+                .scan_prefix(prefix)
+                .map(|(key, state)| {
+                    let room_id = RoomId::parse(
+                        utils::string_from_bytes(
+                            key.rsplit(|&b| b == 0xff)
+                                .next()
+                                .expect("rsplit always returns an element"),
+                        )
+                        .map_err(|_| {
+                            Error::bad_database("Room ID in userroomid_invited is invalid unicode.")
+                        })?,
                     )
                     .map_err(|_| {
-                        Error::bad_database("Room ID in userroomid_invited is invalid unicode.")
-                    })?,
-                )
-                .map_err(|_| Error::bad_database("Room ID in userroomid_invited is invalid."))?;
+                        Error::bad_database("Room ID in userroomid_invited is invalid.")
+                    })?;
 
-                let state = serde_json::from_slice(&state)
-                    .map_err(|_| Error::bad_database("Invalid state in userroomid_invitestate."))?;
+                    let state = serde_json::from_slice(&state).map_err(|_| {
+                        Error::bad_database("Invalid state in userroomid_invitestate.")
+                    })?;
 
-                Ok((room_id, state))
-            }))
+                    Ok((room_id, state))
+                }),
+        )
     }
 
     #[tracing::instrument(skip(self))]
@@ -502,26 +528,31 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
 
-        Box::new(self.userroomid_leftstate
-            .scan_prefix(prefix)
-            .map(|(key, state)| {
-                let room_id = RoomId::parse(
-                    utils::string_from_bytes(
-                        key.rsplit(|&b| b == 0xff)
-                            .next()
-                            .expect("rsplit always returns an element"),
+        Box::new(
+            self.userroomid_leftstate
+                .scan_prefix(prefix)
+                .map(|(key, state)| {
+                    let room_id = RoomId::parse(
+                        utils::string_from_bytes(
+                            key.rsplit(|&b| b == 0xff)
+                                .next()
+                                .expect("rsplit always returns an element"),
+                        )
+                        .map_err(|_| {
+                            Error::bad_database("Room ID in userroomid_invited is invalid unicode.")
+                        })?,
                     )
                     .map_err(|_| {
-                        Error::bad_database("Room ID in userroomid_invited is invalid unicode.")
-                    })?,
-                )
-                .map_err(|_| Error::bad_database("Room ID in userroomid_invited is invalid."))?;
+                        Error::bad_database("Room ID in userroomid_invited is invalid.")
+                    })?;
 
-                let state = serde_json::from_slice(&state)
-                    .map_err(|_| Error::bad_database("Invalid state in userroomid_leftstate."))?;
+                    let state = serde_json::from_slice(&state).map_err(|_| {
+                        Error::bad_database("Invalid state in userroomid_leftstate.")
+                    })?;
 
-                Ok((room_id, state))
-            }))
+                    Ok((room_id, state))
+                }),
+        )
     }
 
     #[tracing::instrument(skip(self))]

src/database/key_value/rooms/state_compressor.rs

@@ -1,6 +1,10 @@
 use std::{collections::HashSet, mem::size_of};
 
-use crate::{service::{self, rooms::state_compressor::data::StateDiff}, database::KeyValueDatabase, Error, utils, Result};
+use crate::{
+    database::KeyValueDatabase,
+    service::{self, rooms::state_compressor::data::StateDiff},
+    utils, Error, Result,
+};
 
 impl service::rooms::state_compressor::Data for KeyValueDatabase {
     fn get_statediff(&self, shortstatehash: u64) -> Result<StateDiff> {
@@ -10,11 +14,7 @@ impl service::rooms::state_compressor::Data for KeyValueDatabase {
             .ok_or_else(|| Error::bad_database("State hash does not exist"))?;
         let parent =
             utils::u64_from_bytes(&value[0..size_of::<u64>()]).expect("bytes have right length");
-        let parent = if parent != 0 {
-            Some(parent)
-        } else {
-            None
-        };
+        let parent = if parent != 0 { Some(parent) } else { None };
 
         let mut add_mode = true;
         let mut added = HashSet::new();
@@ -35,7 +35,11 @@ impl service::rooms::state_compressor::Data for KeyValueDatabase {
             i += 2 * size_of::<u64>();
         }
 
-        Ok(StateDiff { parent, added, removed })
+        Ok(StateDiff {
+            parent,
+            added,
+            removed,
+        })
     }
 
     fn save_statediff(&self, shortstatehash: u64, diff: StateDiff) -> Result<()> {

src/database/key_value/rooms/timeline.rs

@@ -1,13 +1,17 @@
 use std::{collections::hash_map, mem::size_of, sync::Arc};
 
-use ruma::{UserId, RoomId, api::client::error::ErrorKind, EventId, signatures::CanonicalJsonObject};
+use ruma::{
+    api::client::error::ErrorKind, signatures::CanonicalJsonObject, EventId, RoomId, UserId,
+};
 use tracing::error;
 
-use crate::{service, database::KeyValueDatabase, utils, Error, PduEvent, Result, services};
+use crate::{database::KeyValueDatabase, service, services, utils, Error, PduEvent, Result};
 
 impl service::rooms::timeline::Data for KeyValueDatabase {
     fn first_pdu_in_room(&self, room_id: &RoomId) -> Result<Option<Arc<PduEvent>>> {
-        let prefix = services().rooms.short
+        let prefix = services()
+            .rooms
+            .short
             .get_shortroomid(room_id)?
             .expect("room exists")
             .to_be_bytes()
@@ -82,10 +86,7 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
     }
 
     /// Returns the json of a pdu.
-    fn get_non_outlier_pdu_json(
-        &self,
-        event_id: &EventId,
-    ) -> Result<Option<CanonicalJsonObject>> {
+    fn get_non_outlier_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
         self.eventid_pduid
             .get(event_id.as_bytes())?
             .map(|pduid| {
@@ -187,10 +188,17 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
             .map_err(|_| Error::bad_database("PDU has invalid count bytes."))
     }
 
-    fn append_pdu(&self, pdu_id: &[u8], pdu: &PduEvent, json: &CanonicalJsonObject, count: u64) -> Result<()> {
+    fn append_pdu(
+        &self,
+        pdu_id: &[u8],
+        pdu: &PduEvent,
+        json: &CanonicalJsonObject,
+        count: u64,
+    ) -> Result<()> {
         self.pduid_pdu.insert(
             pdu_id,
-            &serde_json::to_vec(json).expect("CanonicalJsonObject is always a valid"))?;
+            &serde_json::to_vec(json).expect("CanonicalJsonObject is always a valid"),
+        )?;
 
         self.lasttimelinecount_cache
             .lock()
@@ -209,7 +217,8 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
         if self.pduid_pdu.get(pdu_id)?.is_some() {
             self.pduid_pdu.insert(
                 pdu_id,
-                &serde_json::to_vec(pdu).expect("CanonicalJsonObject is always a valid"))?;
+                &serde_json::to_vec(pdu).expect("CanonicalJsonObject is always a valid"),
+            )?;
             Ok(())
         } else {
             Err(Error::BadRequest(
@@ -227,7 +236,9 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
         room_id: &RoomId,
         since: u64,
     ) -> Result<Box<dyn Iterator<Item = Result<(Vec<u8>, PduEvent)>>>> {
-        let prefix = services().rooms.short
+        let prefix = services()
+            .rooms
+            .short
             .get_shortroomid(room_id)?
             .expect("room exists")
             .to_be_bytes()
@@ -239,18 +250,19 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 
         let user_id = user_id.to_owned();
 
-        Ok(Box::new(self
-            .pduid_pdu
-            .iter_from(&first_pdu_id, false)
-            .take_while(move |(k, _)| k.starts_with(&prefix))
-            .map(move |(pdu_id, v)| {
-                let mut pdu = serde_json::from_slice::<PduEvent>(&v)
-                    .map_err(|_| Error::bad_database("PDU in db is invalid."))?;
-                if pdu.sender != user_id {
-                    pdu.remove_transaction_id()?;
-                }
-                Ok((pdu_id, pdu))
-            })))
+        Ok(Box::new(
+            self.pduid_pdu
+                .iter_from(&first_pdu_id, false)
+                .take_while(move |(k, _)| k.starts_with(&prefix))
+                .map(move |(pdu_id, v)| {
+                    let mut pdu = serde_json::from_slice::<PduEvent>(&v)
+                        .map_err(|_| Error::bad_database("PDU in db is invalid."))?;
+                    if pdu.sender != user_id {
+                        pdu.remove_transaction_id()?;
+                    }
+                    Ok((pdu_id, pdu))
+                }),
+        ))
     }
 
     /// Returns an iterator over all events and their tokens in a room that happened before the
@@ -262,7 +274,9 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
         until: u64,
     ) -> Result<Box<dyn Iterator<Item = Result<(Vec<u8>, PduEvent)>>>> {
         // Create the first part of the full pdu id
-        let prefix = services().rooms.short
+        let prefix = services()
+            .rooms
+            .short
             .get_shortroomid(room_id)?
             .expect("room exists")
             .to_be_bytes()
@@ -275,18 +289,19 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 
         let user_id = user_id.to_owned();
 
-        Ok(Box::new(self
-            .pduid_pdu
-            .iter_from(current, true)
-            .take_while(move |(k, _)| k.starts_with(&prefix))
-            .map(move |(pdu_id, v)| {
-                let mut pdu = serde_json::from_slice::<PduEvent>(&v)
-                    .map_err(|_| Error::bad_database("PDU in db is invalid."))?;
-                if pdu.sender != user_id {
-                    pdu.remove_transaction_id()?;
-                }
-                Ok((pdu_id, pdu))
-            })))
+        Ok(Box::new(
+            self.pduid_pdu
+                .iter_from(current, true)
+                .take_while(move |(k, _)| k.starts_with(&prefix))
+                .map(move |(pdu_id, v)| {
+                    let mut pdu = serde_json::from_slice::<PduEvent>(&v)
+                        .map_err(|_| Error::bad_database("PDU in db is invalid."))?;
+                    if pdu.sender != user_id {
+                        pdu.remove_transaction_id()?;
+                    }
+                    Ok((pdu_id, pdu))
+                }),
+        ))
     }
 
     fn pdus_after<'a>(
@@ -296,7 +311,9 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
         from: u64,
     ) -> Result<Box<dyn Iterator<Item = Result<(Vec<u8>, PduEvent)>>>> {
         // Create the first part of the full pdu id
-        let prefix = services().rooms.short
+        let prefix = services()
+            .rooms
+            .short
             .get_shortroomid(room_id)?
             .expect("room exists")
             .to_be_bytes()
@@ -309,21 +326,27 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 
         let user_id = user_id.to_owned();
 
-        Ok(Box::new(self
-            .pduid_pdu
-            .iter_from(current, false)
-            .take_while(move |(k, _)| k.starts_with(&prefix))
-            .map(move |(pdu_id, v)| {
-                let mut pdu = serde_json::from_slice::<PduEvent>(&v)
-                    .map_err(|_| Error::bad_database("PDU in db is invalid."))?;
-                if pdu.sender != user_id {
-                    pdu.remove_transaction_id()?;
-                }
-                Ok((pdu_id, pdu))
-            })))
+        Ok(Box::new(
+            self.pduid_pdu
+                .iter_from(current, false)
+                .take_while(move |(k, _)| k.starts_with(&prefix))
+                .map(move |(pdu_id, v)| {
+                    let mut pdu = serde_json::from_slice::<PduEvent>(&v)
+                        .map_err(|_| Error::bad_database("PDU in db is invalid."))?;
+                    if pdu.sender != user_id {
+                        pdu.remove_transaction_id()?;
+                    }
+                    Ok((pdu_id, pdu))
+                }),
+        ))
     }
 
-    fn increment_notification_counts(&self, room_id: &RoomId, notifies: Vec<Box<UserId>>, highlights: Vec<Box<UserId>>) -> Result<()> {
+    fn increment_notification_counts(
+        &self,
+        room_id: &RoomId,
+        notifies: Vec<Box<UserId>>,
+        highlights: Vec<Box<UserId>>,
+    ) -> Result<()> {
         let notifies_batch = Vec::new();
         let highlights_batch = Vec::new();
         for user in notifies {

src/database/key_value/rooms/user.rs

@@ -1,6 +1,6 @@
-use ruma::{UserId, RoomId};
+use ruma::{RoomId, UserId};
 
-use crate::{service, database::KeyValueDatabase, utils, Error, Result, services};
+use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
 impl service::rooms::user::Data for KeyValueDatabase {
     fn reset_notification_counts(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
@@ -50,7 +50,11 @@ impl service::rooms::user::Data for KeyValueDatabase {
         token: u64,
         shortstatehash: u64,
     ) -> Result<()> {
-        let shortroomid = services().rooms.short.get_shortroomid(room_id)?.expect("room exists");
+        let shortroomid = services()
+            .rooms
+            .short
+            .get_shortroomid(room_id)?
+            .expect("room exists");
 
         let mut key = shortroomid.to_be_bytes().to_vec();
         key.extend_from_slice(&token.to_be_bytes());
@@ -60,7 +64,11 @@ impl service::rooms::user::Data for KeyValueDatabase {
     }
 
     fn get_token_shortstatehash(&self, room_id: &RoomId, token: u64) -> Result<Option<u64>> {
-        let shortroomid = services().rooms.short.get_shortroomid(room_id)?.expect("room exists");
+        let shortroomid = services()
+            .rooms
+            .short
+            .get_shortroomid(room_id)?
+            .expect("room exists");
 
         let mut key = shortroomid.to_be_bytes().to_vec();
         key.extend_from_slice(&token.to_be_bytes());
@@ -102,13 +110,15 @@ impl service::rooms::user::Data for KeyValueDatabase {
         });
 
         // We use the default compare function because keys are sorted correctly (not reversed)
-        Ok(Box::new(Box::new(utils::common_elements(iterators, Ord::cmp)
-            .expect("users is not empty")
-            .map(|bytes| {
-                RoomId::parse(utils::string_from_bytes(&*bytes).map_err(|_| {
-                    Error::bad_database("Invalid RoomId bytes in userroomid_joined")
-                })?)
-                .map_err(|_| Error::bad_database("Invalid RoomId in userroomid_joined."))
-            }))))
+        Ok(Box::new(Box::new(
+            utils::common_elements(iterators, Ord::cmp)
+                .expect("users is not empty")
+                .map(|bytes| {
+                    RoomId::parse(utils::string_from_bytes(&*bytes).map_err(|_| {
+                        Error::bad_database("Invalid RoomId bytes in userroomid_joined")
+                    })?)
+                    .map_err(|_| Error::bad_database("Invalid RoomId in userroomid_joined."))
+                }),
+        )))
     }
 }