use chain_width 60

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

src/database/key_value/rooms/alias.rs

@@ -4,7 +4,8 @@ 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<()> {
-		self.alias_roomid.insert(alias.alias().as_bytes(), room_id.as_bytes())?;
+		self.alias_roomid
+			.insert(alias.alias().as_bytes(), room_id.as_bytes())?;
 		let mut aliasid = room_id.as_bytes().to_vec();
 		aliasid.push(0xFF);
 		aliasid.extend_from_slice(&services().globals.next_count()?.to_be_bytes());
@@ -55,16 +56,20 @@ impl service::rooms::alias::Data for KeyValueDatabase {
 	}
 
 	fn all_local_aliases<'a>(&'a self) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, String)>> + 'a> {
-		Box::new(self.alias_roomid.iter().map(|(room_alias_bytes, room_id_bytes)| {
-			let room_alias_localpart = utils::string_from_bytes(&room_alias_bytes)
-				.map_err(|_| Error::bad_database("Invalid alias bytes in aliasid_alias."))?;
+		Box::new(
+			self.alias_roomid
+				.iter()
+				.map(|(room_alias_bytes, room_id_bytes)| {
+					let room_alias_localpart = utils::string_from_bytes(&room_alias_bytes)
+						.map_err(|_| Error::bad_database("Invalid alias bytes in aliasid_alias."))?;
 
-			let room_id = utils::string_from_bytes(&room_id_bytes)
-				.map_err(|_| Error::bad_database("Invalid room_id bytes in aliasid_alias."))?
-				.try_into()
-				.map_err(|_| Error::bad_database("Invalid room_id in aliasid_alias."))?;
+					let room_id = utils::string_from_bytes(&room_id_bytes)
+						.map_err(|_| Error::bad_database("Invalid room_id bytes in aliasid_alias."))?
+						.try_into()
+						.map_err(|_| Error::bad_database("Invalid room_id in aliasid_alias."))?;
 
-			Ok((room_id, room_alias_localpart))
-		}))
+					Ok((room_id, room_alias_localpart))
+				}),
+		)
 	}
 }

src/database/key_value/rooms/auth_chain.rs

@@ -12,18 +12,24 @@ 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.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"))
-					.collect()
-			});
+			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"))
+						.collect()
+				});
 
 			if let Some(chain) = chain {
 				let chain = Arc::new(chain);
 
 				// Cache in RAM
-				self.auth_chain_cache.lock().unwrap().insert(vec![key[0]], Arc::clone(&chain));
+				self.auth_chain_cache
+					.lock()
+					.unwrap()
+					.insert(vec![key[0]], Arc::clone(&chain));
 
 				return Ok(Some(chain));
 			}
@@ -37,12 +43,18 @@ impl service::rooms::auth_chain::Data for KeyValueDatabase {
 		if key.len() == 1 {
 			self.shorteventid_authchain.insert(
 				&key[0].to_be_bytes(),
-				&auth_chain.iter().flat_map(|s| s.to_be_bytes().to_vec()).collect::<Vec<u8>>(),
+				&auth_chain
+					.iter()
+					.flat_map(|s| s.to_be_bytes().to_vec())
+					.collect::<Vec<u8>>(),
 			)?;
 		}
 
 		// 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/edus/presence.rs

@@ -65,7 +65,8 @@ impl service::rooms::edus::presence::Data for KeyValueDatabase {
 				None => Presence::new(new_state.clone(), new_state == PresenceState::Online, now, count, None),
 			};
 
-			self.roomuserid_presence.insert(&key, &new_presence.to_json_bytes()?)?;
+			self.roomuserid_presence
+				.insert(&key, &new_presence.to_json_bytes()?)?;
 		}
 
 		let timeout = match new_state {
@@ -73,10 +74,12 @@ impl service::rooms::edus::presence::Data for KeyValueDatabase {
 			_ => services().globals.config.presence_offline_timeout_s,
 		};
 
-		self.presence_timer_sender.send((user_id.to_owned(), Duration::from_secs(timeout))).map_err(|e| {
-			error!("Failed to add presence timer: {}", e);
-			Error::bad_database("Failed to add presence timer")
-		})
+		self.presence_timer_sender
+			.send((user_id.to_owned(), Duration::from_secs(timeout)))
+			.map_err(|e| {
+				error!("Failed to add presence timer: {}", e);
+				Error::bad_database("Failed to add presence timer")
+			})
 	}
 
 	fn set_presence(
@@ -104,12 +107,15 @@ impl service::rooms::edus::presence::Data for KeyValueDatabase {
 			_ => services().globals.config.presence_offline_timeout_s,
 		};
 
-		self.presence_timer_sender.send((user_id.to_owned(), Duration::from_secs(timeout))).map_err(|e| {
-			error!("Failed to add presence timer: {}", e);
-			Error::bad_database("Failed to add presence timer")
-		})?;
+		self.presence_timer_sender
+			.send((user_id.to_owned(), Duration::from_secs(timeout)))
+			.map_err(|e| {
+				error!("Failed to add presence timer: {}", e);
+				Error::bad_database("Failed to add presence timer")
+			})?;
 
-		self.roomuserid_presence.insert(&key, &presence.to_json_bytes()?)?;
+		self.roomuserid_presence
+			.insert(&key, &presence.to_json_bytes()?)?;
 
 		Ok(())
 	}

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

@@ -18,7 +18,10 @@ impl service::rooms::edus::read_receipt::Data for KeyValueDatabase {
 			.iter_from(&last_possible_key, true)
 			.take_while(|(key, _)| key.starts_with(&prefix))
 			.find(|(key, _)| {
-				key.rsplit(|&b| b == 0xFF).next().expect("rsplit always returns an element") == user_id.as_bytes()
+				key.rsplit(|&b| b == 0xFF)
+					.next()
+					.expect("rsplit always returns an element")
+					== user_id.as_bytes()
 			}) {
 			// This is the old room_latest
 			self.readreceiptid_readreceipt.remove(&old)?;
@@ -78,9 +81,11 @@ impl service::rooms::edus::read_receipt::Data for KeyValueDatabase {
 		key.push(0xFF);
 		key.extend_from_slice(user_id.as_bytes());
 
-		self.roomuserid_privateread.insert(&key, &count.to_be_bytes())?;
+		self.roomuserid_privateread
+			.insert(&key, &count.to_be_bytes())?;
 
-		self.roomuserid_lastprivatereadupdate.insert(&key, &services().globals.next_count()?.to_be_bytes())
+		self.roomuserid_lastprivatereadupdate
+			.insert(&key, &services().globals.next_count()?.to_be_bytes())
 	}
 
 	fn private_read_get(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
@@ -88,11 +93,13 @@ impl service::rooms::edus::read_receipt::Data for KeyValueDatabase {
 		key.push(0xFF);
 		key.extend_from_slice(user_id.as_bytes());
 
-		self.roomuserid_privateread.get(&key)?.map_or(Ok(None), |v| {
-			Ok(Some(
-				utils::u64_from_bytes(&v).map_err(|_| Error::bad_database("Invalid private read marker bytes"))?,
-			))
-		})
+		self.roomuserid_privateread
+			.get(&key)?
+			.map_or(Ok(None), |v| {
+				Ok(Some(
+					utils::u64_from_bytes(&v).map_err(|_| Error::bad_database("Invalid private read marker bytes"))?,
+				))
+			})
 	}
 
 	fn last_privateread_update(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {

src/database/key_value/rooms/metadata.rs

@@ -11,7 +11,12 @@ impl service::rooms::metadata::Data for KeyValueDatabase {
 		};
 
 		// Look for PDUs in that room.
-		Ok(self.pduid_pdu.iter_from(&prefix, false).next().filter(|(k, _)| k.starts_with(&prefix)).is_some())
+		Ok(self
+			.pduid_pdu
+			.iter_from(&prefix, false)
+			.next()
+			.filter(|(k, _)| k.starts_with(&prefix))
+			.is_some())
 	}
 
 	fn iter_ids<'a>(&'a self) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a> {

src/database/key_value/rooms/outlier.rs

@@ -4,15 +4,19 @@ 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>> {
-		self.eventid_outlierpdu.get(event_id.as_bytes())?.map_or(Ok(None), |pdu| {
-			serde_json::from_slice(&pdu).map_err(|_| Error::bad_database("Invalid PDU in db."))
-		})
+		self.eventid_outlierpdu
+			.get(event_id.as_bytes())?
+			.map_or(Ok(None), |pdu| {
+				serde_json::from_slice(&pdu).map_err(|_| Error::bad_database("Invalid PDU in db."))
+			})
 	}
 
 	fn get_outlier_pdu(&self, event_id: &EventId) -> Result<Option<PduEvent>> {
-		self.eventid_outlierpdu.get(event_id.as_bytes())?.map_or(Ok(None), |pdu| {
-			serde_json::from_slice(&pdu).map_err(|_| Error::bad_database("Invalid PDU in db."))
-		})
+		self.eventid_outlierpdu
+			.get(event_id.as_bytes())?
+			.map_or(Ok(None), |pdu| {
+				serde_json::from_slice(&pdu).map_err(|_| Error::bad_database("Invalid PDU in db."))
+			})
 	}
 
 	fn add_pdu_outlier(&self, event_id: &EventId, pdu: &CanonicalJsonObject) -> Result<()> {

src/database/key_value/rooms/pdu_metadata.rs

@@ -32,8 +32,10 @@ impl service::rooms::pdu_metadata::Data for KeyValueDatabase {
 		current.extend_from_slice(&count_raw.to_be_bytes());
 
 		Ok(Box::new(
-			self.tofrom_relation.iter_from(&current, true).take_while(move |(k, _)| k.starts_with(&prefix)).map(
-				move |(tofrom, _data)| {
+			self.tofrom_relation
+				.iter_from(&current, true)
+				.take_while(move |(k, _)| k.starts_with(&prefix))
+				.map(move |(tofrom, _data)| {
 					let from = utils::u64_from_bytes(&tofrom[(mem::size_of::<u64>())..])
 						.map_err(|_| Error::bad_database("Invalid count in tofrom_relation."))?;
 
@@ -49,8 +51,7 @@ impl service::rooms::pdu_metadata::Data for KeyValueDatabase {
 						pdu.remove_transaction_id()?;
 					}
 					Ok((PduCount::Normal(from), pdu))
-				},
-			),
+				}),
 		))
 	}
 
@@ -75,6 +76,8 @@ impl service::rooms::pdu_metadata::Data for KeyValueDatabase {
 	}
 
 	fn is_event_soft_failed(&self, event_id: &EventId) -> Result<bool> {
-		self.softfailedeventids.get(event_id.as_bytes()).map(|o| o.is_some())
+		self.softfailedeventids
+			.get(event_id.as_bytes())
+			.map(|o| o.is_some())
 	}
 }

src/database/key_value/rooms/search.rs

@@ -23,7 +23,13 @@ impl service::rooms::search::Data for KeyValueDatabase {
 	}
 
 	fn search_pdus<'a>(&'a self, room_id: &RoomId, search_string: &str) -> SearchPdusResult<'a> {
-		let prefix = services().rooms.short.get_shortroomid(room_id)?.expect("room exists").to_be_bytes().to_vec();
+		let prefix = services()
+			.rooms
+			.short
+			.get_shortroomid(room_id)?
+			.expect("room exists")
+			.to_be_bytes()
+			.to_vec();
 
 		let words: Vec<_> = search_string
 			.split_terminator(|c: char| !c.is_alphanumeric())

src/database/key_value/rooms/short.rs

@@ -17,20 +17,28 @@ impl service::rooms::short::Data for KeyValueDatabase {
 			},
 			None => {
 				let shorteventid = services().globals.next_count()?;
-				self.eventid_shorteventid.insert(event_id.as_bytes(), &shorteventid.to_be_bytes())?;
-				self.shorteventid_eventid.insert(&shorteventid.to_be_bytes(), event_id.as_bytes())?;
+				self.eventid_shorteventid
+					.insert(event_id.as_bytes(), &shorteventid.to_be_bytes())?;
+				self.shorteventid_eventid
+					.insert(&shorteventid.to_be_bytes(), event_id.as_bytes())?;
 				shorteventid
 			},
 		};
 
-		self.eventidshort_cache.lock().unwrap().insert(event_id.to_owned(), short);
+		self.eventidshort_cache
+			.lock()
+			.unwrap()
+			.insert(event_id.to_owned(), short);
 
 		Ok(short)
 	}
 
 	fn get_shortstatekey(&self, event_type: &StateEventType, state_key: &str) -> Result<Option<u64>> {
-		if let Some(short) =
-			self.statekeyshort_cache.lock().unwrap().get_mut(&(event_type.clone(), state_key.to_owned()))
+		if let Some(short) = self
+			.statekeyshort_cache
+			.lock()
+			.unwrap()
+			.get_mut(&(event_type.clone(), state_key.to_owned()))
 		{
 			return Ok(Some(*short));
 		}
@@ -48,15 +56,21 @@ impl service::rooms::short::Data for KeyValueDatabase {
 			.transpose()?;
 
 		if let Some(s) = short {
-			self.statekeyshort_cache.lock().unwrap().insert((event_type.clone(), state_key.to_owned()), s);
+			self.statekeyshort_cache
+				.lock()
+				.unwrap()
+				.insert((event_type.clone(), state_key.to_owned()), s);
 		}
 
 		Ok(short)
 	}
 
 	fn get_or_create_shortstatekey(&self, event_type: &StateEventType, state_key: &str) -> Result<u64> {
-		if let Some(short) =
-			self.statekeyshort_cache.lock().unwrap().get_mut(&(event_type.clone(), state_key.to_owned()))
+		if let Some(short) = self
+			.statekeyshort_cache
+			.lock()
+			.unwrap()
+			.get_mut(&(event_type.clone(), state_key.to_owned()))
 		{
 			return Ok(*short);
 		}
@@ -70,19 +84,29 @@ impl service::rooms::short::Data for KeyValueDatabase {
 				.map_err(|_| Error::bad_database("Invalid shortstatekey in db."))?,
 			None => {
 				let shortstatekey = services().globals.next_count()?;
-				self.statekey_shortstatekey.insert(&statekey_vec, &shortstatekey.to_be_bytes())?;
-				self.shortstatekey_statekey.insert(&shortstatekey.to_be_bytes(), &statekey_vec)?;
+				self.statekey_shortstatekey
+					.insert(&statekey_vec, &shortstatekey.to_be_bytes())?;
+				self.shortstatekey_statekey
+					.insert(&shortstatekey.to_be_bytes(), &statekey_vec)?;
 				shortstatekey
 			},
 		};
 
-		self.statekeyshort_cache.lock().unwrap().insert((event_type.clone(), state_key.to_owned()), short);
+		self.statekeyshort_cache
+			.lock()
+			.unwrap()
+			.insert((event_type.clone(), state_key.to_owned()), short);
 
 		Ok(short)
 	}
 
 	fn get_eventid_from_short(&self, shorteventid: u64) -> Result<Arc<EventId>> {
-		if let Some(id) = self.shorteventid_cache.lock().unwrap().get_mut(&shorteventid) {
+		if let Some(id) = self
+			.shorteventid_cache
+			.lock()
+			.unwrap()
+			.get_mut(&shorteventid)
+		{
 			return Ok(Arc::clone(id));
 		}
 
@@ -97,13 +121,21 @@ impl service::rooms::short::Data for KeyValueDatabase {
 		)
 		.map_err(|_| Error::bad_database("EventId in shorteventid_eventid is invalid."))?;
 
-		self.shorteventid_cache.lock().unwrap().insert(shorteventid, Arc::clone(&event_id));
+		self.shorteventid_cache
+			.lock()
+			.unwrap()
+			.insert(shorteventid, Arc::clone(&event_id));
 
 		Ok(event_id)
 	}
 
 	fn get_statekey_from_short(&self, shortstatekey: u64) -> Result<(StateEventType, String)> {
-		if let Some(id) = self.shortstatekey_cache.lock().unwrap().get_mut(&shortstatekey) {
+		if let Some(id) = self
+			.shortstatekey_cache
+			.lock()
+			.unwrap()
+			.get_mut(&shortstatekey)
+		{
 			return Ok(id.clone());
 		}
 
@@ -114,8 +146,9 @@ impl service::rooms::short::Data for KeyValueDatabase {
 
 		let mut parts = bytes.splitn(2, |&b| b == 0xFF);
 		let eventtype_bytes = parts.next().expect("split always returns one entry");
-		let statekey_bytes =
-			parts.next().ok_or_else(|| Error::bad_database("Invalid statekey in shortstatekey_statekey."))?;
+		let statekey_bytes = parts
+			.next()
+			.ok_or_else(|| Error::bad_database("Invalid statekey in shortstatekey_statekey."))?;
 
 		let event_type = StateEventType::from(utils::string_from_bytes(eventtype_bytes).map_err(|e| {
 			warn!("Event type in shortstatekey_statekey is invalid: {}", e);
@@ -127,7 +160,10 @@ impl service::rooms::short::Data for KeyValueDatabase {
 
 		let result = (event_type, state_key);
 
-		self.shortstatekey_cache.lock().unwrap().insert(shortstatekey, result.clone());
+		self.shortstatekey_cache
+			.lock()
+			.unwrap()
+			.insert(shortstatekey, result.clone());
 
 		Ok(result)
 	}
@@ -142,7 +178,8 @@ impl service::rooms::short::Data for KeyValueDatabase {
 			),
 			None => {
 				let shortstatehash = services().globals.next_count()?;
-				self.statehash_shortstatehash.insert(state_hash, &shortstatehash.to_be_bytes())?;
+				self.statehash_shortstatehash
+					.insert(state_hash, &shortstatehash.to_be_bytes())?;
 				(shortstatehash, false)
 			},
 		})
@@ -162,7 +199,8 @@ impl service::rooms::short::Data for KeyValueDatabase {
 			},
 			None => {
 				let short = services().globals.next_count()?;
-				self.roomid_shortroomid.insert(room_id.as_bytes(), &short.to_be_bytes())?;
+				self.roomid_shortroomid
+					.insert(room_id.as_bytes(), &short.to_be_bytes())?;
 				short
 			},
 		})

src/database/key_value/rooms/state.rs

@@ -7,11 +7,13 @@ 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>> {
-		self.roomid_shortstatehash.get(room_id.as_bytes())?.map_or(Ok(None), |bytes| {
-			Ok(Some(utils::u64_from_bytes(&bytes).map_err(|_| {
-				Error::bad_database("Invalid shortstatehash in roomid_shortstatehash")
-			})?))
-		})
+		self.roomid_shortstatehash
+			.get(room_id.as_bytes())?
+			.map_or(Ok(None), |bytes| {
+				Ok(Some(utils::u64_from_bytes(&bytes).map_err(|_| {
+					Error::bad_database("Invalid shortstatehash in roomid_shortstatehash")
+				})?))
+			})
 	}
 
 	fn set_room_state(
@@ -20,12 +22,14 @@ impl service::rooms::state::Data for KeyValueDatabase {
 		new_shortstatehash: u64,
 		_mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room state mutex
 	) -> Result<()> {
-		self.roomid_shortstatehash.insert(room_id.as_bytes(), &new_shortstatehash.to_be_bytes())?;
+		self.roomid_shortstatehash
+			.insert(room_id.as_bytes(), &new_shortstatehash.to_be_bytes())?;
 		Ok(())
 	}
 
 	fn set_event_state(&self, shorteventid: u64, shortstatehash: u64) -> Result<()> {
-		self.shorteventid_shortstatehash.insert(&shorteventid.to_be_bytes(), &shortstatehash.to_be_bytes())?;
+		self.shorteventid_shortstatehash
+			.insert(&shorteventid.to_be_bytes(), &shortstatehash.to_be_bytes())?;
 		Ok(())
 	}
 

src/database/key_value/rooms/state_accessor.rs

@@ -19,7 +19,10 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
 		let mut result = HashMap::new();
 		let mut i = 0;
 		for compressed in full_state.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;
@@ -43,7 +46,10 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
 		let mut result = HashMap::new();
 		let mut i = 0;
 		for compressed in full_state.iter() {
-			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(
 					(
@@ -71,7 +77,11 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
 	fn state_get_id(
 		&self, shortstatehash: u64, 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),
 		};
@@ -82,11 +92,17 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
 			.pop()
 			.expect("there is always one layer")
 			.1;
-		Ok(
-			full_state.iter().find(|bytes| bytes.starts_with(&shortstatekey.to_be_bytes())).and_then(|compressed| {
-				services().rooms.state_compressor.parse_compressed_state_event(compressed).ok().map(|(_, id)| id)
-			}),
-		)
+		Ok(full_state
+			.iter()
+			.find(|bytes| bytes.starts_with(&shortstatekey.to_be_bytes()))
+			.and_then(|compressed| {
+				services()
+					.rooms
+					.state_compressor
+					.parse_compressed_state_event(compressed)
+					.ok()
+					.map(|(_, id)| id)
+			}))
 	}
 
 	/// Returns a single PDU from `room_id` with key (`event_type`,
@@ -100,15 +116,18 @@ impl service::rooms::state_accessor::Data for KeyValueDatabase {
 
 	/// Returns the state hash for this pdu.
 	fn pdu_shortstatehash(&self, event_id: &EventId) -> Result<Option<u64>> {
-		self.eventid_shorteventid.get(event_id.as_bytes())?.map_or(Ok(None), |shorteventid| {
-			self.shorteventid_shortstatehash
-				.get(&shorteventid)?
-				.map(|bytes| {
-					utils::u64_from_bytes(&bytes)
-						.map_err(|_| Error::bad_database("Invalid shortstatehash bytes in shorteventid_shortstatehash"))
-				})
-				.transpose()
-		})
+		self.eventid_shorteventid
+			.get(event_id.as_bytes())?
+			.map_or(Ok(None), |shorteventid| {
+				self.shorteventid_shortstatehash
+					.get(&shorteventid)?
+					.map(|bytes| {
+						utils::u64_from_bytes(&bytes).map_err(|_| {
+							Error::bad_database("Invalid shortstatehash bytes in shorteventid_shortstatehash")
+						})
+					})
+					.transpose()
+			})
 	}
 
 	/// Returns the full room state.

src/database/key_value/rooms/state_cache.rs

@@ -58,7 +58,8 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
 			&userroom_id,
 			&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)?;
@@ -80,7 +81,8 @@ 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)?;
@@ -109,11 +111,16 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
 			invitedcount += 1;
 		}
 
-		self.roomid_joinedcount.insert(room_id.as_bytes(), &joinedcount.to_be_bytes())?;
+		self.roomid_joinedcount
+			.insert(room_id.as_bytes(), &joinedcount.to_be_bytes())?;
 
-		self.roomid_invitedcount.insert(room_id.as_bytes(), &invitedcount.to_be_bytes())?;
+		self.roomid_invitedcount
+			.insert(room_id.as_bytes(), &invitedcount.to_be_bytes())?;
 
-		self.our_real_users_cache.write().unwrap().insert(room_id.to_owned(), Arc::new(real_users));
+		self.our_real_users_cache
+			.write()
+			.unwrap()
+			.insert(room_id.to_owned(), Arc::new(real_users));
 
 		for old_joined_server in self.room_servers(room_id).filter_map(Result::ok) {
 			if !joined_servers.remove(&old_joined_server) {
@@ -145,19 +152,33 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
 			self.serverroomids.insert(&serverroom_id, &[])?;
 		}
 
-		self.appservice_in_room_cache.write().unwrap().remove(room_id);
+		self.appservice_in_room_cache
+			.write()
+			.unwrap()
+			.remove(room_id);
 
 		Ok(())
 	}
 
 	#[tracing::instrument(skip(self, room_id))]
 	fn get_our_real_users(&self, room_id: &RoomId) -> Result<Arc<HashSet<OwnedUserId>>> {
-		let maybe = self.our_real_users_cache.read().unwrap().get(room_id).cloned();
+		let maybe = self
+			.our_real_users_cache
+			.read()
+			.unwrap()
+			.get(room_id)
+			.cloned();
 		if let Some(users) = maybe {
 			Ok(users)
 		} else {
 			self.update_joined_count(room_id)?;
-			Ok(Arc::clone(self.our_real_users_cache.read().unwrap().get(room_id).unwrap()))
+			Ok(Arc::clone(
+				self.our_real_users_cache
+					.read()
+					.unwrap()
+					.get(room_id)
+					.unwrap(),
+			))
 		}
 	}
 
@@ -221,8 +242,12 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
 
 		Box::new(self.roomserverids.scan_prefix(prefix).map(|(key, _)| {
 			ServerName::parse(
-				utils::string_from_bytes(key.rsplit(|&b| b == 0xFF).next().expect("rsplit always returns an element"))
-					.map_err(|_| Error::bad_database("Server name in roomserverids is invalid unicode."))?,
+				utils::string_from_bytes(
+					key.rsplit(|&b| b == 0xFF)
+						.next()
+						.expect("rsplit always returns an element"),
+				)
+				.map_err(|_| Error::bad_database("Server name in roomserverids is invalid unicode."))?,
 			)
 			.map_err(|_| Error::bad_database("Server name in roomserverids is invalid."))
 		}))
@@ -246,8 +271,12 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
 
 		Box::new(self.serverroomids.scan_prefix(prefix).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("RoomId in serverroomids is invalid unicode."))?,
+				utils::string_from_bytes(
+					key.rsplit(|&b| b == 0xFF)
+						.next()
+						.expect("rsplit always returns an element"),
+				)
+				.map_err(|_| Error::bad_database("RoomId in serverroomids is invalid unicode."))?,
 			)
 			.map_err(|_| Error::bad_database("RoomId in serverroomids is invalid."))
 		}))
@@ -261,8 +290,12 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
 
 		Box::new(self.roomuserid_joined.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_joined is invalid unicode."))?,
+				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_joined is invalid unicode."))?,
 			)
 			.map_err(|_| Error::bad_database("User ID in roomuserid_joined is invalid."))
 		}))
@@ -292,13 +325,21 @@ 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"))
-					.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."))
-		}))
+		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."))
+				}),
+		)
 	}
 
 	/// Returns an iterator over all invited members of a room.
@@ -307,13 +348,21 @@ 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"))
-					.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."))
-		}))
+		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."))
+				}),
+		)
 	}
 
 	#[tracing::instrument(skip(self))]
@@ -322,11 +371,13 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
 		key.push(0xFF);
 		key.extend_from_slice(user_id.as_bytes());
 
-		self.roomuserid_invitecount.get(&key)?.map_or(Ok(None), |bytes| {
-			Ok(Some(
-				utils::u64_from_bytes(&bytes).map_err(|_| Error::bad_database("Invalid invitecount in db."))?,
-			))
-		})
+		self.roomuserid_invitecount
+			.get(&key)?
+			.map_or(Ok(None), |bytes| {
+				Ok(Some(
+					utils::u64_from_bytes(&bytes).map_err(|_| Error::bad_database("Invalid invitecount in db."))?,
+				))
+			})
 	}
 
 	#[tracing::instrument(skip(self))]
@@ -344,13 +395,21 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
 	/// Returns an iterator over all rooms this user joined.
 	#[tracing::instrument(skip(self))]
 	fn rooms_joined<'a>(&'a self, user_id: &UserId) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + '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"))
-					.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."))
-		}))
+		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."))
+				}),
+		)
 	}
 
 	/// Returns an iterator over all rooms a user was invited to.
@@ -359,18 +418,26 @@ 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"))
-					.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."))?;
+		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."))?;
 
-			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))]
@@ -413,18 +480,26 @@ 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"))
-					.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."))?;
+		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."))?;
 
-			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

@@ -58,6 +58,7 @@ impl service::rooms::state_compressor::Data for KeyValueDatabase {
 			}
 		}
 
-		self.shortstatehash_statediff.insert(&shortstatehash.to_be_bytes(), &value)
+		self.shortstatehash_statediff
+			.insert(&shortstatehash.to_be_bytes(), &value)
 	}
 }

src/database/key_value/rooms/threads.rs

@@ -10,14 +10,22 @@ impl service::rooms::threads::Data for KeyValueDatabase {
 	fn threads_until<'a>(
 		&'a self, user_id: &'a UserId, room_id: &'a RoomId, until: u64, _include: &'a IncludeThreads,
 	) -> PduEventIterResult<'a> {
-		let prefix = services().rooms.short.get_shortroomid(room_id)?.expect("room exists").to_be_bytes().to_vec();
+		let prefix = services()
+			.rooms
+			.short
+			.get_shortroomid(room_id)?
+			.expect("room exists")
+			.to_be_bytes()
+			.to_vec();
 
 		let mut current = prefix.clone();
 		current.extend_from_slice(&(until - 1).to_be_bytes());
 
 		Ok(Box::new(
-			self.threadid_userids.iter_from(&current, true).take_while(move |(k, _)| k.starts_with(&prefix)).map(
-				move |(pduid, _users)| {
+			self.threadid_userids
+				.iter_from(&current, true)
+				.take_while(move |(k, _)| k.starts_with(&prefix))
+				.map(move |(pduid, _users)| {
 					let count = utils::u64_from_bytes(&pduid[(mem::size_of::<u64>())..])
 						.map_err(|_| Error::bad_database("Invalid pduid in threadid_userids."))?;
 					let mut pdu = services()
@@ -29,13 +37,16 @@ impl service::rooms::threads::Data for KeyValueDatabase {
 						pdu.remove_transaction_id()?;
 					}
 					Ok((count, pdu))
-				},
-			),
+				}),
 		))
 	}
 
 	fn update_participants(&self, root_id: &[u8], participants: &[OwnedUserId]) -> Result<()> {
-		let users = participants.iter().map(|user| user.as_bytes()).collect::<Vec<_>>().join(&[0xFF][..]);
+		let users = participants
+			.iter()
+			.map(|user| user.as_bytes())
+			.collect::<Vec<_>>()
+			.join(&[0xFF][..]);
 
 		self.threadid_userids.insert(root_id, &users)?;
 

src/database/key_value/rooms/timeline.rs

@@ -8,15 +8,22 @@ use crate::{database::KeyValueDatabase, service, services, utils, Error, PduEven
 
 impl service::rooms::timeline::Data for KeyValueDatabase {
 	fn last_timeline_count(&self, sender_user: &UserId, room_id: &RoomId) -> Result<PduCount> {
-		match self.lasttimelinecount_cache.lock().unwrap().entry(room_id.to_owned()) {
+		match self
+			.lasttimelinecount_cache
+			.lock()
+			.unwrap()
+			.entry(room_id.to_owned())
+		{
 			hash_map::Entry::Vacant(v) => {
-				if let Some(last_count) = self.pdus_until(sender_user, room_id, PduCount::max())?.find_map(|r| {
-					// Filter out buggy events
-					if r.is_err() {
-						error!("Bad pdu in pdus_since: {:?}", r);
-					}
-					r.ok()
-				}) {
+				if let Some(last_count) = self
+					.pdus_until(sender_user, room_id, PduCount::max())?
+					.find_map(|r| {
+						// Filter out buggy events
+						if r.is_err() {
+							error!("Bad pdu in pdus_since: {:?}", r);
+						}
+						r.ok()
+					}) {
 					Ok(*v.insert(last_count.0))
 				} else {
 					Ok(PduCount::Normal(0))
@@ -28,7 +35,10 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 
 	/// Returns the `count` of this pdu's id.
 	fn get_pdu_count(&self, event_id: &EventId) -> Result<Option<PduCount>> {
-		self.eventid_pduid.get(event_id.as_bytes())?.map(|pdu_id| pdu_count(&pdu_id)).transpose()
+		self.eventid_pduid
+			.get(event_id.as_bytes())?
+			.map(|pdu_id| pdu_count(&pdu_id))
+			.transpose()
 	}
 
 	/// Returns the json of a pdu.
@@ -49,7 +59,9 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 		self.eventid_pduid
 			.get(event_id.as_bytes())?
 			.map(|pduid| {
-				self.pduid_pdu.get(&pduid)?.ok_or_else(|| Error::bad_database("Invalid pduid in eventid_pduid."))
+				self.pduid_pdu
+					.get(&pduid)?
+					.ok_or_else(|| Error::bad_database("Invalid pduid in eventid_pduid."))
 			})
 			.transpose()?
 			.map(|pdu| serde_json::from_slice(&pdu).map_err(|_| Error::bad_database("Invalid PDU in db.")))
@@ -64,7 +76,9 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 		self.eventid_pduid
 			.get(event_id.as_bytes())?
 			.map(|pduid| {
-				self.pduid_pdu.get(&pduid)?.ok_or_else(|| Error::bad_database("Invalid pduid in eventid_pduid."))
+				self.pduid_pdu
+					.get(&pduid)?
+					.ok_or_else(|| Error::bad_database("Invalid pduid in eventid_pduid."))
 			})
 			.transpose()?
 			.map(|pdu| serde_json::from_slice(&pdu).map_err(|_| Error::bad_database("Invalid PDU in db.")))
@@ -92,7 +106,10 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 			)?
 			.map(Arc::new)
 		{
-			self.pdu_cache.lock().unwrap().insert(event_id.to_owned(), Arc::clone(&pdu));
+			self.pdu_cache
+				.lock()
+				.unwrap()
+				.insert(event_id.to_owned(), Arc::clone(&pdu));
 			Ok(Some(pdu))
 		} else {
 			Ok(None)
@@ -125,7 +142,10 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 			&serde_json::to_vec(json).expect("CanonicalJsonObject is always a valid"),
 		)?;
 
-		self.lasttimelinecount_cache.lock().unwrap().insert(pdu.room_id.clone(), PduCount::Normal(count));
+		self.lasttimelinecount_cache
+			.lock()
+			.unwrap()
+			.insert(pdu.room_id.clone(), PduCount::Normal(count));
 
 		self.eventid_pduid.insert(pdu.event_id.as_bytes(), pdu_id)?;
 		self.eventid_outlierpdu.remove(pdu.event_id.as_bytes())?;
@@ -156,7 +176,10 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 			return Err(Error::BadRequest(ErrorKind::NotFound, "PDU does not exist."));
 		}
 
-		self.pdu_cache.lock().unwrap().remove(&(*pdu.event_id).to_owned());
+		self.pdu_cache
+			.lock()
+			.unwrap()
+			.remove(&(*pdu.event_id).to_owned());
 
 		Ok(())
 	}
@@ -172,8 +195,10 @@ 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)| {
+			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 {
@@ -182,8 +207,7 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 					pdu.add_age()?;
 					let count = pdu_count(&pdu_id)?;
 					Ok((count, pdu))
-				},
-			),
+				}),
 		))
 	}
 
@@ -195,8 +219,10 @@ 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)| {
+			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 {
@@ -205,8 +231,7 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 					pdu.add_age()?;
 					let count = pdu_count(&pdu_id)?;
 					Ok((count, pdu))
-				},
-			),
+				}),
 		))
 	}
 
@@ -228,8 +253,10 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
 			highlights_batch.push(userroom_id);
 		}
 
-		self.userroomid_notificationcount.increment_batch(&mut notifies_batch.into_iter())?;
-		self.userroomid_highlightcount.increment_batch(&mut highlights_batch.into_iter())?;
+		self.userroomid_notificationcount
+			.increment_batch(&mut notifies_batch.into_iter())?;
+		self.userroomid_highlightcount
+			.increment_batch(&mut highlights_batch.into_iter())?;
 		Ok(())
 	}
 }

src/database/key_value/rooms/user.rs

@@ -11,10 +11,13 @@ impl service::rooms::user::Data for KeyValueDatabase {
 		roomuser_id.push(0xFF);
 		roomuser_id.extend_from_slice(user_id.as_bytes());
 
-		self.userroomid_notificationcount.insert(&userroom_id, &0_u64.to_be_bytes())?;
-		self.userroomid_highlightcount.insert(&userroom_id, &0_u64.to_be_bytes())?;
+		self.userroomid_notificationcount
+			.insert(&userroom_id, &0_u64.to_be_bytes())?;
+		self.userroomid_highlightcount
+			.insert(&userroom_id, &0_u64.to_be_bytes())?;
 
-		self.roomuserid_lastnotificationread.insert(&roomuser_id, &services().globals.next_count()?.to_be_bytes())?;
+		self.roomuserid_lastnotificationread
+			.insert(&roomuser_id, &services().globals.next_count()?.to_be_bytes())?;
 
 		Ok(())
 	}
@@ -24,9 +27,11 @@ impl service::rooms::user::Data for KeyValueDatabase {
 		userroom_id.push(0xFF);
 		userroom_id.extend_from_slice(room_id.as_bytes());
 
-		self.userroomid_notificationcount.get(&userroom_id)?.map_or(Ok(0), |bytes| {
-			utils::u64_from_bytes(&bytes).map_err(|_| Error::bad_database("Invalid notification count in db."))
-		})
+		self.userroomid_notificationcount
+			.get(&userroom_id)?
+			.map_or(Ok(0), |bytes| {
+				utils::u64_from_bytes(&bytes).map_err(|_| Error::bad_database("Invalid notification count in db."))
+			})
 	}
 
 	fn highlight_count(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
@@ -34,9 +39,11 @@ impl service::rooms::user::Data for KeyValueDatabase {
 		userroom_id.push(0xFF);
 		userroom_id.extend_from_slice(room_id.as_bytes());
 
-		self.userroomid_highlightcount.get(&userroom_id)?.map_or(Ok(0), |bytes| {
-			utils::u64_from_bytes(&bytes).map_err(|_| Error::bad_database("Invalid highlight count in db."))
-		})
+		self.userroomid_highlightcount
+			.get(&userroom_id)?
+			.map_or(Ok(0), |bytes| {
+				utils::u64_from_bytes(&bytes).map_err(|_| Error::bad_database("Invalid highlight count in db."))
+			})
 	}
 
 	fn last_notification_read(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
@@ -56,16 +63,25 @@ impl service::rooms::user::Data for KeyValueDatabase {
 	}
 
 	fn associate_token_shortstatehash(&self, room_id: &RoomId, 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());
 
-		self.roomsynctoken_shortstatehash.insert(&key, &shortstatehash.to_be_bytes())
+		self.roomsynctoken_shortstatehash
+			.insert(&key, &shortstatehash.to_be_bytes())
 	}
 
 	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());
@@ -106,13 +122,15 @@ impl service::rooms::user::Data for KeyValueDatabase {
 		// We use the default compare function because keys are sorted correctly (not
 		// reversed)
 		Ok(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."))
-			}),
+			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."))
+				}),
 		))
 	}
 }