use chain_width 60

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

src/database/abstraction/rocksdb.rs

@@ -155,7 +155,8 @@ impl KeyValueDatabaseEngine for Arc<Engine> {
 		let db = rust_rocksdb::DBWithThreadMode::<rust_rocksdb::MultiThreaded>::open_cf_descriptors(
 			&db_opts,
 			&config.database_path,
-			cfs.iter().map(|name| rust_rocksdb::ColumnFamilyDescriptor::new(name, db_opts.clone())),
+			cfs.iter()
+				.map(|name| rust_rocksdb::ColumnFamilyDescriptor::new(name, db_opts.clone())),
 		)?;
 
 		Ok(Arc::new(Engine {
@@ -200,13 +201,15 @@ impl KeyValueDatabaseEngine for Arc<Engine> {
 	fn corked(&self) -> bool { self.corks.load(std::sync::atomic::Ordering::Relaxed) > 0 }
 
 	fn cork(&self) -> Result<()> {
-		self.corks.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+		self.corks
+			.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
 
 		Ok(())
 	}
 
 	fn uncork(&self) -> Result<()> {
-		self.corks.fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
+		self.corks
+			.fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
 
 		Ok(())
 	}
@@ -293,7 +296,9 @@ impl KeyValueDatabaseEngine for Arc<Engine> {
 				format_args!(
 					"#{} {}: {} bytes, {} files\n",
 					info.backup_id,
-					DateTime::<Utc>::from_timestamp(info.timestamp, 0).unwrap_or_default().to_rfc2822(),
+					DateTime::<Utc>::from_timestamp(info.timestamp, 0)
+						.unwrap_or_default()
+						.to_rfc2822(),
 					info.size,
 					info.num_files,
 				),
@@ -358,7 +363,9 @@ impl KvTree for RocksDbEngineTree<'_> {
 		let writeoptions = rust_rocksdb::WriteOptions::default();
 		let lock = self.write_lock.read().unwrap();
 
-		self.db.rocks.put_cf_opt(&self.cf(), key, value, &writeoptions)?;
+		self.db
+			.rocks
+			.put_cf_opt(&self.cf(), key, value, &writeoptions)?;
 
 		drop(lock);
 
@@ -465,7 +472,9 @@ impl KvTree for RocksDbEngineTree<'_> {
 
 		let old = self.db.rocks.get_cf_opt(&self.cf(), key, &readoptions)?;
 		let new = utils::increment(old.as_deref());
-		self.db.rocks.put_cf_opt(&self.cf(), key, &new, &writeoptions)?;
+		self.db
+			.rocks
+			.put_cf_opt(&self.cf(), key, &new, &writeoptions)?;
 
 		drop(lock);
 

src/database/abstraction/sqlite.rs

@@ -68,15 +68,18 @@ impl Engine {
 	fn write_lock(&self) -> MutexGuard<'_, Connection> { self.writer.lock() }
 
 	fn read_lock(&self) -> &Connection {
-		self.read_conn_tls.get_or(|| Self::prepare_conn(&self.path, self.cache_size_per_thread).unwrap())
+		self.read_conn_tls
+			.get_or(|| Self::prepare_conn(&self.path, self.cache_size_per_thread).unwrap())
 	}
 
 	fn read_lock_iterator(&self) -> &Connection {
-		self.read_iterator_conn_tls.get_or(|| Self::prepare_conn(&self.path, self.cache_size_per_thread).unwrap())
+		self.read_iterator_conn_tls
+			.get_or(|| Self::prepare_conn(&self.path, self.cache_size_per_thread).unwrap())
 	}
 
 	pub fn flush_wal(self: &Arc<Self>) -> Result<()> {
-		self.write_lock().pragma_update(Some(Main), "wal_checkpoint", "RESTART")?;
+		self.write_lock()
+			.pragma_update(Some(Main), "wal_checkpoint", "RESTART")?;
 		Ok(())
 	}
 }
@@ -153,7 +156,9 @@ impl SqliteTable {
 
 	pub fn iter_with_guard<'a>(&'a self, guard: &'a Connection) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
 		let statement = Box::leak(Box::new(
-			guard.prepare(&format!("SELECT key, value FROM {} ORDER BY key ASC", &self.name)).unwrap(),
+			guard
+				.prepare(&format!("SELECT key, value FROM {} ORDER BY key ASC", &self.name))
+				.unwrap(),
 		));
 
 		let statement_ref = NonAliasingBox(statement);
@@ -161,7 +166,10 @@ impl SqliteTable {
 		//let name = self.name.clone();
 
 		let iterator = Box::new(
-			statement.query_map([], |row| Ok((row.get_unwrap(0), row.get_unwrap(1)))).unwrap().map(Result::unwrap),
+			statement
+				.query_map([], |row| Ok((row.get_unwrap(0), row.get_unwrap(1))))
+				.unwrap()
+				.map(Result::unwrap),
 		);
 
 		Box::new(PreparedStatementIterator {
@@ -293,7 +301,10 @@ impl KvTree for SqliteTable {
 	}
 
 	fn scan_prefix<'a>(&'a self, prefix: Vec<u8>) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
-		Box::new(self.iter_from(&prefix, false).take_while(move |(key, _)| key.starts_with(&prefix)))
+		Box::new(
+			self.iter_from(&prefix, false)
+				.take_while(move |(key, _)| key.starts_with(&prefix)),
+		)
 	}
 
 	fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
@@ -302,7 +313,9 @@ impl KvTree for SqliteTable {
 
 	fn clear(&self) -> Result<()> {
 		debug!("clear: running");
-		self.engine.write_lock().execute(format!("DELETE FROM {}", self.name).as_str(), [])?;
+		self.engine
+			.write_lock()
+			.execute(format!("DELETE FROM {}", self.name).as_str(), [])?;
 		debug!("clear: ran");
 		Ok(())
 	}

src/database/key_value/account_data.rs

@@ -18,7 +18,11 @@ impl service::account_data::Data for KeyValueDatabase {
 		&self, room_id: Option<&RoomId>, user_id: &UserId, event_type: RoomAccountDataEventType,
 		data: &serde_json::Value,
 	) -> Result<()> {
-		let mut prefix = room_id.map(ToString::to_string).unwrap_or_default().as_bytes().to_vec();
+		let mut prefix = room_id
+			.map(ToString::to_string)
+			.unwrap_or_default()
+			.as_bytes()
+			.to_vec();
 		prefix.push(0xFF);
 		prefix.extend_from_slice(user_id.as_bytes());
 		prefix.push(0xFF);
@@ -45,7 +49,8 @@ impl service::account_data::Data for KeyValueDatabase {
 
 		let prev = self.roomusertype_roomuserdataid.get(&key)?;
 
-		self.roomusertype_roomuserdataid.insert(&key, &roomuserdataid)?;
+		self.roomusertype_roomuserdataid
+			.insert(&key, &roomuserdataid)?;
 
 		// Remove old entry
 		if let Some(prev) = prev {
@@ -60,7 +65,11 @@ impl service::account_data::Data for KeyValueDatabase {
 	fn get(
 		&self, room_id: Option<&RoomId>, user_id: &UserId, kind: RoomAccountDataEventType,
 	) -> Result<Option<Box<serde_json::value::RawValue>>> {
-		let mut key = room_id.map(ToString::to_string).unwrap_or_default().as_bytes().to_vec();
+		let mut key = room_id
+			.map(ToString::to_string)
+			.unwrap_or_default()
+			.as_bytes()
+			.to_vec();
 		key.push(0xFF);
 		key.extend_from_slice(user_id.as_bytes());
 		key.push(0xFF);
@@ -68,7 +77,11 @@ impl service::account_data::Data for KeyValueDatabase {
 
 		self.roomusertype_roomuserdataid
 			.get(&key)?
-			.and_then(|roomuserdataid| self.roomuserdataid_accountdata.get(&roomuserdataid).transpose())
+			.and_then(|roomuserdataid| {
+				self.roomuserdataid_accountdata
+					.get(&roomuserdataid)
+					.transpose()
+			})
 			.transpose()?
 			.map(|data| serde_json::from_slice(&data).map_err(|_| Error::bad_database("could not deserialize")))
 			.transpose()
@@ -81,7 +94,11 @@ impl service::account_data::Data for KeyValueDatabase {
 	) -> Result<HashMap<RoomAccountDataEventType, Raw<AnyEphemeralRoomEvent>>> {
 		let mut userdata = HashMap::new();
 
-		let mut prefix = room_id.map(ToString::to_string).unwrap_or_default().as_bytes().to_vec();
+		let mut prefix = room_id
+			.map(ToString::to_string)
+			.unwrap_or_default()
+			.as_bytes()
+			.to_vec();
 		prefix.push(0xFF);
 		prefix.extend_from_slice(user_id.as_bytes());
 		prefix.push(0xFF);

src/database/key_value/appservice.rs

@@ -6,7 +6,8 @@ impl service::appservice::Data for KeyValueDatabase {
 	/// Registers an appservice and returns the ID to the caller
 	fn register_appservice(&self, yaml: Registration) -> Result<String> {
 		let id = yaml.id.as_str();
-		self.id_appserviceregistrations.insert(id.as_bytes(), serde_yaml::to_string(&yaml).unwrap().as_bytes())?;
+		self.id_appserviceregistrations
+			.insert(id.as_bytes(), serde_yaml::to_string(&yaml).unwrap().as_bytes())?;
 
 		Ok(id.to_owned())
 	}
@@ -17,7 +18,8 @@ impl service::appservice::Data for KeyValueDatabase {
 	///
 	/// * `service_name` - the name you send to register the service previously
 	fn unregister_appservice(&self, service_name: &str) -> Result<()> {
-		self.id_appserviceregistrations.remove(service_name.as_bytes())?;
+		self.id_appserviceregistrations
+			.remove(service_name.as_bytes())?;
 		Ok(())
 	}
 
@@ -44,7 +46,8 @@ impl service::appservice::Data for KeyValueDatabase {
 			.map(move |id| {
 				Ok((
 					id.clone(),
-					self.get_registration(&id)?.expect("iter_ids only returns appservices that exist"),
+					self.get_registration(&id)?
+						.expect("iter_ids only returns appservices that exist"),
 				))
 			})
 			.collect()

src/database/key_value/globals.rs

@@ -31,14 +31,17 @@ impl service::globals::Data for KeyValueDatabase {
 	}
 
 	fn last_check_for_updates_id(&self) -> Result<u64> {
-		self.global.get(LAST_CHECK_FOR_UPDATES_COUNT)?.map_or(Ok(0_u64), |bytes| {
-			utils::u64_from_bytes(&bytes)
-				.map_err(|_| Error::bad_database("last check for updates count has invalid bytes."))
-		})
+		self.global
+			.get(LAST_CHECK_FOR_UPDATES_COUNT)?
+			.map_or(Ok(0_u64), |bytes| {
+				utils::u64_from_bytes(&bytes)
+					.map_err(|_| Error::bad_database("last check for updates count has invalid bytes."))
+			})
 	}
 
 	fn update_check_for_updates_id(&self, id: u64) -> Result<()> {
-		self.global.insert(LAST_CHECK_FOR_UPDATES_COUNT, &id.to_be_bytes())?;
+		self.global
+			.insert(LAST_CHECK_FOR_UPDATES_COUNT, &id.to_be_bytes())?;
 
 		Ok(())
 	}
@@ -62,11 +65,19 @@ impl service::globals::Data for KeyValueDatabase {
 		futures.push(self.userroomid_joined.watch_prefix(&userid_prefix));
 		futures.push(self.userroomid_invitestate.watch_prefix(&userid_prefix));
 		futures.push(self.userroomid_leftstate.watch_prefix(&userid_prefix));
-		futures.push(self.userroomid_notificationcount.watch_prefix(&userid_prefix));
+		futures.push(
+			self.userroomid_notificationcount
+				.watch_prefix(&userid_prefix),
+		);
 		futures.push(self.userroomid_highlightcount.watch_prefix(&userid_prefix));
 
 		// Events for rooms we are in
-		for room_id in services().rooms.state_cache.rooms_joined(user_id).filter_map(Result::ok) {
+		for room_id in services()
+			.rooms
+			.state_cache
+			.rooms_joined(user_id)
+			.filter_map(Result::ok)
+		{
 			let short_roomid = services()
 				.rooms
 				.short
@@ -98,13 +109,19 @@ impl service::globals::Data for KeyValueDatabase {
 			let mut roomuser_prefix = roomid_prefix.clone();
 			roomuser_prefix.extend_from_slice(&userid_prefix);
 
-			futures.push(self.roomusertype_roomuserdataid.watch_prefix(&roomuser_prefix));
+			futures.push(
+				self.roomusertype_roomuserdataid
+					.watch_prefix(&roomuser_prefix),
+			);
 		}
 
 		let mut globaluserdata_prefix = vec![0xFF];
 		globaluserdata_prefix.extend_from_slice(&userid_prefix);
 
-		futures.push(self.roomusertype_roomuserdataid.watch_prefix(&globaluserdata_prefix));
+		futures.push(
+			self.roomusertype_roomuserdataid
+				.watch_prefix(&globaluserdata_prefix),
+		);
 
 		// More key changes (used when user is not joined to any rooms)
 		futures.push(self.keychangeid_userid.watch_prefix(&userid_prefix));
@@ -207,7 +224,9 @@ lasttimelinecount_cache: {lasttimelinecount_cache}\n"
 
 		utils::string_from_bytes(
 			// 1. version
-			parts.next().expect("splitn always returns at least one element"),
+			parts
+				.next()
+				.expect("splitn always returns at least one element"),
 		)
 		.map_err(|_| Error::bad_database("Invalid version bytes in keypair."))
 		.and_then(|version| {
@@ -231,10 +250,12 @@ lasttimelinecount_cache: {lasttimelinecount_cache}\n"
 		// Not atomic, but this is not critical
 		let signingkeys = self.server_signingkeys.get(origin.as_bytes())?;
 
-		let mut keys = signingkeys.and_then(|keys| serde_json::from_slice(&keys).ok()).unwrap_or_else(|| {
-			// Just insert "now", it doesn't matter
-			ServerSigningKeys::new(origin.to_owned(), MilliSecondsSinceUnixEpoch::now())
-		});
+		let mut keys = signingkeys
+			.and_then(|keys| serde_json::from_slice(&keys).ok())
+			.unwrap_or_else(|| {
+				// Just insert "now", it doesn't matter
+				ServerSigningKeys::new(origin.to_owned(), MilliSecondsSinceUnixEpoch::now())
+			});
 
 		let ServerSigningKeys {
 			verify_keys,
@@ -251,7 +272,11 @@ lasttimelinecount_cache: {lasttimelinecount_cache}\n"
 		)?;
 
 		let mut tree = keys.verify_keys;
-		tree.extend(keys.old_verify_keys.into_iter().map(|old| (old.0, VerifyKey::new(old.1.key))));
+		tree.extend(
+			keys.old_verify_keys
+				.into_iter()
+				.map(|old| (old.0, VerifyKey::new(old.1.key))),
+		);
 
 		Ok(tree)
 	}
@@ -265,7 +290,11 @@ lasttimelinecount_cache: {lasttimelinecount_cache}\n"
 			.and_then(|bytes| serde_json::from_slice(&bytes).ok())
 			.map_or_else(BTreeMap::new, |keys: ServerSigningKeys| {
 				let mut tree = keys.verify_keys;
-				tree.extend(keys.old_verify_keys.into_iter().map(|old| (old.0, VerifyKey::new(old.1.key))));
+				tree.extend(
+					keys.old_verify_keys
+						.into_iter()
+						.map(|old| (old.0, VerifyKey::new(old.1.key))),
+				);
 				tree
 			});
 

src/database/key_value/key_backups.rs

@@ -23,7 +23,8 @@ impl service::key_backups::Data for KeyValueDatabase {
 			&key,
 			&serde_json::to_vec(backup_metadata).expect("BackupAlgorithm::to_vec always works"),
 		)?;
-		self.backupid_etag.insert(&key, &services().globals.next_count()?.to_be_bytes())?;
+		self.backupid_etag
+			.insert(&key, &services().globals.next_count()?.to_be_bytes())?;
 		Ok(version)
 	}
 
@@ -53,8 +54,10 @@ impl service::key_backups::Data for KeyValueDatabase {
 			return Err(Error::BadRequest(ErrorKind::NotFound, "Tried to update nonexistent backup."));
 		}
 
-		self.backupid_algorithm.insert(&key, backup_metadata.json().get().as_bytes())?;
-		self.backupid_etag.insert(&key, &services().globals.next_count()?.to_be_bytes())?;
+		self.backupid_algorithm
+			.insert(&key, backup_metadata.json().get().as_bytes())?;
+		self.backupid_etag
+			.insert(&key, &services().globals.next_count()?.to_be_bytes())?;
 		Ok(version.to_owned())
 	}
 
@@ -69,8 +72,12 @@ impl service::key_backups::Data for KeyValueDatabase {
 			.take_while(move |(k, _)| k.starts_with(&prefix))
 			.next()
 			.map(|(key, _)| {
-				utils::string_from_bytes(key.rsplit(|&b| b == 0xFF).next().expect("rsplit always returns an element"))
-					.map_err(|_| Error::bad_database("backupid_algorithm key is invalid."))
+				utils::string_from_bytes(
+					key.rsplit(|&b| b == 0xFF)
+						.next()
+						.expect("rsplit always returns an element"),
+				)
+				.map_err(|_| Error::bad_database("backupid_algorithm key is invalid."))
 			})
 			.transpose()
 	}
@@ -87,7 +94,9 @@ impl service::key_backups::Data for KeyValueDatabase {
 			.next()
 			.map(|(key, value)| {
 				let version = utils::string_from_bytes(
-					key.rsplit(|&b| b == 0xFF).next().expect("rsplit always returns an element"),
+					key.rsplit(|&b| b == 0xFF)
+						.next()
+						.expect("rsplit always returns an element"),
 				)
 				.map_err(|_| Error::bad_database("backupid_algorithm key is invalid."))?;
 
@@ -105,10 +114,12 @@ impl service::key_backups::Data for KeyValueDatabase {
 		key.push(0xFF);
 		key.extend_from_slice(version.as_bytes());
 
-		self.backupid_algorithm.get(&key)?.map_or(Ok(None), |bytes| {
-			serde_json::from_slice(&bytes)
-				.map_err(|_| Error::bad_database("Algorithm in backupid_algorithm is invalid."))
-		})
+		self.backupid_algorithm
+			.get(&key)?
+			.map_or(Ok(None), |bytes| {
+				serde_json::from_slice(&bytes)
+					.map_err(|_| Error::bad_database("Algorithm in backupid_algorithm is invalid."))
+			})
 	}
 
 	fn add_key(
@@ -122,14 +133,16 @@ impl service::key_backups::Data for KeyValueDatabase {
 			return Err(Error::BadRequest(ErrorKind::NotFound, "Tried to update nonexistent backup."));
 		}
 
-		self.backupid_etag.insert(&key, &services().globals.next_count()?.to_be_bytes())?;
+		self.backupid_etag
+			.insert(&key, &services().globals.next_count()?.to_be_bytes())?;
 
 		key.push(0xFF);
 		key.extend_from_slice(room_id.as_bytes());
 		key.push(0xFF);
 		key.extend_from_slice(session_id.as_bytes());
 
-		self.backupkeyid_backup.insert(&key, key_data.json().get().as_bytes())?;
+		self.backupkeyid_backup
+			.insert(&key, key_data.json().get().as_bytes())?;
 
 		Ok(())
 	}
@@ -148,7 +161,10 @@ impl service::key_backups::Data for KeyValueDatabase {
 		key.extend_from_slice(version.as_bytes());
 
 		Ok(utils::u64_from_bytes(
-			&self.backupid_etag.get(&key)?.ok_or_else(|| Error::bad_database("Backup has no etag."))?,
+			&self
+				.backupid_etag
+				.get(&key)?
+				.ok_or_else(|| Error::bad_database("Backup has no etag."))?,
 		)
 		.map_err(|_| Error::bad_database("etag in backupid_etag invalid."))?
 		.to_string())
@@ -162,27 +178,34 @@ impl service::key_backups::Data for KeyValueDatabase {
 
 		let mut rooms = BTreeMap::<OwnedRoomId, RoomKeyBackup>::new();
 
-		for result in self.backupkeyid_backup.scan_prefix(prefix).map(|(key, value)| {
-			let mut parts = key.rsplit(|&b| b == 0xFF);
+		for result in self
+			.backupkeyid_backup
+			.scan_prefix(prefix)
+			.map(|(key, value)| {
+				let mut parts = key.rsplit(|&b| b == 0xFF);
 
-			let session_id = utils::string_from_bytes(
-				parts.next().ok_or_else(|| Error::bad_database("backupkeyid_backup key is invalid."))?,
-			)
-			.map_err(|_| Error::bad_database("backupkeyid_backup session_id is invalid."))?;
-
-			let room_id = RoomId::parse(
-				utils::string_from_bytes(
-					parts.next().ok_or_else(|| Error::bad_database("backupkeyid_backup key is invalid."))?,
+				let session_id = utils::string_from_bytes(
+					parts
+						.next()
+						.ok_or_else(|| Error::bad_database("backupkeyid_backup key is invalid."))?,
 				)
-				.map_err(|_| Error::bad_database("backupkeyid_backup room_id is invalid."))?,
-			)
-			.map_err(|_| Error::bad_database("backupkeyid_backup room_id is invalid room id."))?;
+				.map_err(|_| Error::bad_database("backupkeyid_backup session_id is invalid."))?;
 
-			let key_data = serde_json::from_slice(&value)
-				.map_err(|_| Error::bad_database("KeyBackupData in backupkeyid_backup is invalid."))?;
+				let room_id = RoomId::parse(
+					utils::string_from_bytes(
+						parts
+							.next()
+							.ok_or_else(|| Error::bad_database("backupkeyid_backup key is invalid."))?,
+					)
+					.map_err(|_| Error::bad_database("backupkeyid_backup room_id is invalid."))?,
+				)
+				.map_err(|_| Error::bad_database("backupkeyid_backup room_id is invalid room id."))?;
 
-			Ok::<_, Error>((room_id, session_id, key_data))
-		}) {
+				let key_data = serde_json::from_slice(&value)
+					.map_err(|_| Error::bad_database("KeyBackupData in backupkeyid_backup is invalid."))?;
+
+				Ok::<_, Error>((room_id, session_id, key_data))
+			}) {
 			let (room_id, session_id, key_data) = result?;
 			rooms
 				.entry(room_id)
@@ -213,7 +236,9 @@ impl service::key_backups::Data for KeyValueDatabase {
 				let mut parts = key.rsplit(|&b| b == 0xFF);
 
 				let session_id = utils::string_from_bytes(
-					parts.next().ok_or_else(|| Error::bad_database("backupkeyid_backup key is invalid."))?,
+					parts
+						.next()
+						.ok_or_else(|| Error::bad_database("backupkeyid_backup key is invalid."))?,
 				)
 				.map_err(|_| Error::bad_database("backupkeyid_backup session_id is invalid."))?;
 

src/database/key_value/media.rs

@@ -18,9 +18,19 @@ impl service::media::Data for KeyValueDatabase {
 		key.extend_from_slice(&width.to_be_bytes());
 		key.extend_from_slice(&height.to_be_bytes());
 		key.push(0xFF);
-		key.extend_from_slice(content_disposition.as_ref().map(|f| f.as_bytes()).unwrap_or_default());
+		key.extend_from_slice(
+			content_disposition
+				.as_ref()
+				.map(|f| f.as_bytes())
+				.unwrap_or_default(),
+		);
 		key.push(0xFF);
-		key.extend_from_slice(content_type.as_ref().map(|c| c.as_bytes()).unwrap_or_default());
+		key.extend_from_slice(
+			content_type
+				.as_ref()
+				.map(|c| c.as_bytes())
+				.unwrap_or_default(),
+		);
 
 		self.mediaid_file.insert(&key, &[])?;
 
@@ -107,8 +117,9 @@ impl service::media::Data for KeyValueDatabase {
 			})
 			.transpose()?;
 
-		let content_disposition_bytes =
-			parts.next().ok_or_else(|| Error::bad_database("Media ID in db is invalid."))?;
+		let content_disposition_bytes = parts
+			.next()
+			.ok_or_else(|| Error::bad_database("Media ID in db is invalid."))?;
 
 		let content_disposition = if content_disposition_bytes.is_empty() {
 			None
@@ -139,11 +150,26 @@ impl service::media::Data for KeyValueDatabase {
 		let mut value = Vec::<u8>::new();
 		value.extend_from_slice(&timestamp.as_secs().to_be_bytes());
 		value.push(0xFF);
-		value.extend_from_slice(data.title.as_ref().map(String::as_bytes).unwrap_or_default());
+		value.extend_from_slice(
+			data.title
+				.as_ref()
+				.map(String::as_bytes)
+				.unwrap_or_default(),
+		);
 		value.push(0xFF);
-		value.extend_from_slice(data.description.as_ref().map(String::as_bytes).unwrap_or_default());
+		value.extend_from_slice(
+			data.description
+				.as_ref()
+				.map(String::as_bytes)
+				.unwrap_or_default(),
+		);
 		value.push(0xFF);
-		value.extend_from_slice(data.image.as_ref().map(String::as_bytes).unwrap_or_default());
+		value.extend_from_slice(
+			data.image
+				.as_ref()
+				.map(String::as_bytes)
+				.unwrap_or_default(),
+		);
 		value.push(0xFF);
 		value.extend_from_slice(&data.image_size.unwrap_or(0).to_be_bytes());
 		value.push(0xFF);
@@ -166,27 +192,45 @@ impl service::media::Data for KeyValueDatabase {
 			x => x,
 		};*/
 
-		let title = match values.next().and_then(|b| String::from_utf8(b.to_vec()).ok()) {
+		let title = match values
+			.next()
+			.and_then(|b| String::from_utf8(b.to_vec()).ok())
+		{
 			Some(s) if s.is_empty() => None,
 			x => x,
 		};
-		let description = match values.next().and_then(|b| String::from_utf8(b.to_vec()).ok()) {
+		let description = match values
+			.next()
+			.and_then(|b| String::from_utf8(b.to_vec()).ok())
+		{
 			Some(s) if s.is_empty() => None,
 			x => x,
 		};
-		let image = match values.next().and_then(|b| String::from_utf8(b.to_vec()).ok()) {
+		let image = match values
+			.next()
+			.and_then(|b| String::from_utf8(b.to_vec()).ok())
+		{
 			Some(s) if s.is_empty() => None,
 			x => x,
 		};
-		let image_size = match values.next().map(|b| usize::from_be_bytes(b.try_into().unwrap_or_default())) {
+		let image_size = match values
+			.next()
+			.map(|b| usize::from_be_bytes(b.try_into().unwrap_or_default()))
+		{
 			Some(0) => None,
 			x => x,
 		};
-		let image_width = match values.next().map(|b| u32::from_be_bytes(b.try_into().unwrap_or_default())) {
+		let image_width = match values
+			.next()
+			.map(|b| u32::from_be_bytes(b.try_into().unwrap_or_default()))
+		{
 			Some(0) => None,
 			x => x,
 		};
-		let image_height = match values.next().map(|b| u32::from_be_bytes(b.try_into().unwrap_or_default())) {
+		let image_height = match values
+			.next()
+			.map(|b| u32::from_be_bytes(b.try_into().unwrap_or_default()))
+		{
 			Some(0) => None,
 			x => x,
 		};

src/database/key_value/pusher.rs

@@ -53,7 +53,9 @@ impl service::pusher::Data for KeyValueDatabase {
 		Box::new(self.senderkey_pusher.scan_prefix(prefix).map(|(k, _)| {
 			let mut parts = k.splitn(2, |&b| b == 0xFF);
 			let _senderkey = parts.next();
-			let push_key = parts.next().ok_or_else(|| Error::bad_database("Invalid senderkey_pusher in db"))?;
+			let push_key = parts
+				.next()
+				.ok_or_else(|| Error::bad_database("Invalid senderkey_pusher in db"))?;
 			let push_key_string = utils::string_from_bytes(push_key)
 				.map_err(|_| Error::bad_database("Invalid pusher bytes in senderkey_pusher"))?;
 

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."))
+				}),
 		))
 	}
 }

src/database/key_value/sending.rs

@@ -73,7 +73,8 @@ impl service::sending::Data for KeyValueDatabase {
 			batch.push((key.clone(), value.to_owned()));
 			keys.push(key);
 		}
-		self.servernameevent_data.insert_batch(&mut batch.into_iter())?;
+		self.servernameevent_data
+			.insert_batch(&mut batch.into_iter())?;
 		Ok(keys)
 	}
 
@@ -107,13 +108,16 @@ impl service::sending::Data for KeyValueDatabase {
 	}
 
 	fn set_latest_educount(&self, server_name: &ServerName, last_count: u64) -> Result<()> {
-		self.servername_educount.insert(server_name.as_bytes(), &last_count.to_be_bytes())
+		self.servername_educount
+			.insert(server_name.as_bytes(), &last_count.to_be_bytes())
 	}
 
 	fn get_latest_educount(&self, server_name: &ServerName) -> Result<u64> {
-		self.servername_educount.get(server_name.as_bytes())?.map_or(Ok(0), |bytes| {
-			utils::u64_from_bytes(&bytes).map_err(|_| Error::bad_database("Invalid u64 in servername_educount."))
-		})
+		self.servername_educount
+			.get(server_name.as_bytes())?
+			.map_or(Ok(0), |bytes| {
+				utils::u64_from_bytes(&bytes).map_err(|_| Error::bad_database("Invalid u64 in servername_educount."))
+			})
 	}
 }
 
@@ -124,7 +128,9 @@ fn parse_servercurrentevent(key: &[u8], value: Vec<u8>) -> Result<(OutgoingKind,
 		let mut parts = key[1..].splitn(2, |&b| b == 0xFF);
 
 		let server = parts.next().expect("splitn always returns one element");
-		let event = parts.next().ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
+		let event = parts
+			.next()
+			.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
 
 		let server = utils::string_from_bytes(server)
 			.map_err(|_| Error::bad_database("Invalid server bytes in server_currenttransaction"))?;
@@ -146,11 +152,15 @@ fn parse_servercurrentevent(key: &[u8], value: Vec<u8>) -> Result<(OutgoingKind,
 		let user_id =
 			UserId::parse(user_string).map_err(|_| Error::bad_database("Invalid user id in servercurrentevent"))?;
 
-		let pushkey = parts.next().ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
+		let pushkey = parts
+			.next()
+			.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
 		let pushkey_string = utils::string_from_bytes(pushkey)
 			.map_err(|_| Error::bad_database("Invalid pushkey in servercurrentevent"))?;
 
-		let event = parts.next().ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
+		let event = parts
+			.next()
+			.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
 
 		(
 			OutgoingKind::Push(user_id, pushkey_string),
@@ -165,7 +175,9 @@ fn parse_servercurrentevent(key: &[u8], value: Vec<u8>) -> Result<(OutgoingKind,
 		let mut parts = key.splitn(2, |&b| b == 0xFF);
 
 		let server = parts.next().expect("splitn always returns one element");
-		let event = parts.next().ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
+		let event = parts
+			.next()
+			.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?;
 
 		let server = utils::string_from_bytes(server)
 			.map_err(|_| Error::bad_database("Invalid server bytes in server_currenttransaction"))?;

src/database/key_value/uiaa.rs

@@ -9,10 +9,13 @@ impl service::uiaa::Data for KeyValueDatabase {
 	fn set_uiaa_request(
 		&self, user_id: &UserId, device_id: &DeviceId, session: &str, request: &CanonicalJsonValue,
 	) -> Result<()> {
-		self.userdevicesessionid_uiaarequest.write().unwrap().insert(
-			(user_id.to_owned(), device_id.to_owned(), session.to_owned()),
-			request.to_owned(),
-		);
+		self.userdevicesessionid_uiaarequest
+			.write()
+			.unwrap()
+			.insert(
+				(user_id.to_owned(), device_id.to_owned(), session.to_owned()),
+				request.to_owned(),
+			);
 
 		Ok(())
 	}
@@ -40,7 +43,8 @@ impl service::uiaa::Data for KeyValueDatabase {
 				&serde_json::to_vec(&uiaainfo).expect("UiaaInfo::to_vec always works"),
 			)?;
 		} else {
-			self.userdevicesessionid_uiaainfo.remove(&userdevicesessionid)?;
+			self.userdevicesessionid_uiaainfo
+				.remove(&userdevicesessionid)?;
 		}
 
 		Ok(())

src/database/key_value/users.rs

@@ -34,23 +34,27 @@ impl service::users::Data for KeyValueDatabase {
 
 	/// Find out which user an access token belongs to.
 	fn find_from_token(&self, token: &str) -> Result<Option<(OwnedUserId, String)>> {
-		self.token_userdeviceid.get(token.as_bytes())?.map_or(Ok(None), |bytes| {
-			let mut parts = bytes.split(|&b| b == 0xFF);
-			let user_bytes =
-				parts.next().ok_or_else(|| Error::bad_database("User ID in token_userdeviceid is invalid."))?;
-			let device_bytes =
-				parts.next().ok_or_else(|| Error::bad_database("Device ID in token_userdeviceid is invalid."))?;
+		self.token_userdeviceid
+			.get(token.as_bytes())?
+			.map_or(Ok(None), |bytes| {
+				let mut parts = bytes.split(|&b| b == 0xFF);
+				let user_bytes = parts
+					.next()
+					.ok_or_else(|| Error::bad_database("User ID in token_userdeviceid is invalid."))?;
+				let device_bytes = parts
+					.next()
+					.ok_or_else(|| Error::bad_database("Device ID in token_userdeviceid is invalid."))?;
 
-			Ok(Some((
-				UserId::parse(
-					utils::string_from_bytes(user_bytes)
-						.map_err(|_| Error::bad_database("User ID in token_userdeviceid is invalid unicode."))?,
-				)
-				.map_err(|_| Error::bad_database("User ID in token_userdeviceid is invalid."))?,
-				utils::string_from_bytes(device_bytes)
-					.map_err(|_| Error::bad_database("Device ID in token_userdeviceid is invalid."))?,
-			)))
-		})
+				Ok(Some((
+					UserId::parse(
+						utils::string_from_bytes(user_bytes)
+							.map_err(|_| Error::bad_database("User ID in token_userdeviceid is invalid unicode."))?,
+					)
+					.map_err(|_| Error::bad_database("User ID in token_userdeviceid is invalid."))?,
+					utils::string_from_bytes(device_bytes)
+						.map_err(|_| Error::bad_database("Device ID in token_userdeviceid is invalid."))?,
+				)))
+			})
 	}
 
 	/// Returns an iterator over all users on this homeserver.
@@ -79,18 +83,21 @@ impl service::users::Data for KeyValueDatabase {
 
 	/// Returns the password hash for the given user.
 	fn password_hash(&self, user_id: &UserId) -> Result<Option<String>> {
-		self.userid_password.get(user_id.as_bytes())?.map_or(Ok(None), |bytes| {
-			Ok(Some(utils::string_from_bytes(&bytes).map_err(|_| {
-				Error::bad_database("Password hash in db is not valid string.")
-			})?))
-		})
+		self.userid_password
+			.get(user_id.as_bytes())?
+			.map_or(Ok(None), |bytes| {
+				Ok(Some(utils::string_from_bytes(&bytes).map_err(|_| {
+					Error::bad_database("Password hash in db is not valid string.")
+				})?))
+			})
 	}
 
 	/// Hash and set the user's password to the Argon2 hash
 	fn set_password(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
 		if let Some(password) = password {
 			if let Ok(hash) = utils::calculate_password_hash(password) {
-				self.userid_password.insert(user_id.as_bytes(), hash.as_bytes())?;
+				self.userid_password
+					.insert(user_id.as_bytes(), hash.as_bytes())?;
 				Ok(())
 			} else {
 				Err(Error::BadRequest(
@@ -106,18 +113,22 @@ impl service::users::Data for KeyValueDatabase {
 
 	/// Returns the displayname of a user on this homeserver.
 	fn displayname(&self, user_id: &UserId) -> Result<Option<String>> {
-		self.userid_displayname.get(user_id.as_bytes())?.map_or(Ok(None), |bytes| {
-			Ok(Some(
-				utils::string_from_bytes(&bytes).map_err(|_| Error::bad_database("Displayname in db is invalid."))?,
-			))
-		})
+		self.userid_displayname
+			.get(user_id.as_bytes())?
+			.map_or(Ok(None), |bytes| {
+				Ok(Some(
+					utils::string_from_bytes(&bytes)
+						.map_err(|_| Error::bad_database("Displayname in db is invalid."))?,
+				))
+			})
 	}
 
 	/// Sets a new displayname or removes it if displayname is None. You still
 	/// need to nofify all rooms of this change.
 	fn set_displayname(&self, user_id: &UserId, displayname: Option<String>) -> Result<()> {
 		if let Some(displayname) = displayname {
-			self.userid_displayname.insert(user_id.as_bytes(), displayname.as_bytes())?;
+			self.userid_displayname
+				.insert(user_id.as_bytes(), displayname.as_bytes())?;
 		} else {
 			self.userid_displayname.remove(user_id.as_bytes())?;
 		}
@@ -143,7 +154,8 @@ impl service::users::Data for KeyValueDatabase {
 	/// Sets a new avatar_url or removes it if avatar_url is None.
 	fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<OwnedMxcUri>) -> Result<()> {
 		if let Some(avatar_url) = avatar_url {
-			self.userid_avatarurl.insert(user_id.as_bytes(), avatar_url.to_string().as_bytes())?;
+			self.userid_avatarurl
+				.insert(user_id.as_bytes(), avatar_url.to_string().as_bytes())?;
 		} else {
 			self.userid_avatarurl.remove(user_id.as_bytes())?;
 		}
@@ -167,7 +179,8 @@ impl service::users::Data for KeyValueDatabase {
 	/// Sets a new avatar_url or removes it if avatar_url is None.
 	fn set_blurhash(&self, user_id: &UserId, blurhash: Option<String>) -> Result<()> {
 		if let Some(blurhash) = blurhash {
-			self.userid_blurhash.insert(user_id.as_bytes(), blurhash.as_bytes())?;
+			self.userid_blurhash
+				.insert(user_id.as_bytes(), blurhash.as_bytes())?;
 		} else {
 			self.userid_blurhash.remove(user_id.as_bytes())?;
 		}
@@ -190,7 +203,8 @@ impl service::users::Data for KeyValueDatabase {
 		userdeviceid.push(0xFF);
 		userdeviceid.extend_from_slice(device_id.as_bytes());
 
-		self.userid_devicelistversion.increment(user_id.as_bytes())?;
+		self.userid_devicelistversion
+			.increment(user_id.as_bytes())?;
 
 		self.userdeviceid_metadata.insert(
 			&userdeviceid,
@@ -230,7 +244,8 @@ impl service::users::Data for KeyValueDatabase {
 
 		// TODO: Remove onetimekeys
 
-		self.userid_devicelistversion.increment(user_id.as_bytes())?;
+		self.userid_devicelistversion
+			.increment(user_id.as_bytes())?;
 
 		self.userdeviceid_metadata.remove(&userdeviceid)?;
 
@@ -242,16 +257,20 @@ impl service::users::Data for KeyValueDatabase {
 		let mut prefix = user_id.as_bytes().to_vec();
 		prefix.push(0xFF);
 		// All devices have metadata
-		Box::new(self.userdeviceid_metadata.scan_prefix(prefix).map(|(bytes, _)| {
-			Ok(utils::string_from_bytes(
-				bytes
-					.rsplit(|&b| b == 0xFF)
-					.next()
-					.ok_or_else(|| Error::bad_database("UserDevice ID in db is invalid."))?,
-			)
-			.map_err(|_| Error::bad_database("Device ID in userdeviceid_metadata is invalid."))?
-			.into())
-		}))
+		Box::new(
+			self.userdeviceid_metadata
+				.scan_prefix(prefix)
+				.map(|(bytes, _)| {
+					Ok(utils::string_from_bytes(
+						bytes
+							.rsplit(|&b| b == 0xFF)
+							.next()
+							.ok_or_else(|| Error::bad_database("UserDevice ID in db is invalid."))?,
+					)
+					.map_err(|_| Error::bad_database("Device ID in userdeviceid_metadata is invalid."))?
+					.into())
+				}),
+		)
 	}
 
 	/// Replaces the access token of one device.
@@ -278,8 +297,10 @@ impl service::users::Data for KeyValueDatabase {
 		}
 
 		// Assign token to user device combination
-		self.userdeviceid_token.insert(&userdeviceid, token.as_bytes())?;
-		self.token_userdeviceid.insert(token.as_bytes(), &userdeviceid)?;
+		self.userdeviceid_token
+			.insert(&userdeviceid, token.as_bytes())?;
+		self.token_userdeviceid
+			.insert(token.as_bytes(), &userdeviceid)?;
 
 		Ok(())
 	}
@@ -310,7 +331,9 @@ impl service::users::Data for KeyValueDatabase {
 		// TODO: Use DeviceKeyId::to_string when it's available (and update everything,
 		// because there are no wrapping quotation marks anymore)
 		key.extend_from_slice(
-			serde_json::to_string(one_time_key_key).expect("DeviceKeyId::to_string always works").as_bytes(),
+			serde_json::to_string(one_time_key_key)
+				.expect("DeviceKeyId::to_string always works")
+				.as_bytes(),
 		);
 
 		self.onetimekeyid_onetimekeys.insert(
@@ -318,16 +341,19 @@ impl service::users::Data for KeyValueDatabase {
 			&serde_json::to_vec(&one_time_key_value).expect("OneTimeKey::to_vec always works"),
 		)?;
 
-		self.userid_lastonetimekeyupdate.insert(user_id.as_bytes(), &services().globals.next_count()?.to_be_bytes())?;
+		self.userid_lastonetimekeyupdate
+			.insert(user_id.as_bytes(), &services().globals.next_count()?.to_be_bytes())?;
 
 		Ok(())
 	}
 
 	fn last_one_time_keys_update(&self, user_id: &UserId) -> Result<u64> {
-		self.userid_lastonetimekeyupdate.get(user_id.as_bytes())?.map_or(Ok(0), |bytes| {
-			utils::u64_from_bytes(&bytes)
-				.map_err(|_| Error::bad_database("Count in roomid_lastroomactiveupdate is invalid."))
-		})
+		self.userid_lastonetimekeyupdate
+			.get(user_id.as_bytes())?
+			.map_or(Ok(0), |bytes| {
+				utils::u64_from_bytes(&bytes)
+					.map_err(|_| Error::bad_database("Count in roomid_lastroomactiveupdate is invalid."))
+			})
 	}
 
 	fn take_one_time_key(
@@ -341,7 +367,8 @@ impl service::users::Data for KeyValueDatabase {
 		prefix.extend_from_slice(key_algorithm.as_ref().as_bytes());
 		prefix.push(b':');
 
-		self.userid_lastonetimekeyupdate.insert(user_id.as_bytes(), &services().globals.next_count()?.to_be_bytes())?;
+		self.userid_lastonetimekeyupdate
+			.insert(user_id.as_bytes(), &services().globals.next_count()?.to_be_bytes())?;
 
 		self.onetimekeyid_onetimekeys
 			.scan_prefix(prefix)
@@ -372,18 +399,21 @@ impl service::users::Data for KeyValueDatabase {
 
 		let mut counts = BTreeMap::new();
 
-		for algorithm in self.onetimekeyid_onetimekeys.scan_prefix(userdeviceid).map(|(bytes, _)| {
-			Ok::<_, Error>(
-				serde_json::from_slice::<OwnedDeviceKeyId>(
-					bytes
-						.rsplit(|&b| b == 0xFF)
-						.next()
-						.ok_or_else(|| Error::bad_database("OneTimeKey ID in db is invalid."))?,
+		for algorithm in self
+			.onetimekeyid_onetimekeys
+			.scan_prefix(userdeviceid)
+			.map(|(bytes, _)| {
+				Ok::<_, Error>(
+					serde_json::from_slice::<OwnedDeviceKeyId>(
+						bytes
+							.rsplit(|&b| b == 0xFF)
+							.next()
+							.ok_or_else(|| Error::bad_database("OneTimeKey ID in db is invalid."))?,
+					)
+					.map_err(|_| Error::bad_database("DeviceKeyId in db is invalid."))?
+					.algorithm(),
 				)
-				.map_err(|_| Error::bad_database("DeviceKeyId in db is invalid."))?
-				.algorithm(),
-			)
-		}) {
+			}) {
 			*counts.entry(algorithm?).or_default() += UInt::from(1_u32);
 		}
 
@@ -415,9 +445,11 @@ impl service::users::Data for KeyValueDatabase {
 
 		let (master_key_key, _) = self.parse_master_key(user_id, master_key)?;
 
-		self.keyid_key.insert(&master_key_key, master_key.json().get().as_bytes())?;
+		self.keyid_key
+			.insert(&master_key_key, master_key.json().get().as_bytes())?;
 
-		self.userid_masterkeyid.insert(user_id.as_bytes(), &master_key_key)?;
+		self.userid_masterkeyid
+			.insert(user_id.as_bytes(), &master_key_key)?;
 
 		// Self-signing key
 		if let Some(self_signing_key) = self_signing_key {
@@ -441,9 +473,11 @@ impl service::users::Data for KeyValueDatabase {
 			let mut self_signing_key_key = prefix.clone();
 			self_signing_key_key.extend_from_slice(self_signing_key_id.as_bytes());
 
-			self.keyid_key.insert(&self_signing_key_key, self_signing_key.json().get().as_bytes())?;
+			self.keyid_key
+				.insert(&self_signing_key_key, self_signing_key.json().get().as_bytes())?;
 
-			self.userid_selfsigningkeyid.insert(user_id.as_bytes(), &self_signing_key_key)?;
+			self.userid_selfsigningkeyid
+				.insert(user_id.as_bytes(), &self_signing_key_key)?;
 		}
 
 		// User-signing key
@@ -468,9 +502,11 @@ impl service::users::Data for KeyValueDatabase {
 			let mut user_signing_key_key = prefix;
 			user_signing_key_key.extend_from_slice(user_signing_key_id.as_bytes());
 
-			self.keyid_key.insert(&user_signing_key_key, user_signing_key.json().get().as_bytes())?;
+			self.keyid_key
+				.insert(&user_signing_key_key, user_signing_key.json().get().as_bytes())?;
 
-			self.userid_usersigningkeyid.insert(user_id.as_bytes(), &user_signing_key_key)?;
+			self.userid_usersigningkeyid
+				.insert(user_id.as_bytes(), &user_signing_key_key)?;
 		}
 
 		if notify {
@@ -559,9 +595,18 @@ impl service::users::Data for KeyValueDatabase {
 
 	fn mark_device_key_update(&self, user_id: &UserId) -> Result<()> {
 		let count = services().globals.next_count()?.to_be_bytes();
-		for room_id in services().rooms.state_cache.rooms_joined(user_id).filter_map(Result::ok) {
+		for room_id in services()
+			.rooms
+			.state_cache
+			.rooms_joined(user_id)
+			.filter_map(Result::ok)
+		{
 			// Don't send key updates to unencrypted rooms
-			if services().rooms.state_accessor.room_state_get(&room_id, &StateEventType::RoomEncryption, "")?.is_none()
+			if services()
+				.rooms
+				.state_accessor
+				.room_state_get(&room_id, &StateEventType::RoomEncryption, "")?
+				.is_none()
 			{
 				continue;
 			}
@@ -599,11 +644,13 @@ impl service::users::Data for KeyValueDatabase {
 		let mut prefix = user_id.as_bytes().to_vec();
 		prefix.push(0xFF);
 
-		let master_key =
-			master_key.deserialize().map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid master key"))?;
+		let master_key = master_key
+			.deserialize()
+			.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid master key"))?;
 		let mut master_key_ids = master_key.keys.values();
-		let master_key_id =
-			master_key_ids.next().ok_or(Error::BadRequest(ErrorKind::InvalidParam, "Master key contained no key."))?;
+		let master_key_id = master_key_ids
+			.next()
+			.ok_or(Error::BadRequest(ErrorKind::InvalidParam, "Master key contained no key."))?;
 		if master_key_ids.next().is_some() {
 			return Err(Error::BadRequest(
 				ErrorKind::InvalidParam,
@@ -646,14 +693,16 @@ impl service::users::Data for KeyValueDatabase {
 	}
 
 	fn get_user_signing_key(&self, user_id: &UserId) -> Result<Option<Raw<CrossSigningKey>>> {
-		self.userid_usersigningkeyid.get(user_id.as_bytes())?.map_or(Ok(None), |key| {
-			self.keyid_key.get(&key)?.map_or(Ok(None), |bytes| {
-				Ok(Some(
-					serde_json::from_slice(&bytes)
-						.map_err(|_| Error::bad_database("CrossSigningKey in db is invalid."))?,
-				))
+		self.userid_usersigningkeyid
+			.get(user_id.as_bytes())?
+			.map_or(Ok(None), |key| {
+				self.keyid_key.get(&key)?.map_or(Ok(None), |bytes| {
+					Ok(Some(
+						serde_json::from_slice(&bytes)
+							.map_err(|_| Error::bad_database("CrossSigningKey in db is invalid."))?,
+					))
+				})
 			})
-		})
 	}
 
 	fn add_to_device_event(
@@ -743,7 +792,8 @@ impl service::users::Data for KeyValueDatabase {
 			));
 		}
 
-		self.userid_devicelistversion.increment(user_id.as_bytes())?;
+		self.userid_devicelistversion
+			.increment(user_id.as_bytes())?;
 
 		self.userdeviceid_metadata.insert(
 			&userdeviceid,
@@ -759,27 +809,37 @@ impl service::users::Data for KeyValueDatabase {
 		userdeviceid.push(0xFF);
 		userdeviceid.extend_from_slice(device_id.as_bytes());
 
-		self.userdeviceid_metadata.get(&userdeviceid)?.map_or(Ok(None), |bytes| {
-			Ok(Some(serde_json::from_slice(&bytes).map_err(|_| {
-				Error::bad_database("Metadata in userdeviceid_metadata is invalid.")
-			})?))
-		})
+		self.userdeviceid_metadata
+			.get(&userdeviceid)?
+			.map_or(Ok(None), |bytes| {
+				Ok(Some(serde_json::from_slice(&bytes).map_err(|_| {
+					Error::bad_database("Metadata in userdeviceid_metadata is invalid.")
+				})?))
+			})
 	}
 
 	fn get_devicelist_version(&self, user_id: &UserId) -> Result<Option<u64>> {
-		self.userid_devicelistversion.get(user_id.as_bytes())?.map_or(Ok(None), |bytes| {
-			utils::u64_from_bytes(&bytes).map_err(|_| Error::bad_database("Invalid devicelistversion in db.")).map(Some)
-		})
+		self.userid_devicelistversion
+			.get(user_id.as_bytes())?
+			.map_or(Ok(None), |bytes| {
+				utils::u64_from_bytes(&bytes)
+					.map_err(|_| Error::bad_database("Invalid devicelistversion in db."))
+					.map(Some)
+			})
 	}
 
 	fn all_devices_metadata<'a>(&'a self, user_id: &UserId) -> Box<dyn Iterator<Item = Result<Device>> + 'a> {
 		let mut key = user_id.as_bytes().to_vec();
 		key.push(0xFF);
 
-		Box::new(self.userdeviceid_metadata.scan_prefix(key).map(|(_, bytes)| {
-			serde_json::from_slice::<Device>(&bytes)
-				.map_err(|_| Error::bad_database("Device in userdeviceid_metadata is invalid."))
-		}))
+		Box::new(
+			self.userdeviceid_metadata
+				.scan_prefix(key)
+				.map(|(_, bytes)| {
+					serde_json::from_slice::<Device>(&bytes)
+						.map_err(|_| Error::bad_database("Device in userdeviceid_metadata is invalid."))
+				}),
+		)
 	}
 
 	/// Creates a new sync filter. Returns the filter id.
@@ -790,7 +850,8 @@ impl service::users::Data for KeyValueDatabase {
 		key.push(0xFF);
 		key.extend_from_slice(filter_id.as_bytes());
 
-		self.userfilterid_filter.insert(&key, &serde_json::to_vec(&filter).expect("filter is valid json"))?;
+		self.userfilterid_filter
+			.insert(&key, &serde_json::to_vec(&filter).expect("filter is valid json"))?;
 
 		Ok(filter_id)
 	}

src/database/mod.rs

@@ -375,7 +375,10 @@ impl KeyValueDatabase {
 			server_signingkeys: builder.open_tree("server_signingkeys")?,
 
 			pdu_cache: Mutex::new(LruCache::new(
-				config.pdu_cache_capacity.try_into().expect("pdu cache capacity fits into usize"),
+				config
+					.pdu_cache_capacity
+					.try_into()
+					.expect("pdu cache capacity fits into usize"),
 			)),
 			auth_chain_cache: Mutex::new(LruCache::new((100_000.0 * config.conduit_cache_capacity_modifier) as usize)),
 			shorteventid_cache: Mutex::new(LruCache::new(
@@ -457,8 +460,11 @@ impl KeyValueDatabase {
 						.argon
 						.hash_password(b"", &salt)
 						.expect("our own password to be properly hashed");
-					let empty_hashed_password =
-						services().globals.argon.verify_password(&password, &empty_pass).is_ok();
+					let empty_hashed_password = services()
+						.globals
+						.argon
+						.verify_password(&password, &empty_pass)
+						.is_ok();
 
 					if empty_hashed_password {
 						db.userid_password.insert(&userid, b"")?;
@@ -526,7 +532,8 @@ impl KeyValueDatabase {
 					key.push(0xFF);
 					key.extend_from_slice(event_type);
 
-					db.roomusertype_roomuserdataid.insert(&key, &roomuserdataid)?;
+					db.roomusertype_roomuserdataid
+						.insert(&key, &roomuserdataid)?;
 				}
 
 				services().globals.bump_database_version(5)?;
@@ -565,16 +572,24 @@ impl KeyValueDatabase {
 					let states_parents = last_roomsstatehash.map_or_else(
 						|| Ok(Vec::new()),
 						|&last_roomsstatehash| {
-							services().rooms.state_compressor.load_shortstatehash_info(last_roomsstatehash)
+							services()
+								.rooms
+								.state_compressor
+								.load_shortstatehash_info(last_roomsstatehash)
 						},
 					)?;
 
 					let (statediffnew, statediffremoved) = if let Some(parent_stateinfo) = states_parents.last() {
-						let statediffnew =
-							current_state.difference(&parent_stateinfo.1).copied().collect::<HashSet<_>>();
+						let statediffnew = current_state
+							.difference(&parent_stateinfo.1)
+							.copied()
+							.collect::<HashSet<_>>();
 
-						let statediffremoved =
-							parent_stateinfo.1.difference(&current_state).copied().collect::<HashSet<_>>();
+						let statediffremoved = parent_stateinfo
+							.1
+							.difference(&current_state)
+							.copied()
+							.collect::<HashSet<_>>();
 
 						(statediffnew, statediffremoved)
 					} else {
@@ -634,7 +649,12 @@ impl KeyValueDatabase {
 						let event_id = db.shorteventid_eventid.get(&seventid).unwrap().unwrap();
 						let string = utils::string_from_bytes(&event_id).unwrap();
 						let event_id = <&EventId>::try_from(string.as_str()).unwrap();
-						let pdu = services().rooms.timeline.get_pdu(event_id).unwrap().unwrap();
+						let pdu = services()
+							.rooms
+							.timeline
+							.get_pdu(event_id)
+							.unwrap()
+							.unwrap();
 
 						if Some(&pdu.room_id) != current_room.as_ref() {
 							current_room = Some(pdu.room_id.clone());
@@ -676,7 +696,11 @@ impl KeyValueDatabase {
 					let room_id = parts.next().unwrap();
 					let count = parts.next().unwrap();
 
-					let short_room_id = db.roomid_shortroomid.get(room_id).unwrap().expect("shortroomid should exist");
+					let short_room_id = db
+						.roomid_shortroomid
+						.get(room_id)
+						.unwrap()
+						.expect("shortroomid should exist");
 
 					let mut new_key = short_room_id;
 					new_key.extend_from_slice(count);
@@ -694,7 +718,11 @@ impl KeyValueDatabase {
 					let room_id = parts.next().unwrap();
 					let count = parts.next().unwrap();
 
-					let short_room_id = db.roomid_shortroomid.get(room_id).unwrap().expect("shortroomid should exist");
+					let short_room_id = db
+						.roomid_shortroomid
+						.get(room_id)
+						.unwrap()
+						.expect("shortroomid should exist");
 
 					let mut new_value = short_room_id;
 					new_value.extend_from_slice(count);
@@ -724,8 +752,11 @@ impl KeyValueDatabase {
 						let _pdu_id_room = parts.next().unwrap();
 						let pdu_id_count = parts.next().unwrap();
 
-						let short_room_id =
-							db.roomid_shortroomid.get(room_id).unwrap().expect("shortroomid should exist");
+						let short_room_id = db
+							.roomid_shortroomid
+							.get(room_id)
+							.unwrap()
+							.expect("shortroomid should exist");
 						let mut new_key = short_room_id;
 						new_key.extend_from_slice(word);
 						new_key.push(0xFF);
@@ -765,7 +796,8 @@ impl KeyValueDatabase {
 			if services().globals.database_version()? < 10 {
 				// Add other direction for shortstatekeys
 				for (statekey, shortstatekey) in db.statekey_shortstatekey.iter() {
-					db.shortstatekey_statekey.insert(&shortstatekey, &statekey)?;
+					db.shortstatekey_statekey
+						.insert(&shortstatekey, &statekey)?;
 				}
 
 				// Force E2EE device list updates so we can send them over federation
@@ -779,7 +811,9 @@ impl KeyValueDatabase {
 			}
 
 			if services().globals.database_version()? < 11 {
-				db.db.open_tree("userdevicesessionid_uiaarequest")?.clear()?;
+				db.db
+					.open_tree("userdevicesessionid_uiaarequest")?
+					.clear()?;
 				services().globals.bump_database_version(11)?;
 
 				warn!("Migration: 10 -> 11 finished");
@@ -813,7 +847,9 @@ impl KeyValueDatabase {
 						if rule.is_some() {
 							let mut rule = rule.unwrap().clone();
 							content_rule_transformation[1].clone_into(&mut rule.rule_id);
-							rules_list.content.shift_remove(content_rule_transformation[0]);
+							rules_list
+								.content
+								.shift_remove(content_rule_transformation[0]);
 							rules_list.content.insert(rule);
 						}
 					}
@@ -874,7 +910,10 @@ impl KeyValueDatabase {
 					let mut account_data = serde_json::from_str::<PushRulesEvent>(raw_rules_list.get()).unwrap();
 
 					let user_default_rules = Ruleset::server_default(&user);
-					account_data.content.global.update_with_server_default(user_default_rules);
+					account_data
+						.content
+						.global
+						.update_with_server_default(user_default_rules);
 
 					services().account_data.update(
 						None,
@@ -936,7 +975,10 @@ impl KeyValueDatabase {
 							warn!(
 								"User {} matches the following forbidden username patterns: {}",
 								user_id.to_string(),
-								matches.into_iter().map(|x| &patterns.patterns()[x]).join(", ")
+								matches
+									.into_iter()
+									.map(|x| &patterns.patterns()[x])
+									.join(", ")
 							);
 						}
 					}
@@ -957,7 +999,10 @@ impl KeyValueDatabase {
 									"Room with alias {} ({}) matches the following forbidden room name patterns: {}",
 									room_alias,
 									&room_id,
-									matches.into_iter().map(|x| &patterns.patterns()[x]).join(", ")
+									matches
+										.into_iter()
+										.map(|x| &patterns.patterns()[x])
+										.join(", ")
 								);
 							}
 						}
@@ -971,7 +1016,9 @@ impl KeyValueDatabase {
 				latest_database_version
 			);
 		} else {
-			services().globals.bump_database_version(latest_database_version)?;
+			services()
+				.globals
+				.bump_database_version(latest_database_version)?;
 
 			// Create the admin room and server user on first run
 			services().admin.create_admin_room().await?;
@@ -993,10 +1040,12 @@ impl KeyValueDatabase {
 						"The Conduit account emergency password is set! Please unset it as soon as you finish admin \
 						 account recovery!"
 					);
-					services().admin.send_message(RoomMessageEventContent::text_plain(
-						"The Conduit account emergency password is set! Please unset it as soon as you finish admin \
-						 account recovery!",
-					));
+					services()
+						.admin
+						.send_message(RoomMessageEventContent::text_plain(
+							"The Conduit account emergency password is set! Please unset it as soon as you finish \
+							 admin account recovery!",
+						));
 				}
 			},
 			Err(e) => {
@@ -1047,8 +1096,13 @@ impl KeyValueDatabase {
 	}
 
 	async fn try_handle_updates() -> Result<()> {
-		let response =
-			services().globals.client.default.get("https://pupbrain.dev/check-for-updates/stable").send().await?;
+		let response = services()
+			.globals
+			.client
+			.default
+			.get("https://pupbrain.dev/check-for-updates/stable")
+			.send()
+			.await?;
 
 		let response = serde_json::from_str::<CheckForUpdatesResponse>(&response.text().await?).map_err(|e| {
 			error!("Bad check for updates response: {e}");
@@ -1060,13 +1114,17 @@ impl KeyValueDatabase {
 			last_update_id = last_update_id.max(update.id);
 			if update.id > services().globals.last_check_for_updates_id()? {
 				error!("{}", update.message);
-				services().admin.send_message(RoomMessageEventContent::text_plain(format!(
-					"@room: the following is a message from the conduwuit puppy. it was sent on '{}':\n\n{}",
-					update.date, update.message
-				)));
+				services()
+					.admin
+					.send_message(RoomMessageEventContent::text_plain(format!(
+						"@room: the following is a message from the conduwuit puppy. it was sent on '{}':\n\n{}",
+						update.date, update.message
+					)));
 			}
 		}
-		services().globals.update_check_for_updates_id(last_update_id)?;
+		services()
+			.globals
+			.update_check_for_updates_id(last_update_id)?;
 
 		Ok(())
 	}
@@ -1138,7 +1196,9 @@ fn set_emergency_access() -> Result<bool> {
 	let conduit_user = UserId::parse_with_server_name("conduit", services().globals.server_name())
 		.expect("@conduit:server_name is a valid UserId");
 
-	services().users.set_password(&conduit_user, services().globals.emergency_password().as_deref())?;
+	services()
+		.users
+		.set_password(&conduit_user, services().globals.emergency_password().as_deref())?;
 
 	let (ruleset, res) = match services().globals.emergency_password() {
 		Some(_) => (Ruleset::server_default(&conduit_user), Ok(true)),