fix: some compile time errors

Only 174 errors left!

src/database/abstraction.rs

@@ -30,7 +30,7 @@ pub trait KeyValueDatabaseEngine: Send + Sync {
     fn open(config: &Config) -> Result<Self>
     where
         Self: Sized;
-    fn open_tree(&self, name: &'static str) -> Result<Arc<dyn Tree>>;
+    fn open_tree(&self, name: &'static str) -> Result<Arc<dyn KvTree>>;
     fn flush(&self) -> Result<()>;
     fn cleanup(&self) -> Result<()> {
         Ok(())
@@ -40,7 +40,7 @@ pub trait KeyValueDatabaseEngine: Send + Sync {
     }
 }
 
-pub trait KeyValueTree: Send + Sync {
+pub trait KvTree: Send + Sync {
     fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>>;
 
     fn insert(&self, key: &[u8], value: &[u8]) -> Result<()>;

src/database/abstraction/rocksdb.rs

@@ -1,4 +1,4 @@
-use super::{super::Config, watchers::Watchers, DatabaseEngine, Tree};
+use super::{super::Config, watchers::Watchers, KvTree, KeyValueDatabaseEngine};
 use crate::{utils, Result};
 use std::{
     future::Future,
@@ -51,7 +51,7 @@ fn db_options(max_open_files: i32, rocksdb_cache: &rocksdb::Cache) -> rocksdb::O
     db_opts
 }
 
-impl DatabaseEngine for Arc<Engine> {
+impl KeyValueDatabaseEngine for Arc<Engine> {
     fn open(config: &Config) -> Result<Self> {
         let cache_capacity_bytes = (config.db_cache_capacity_mb * 1024.0 * 1024.0) as usize;
         let rocksdb_cache = rocksdb::Cache::new_lru_cache(cache_capacity_bytes).unwrap();
@@ -83,7 +83,7 @@ impl DatabaseEngine for Arc<Engine> {
         }))
     }
 
-    fn open_tree(&self, name: &'static str) -> Result<Arc<dyn Tree>> {
+    fn open_tree(&self, name: &'static str) -> Result<Arc<dyn KvTree>> {
         if !self.old_cfs.contains(&name.to_owned()) {
             // Create if it didn't exist
             let _ = self
@@ -129,7 +129,7 @@ impl RocksDbEngineTree<'_> {
     }
 }
 
-impl Tree for RocksDbEngineTree<'_> {
+impl KvTree for RocksDbEngineTree<'_> {
     fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
         Ok(self.db.rocks.get_cf(&self.cf(), key)?)
     }

src/database/abstraction/sqlite.rs

@@ -1,4 +1,4 @@
-use super::{watchers::Watchers, DatabaseEngine, Tree};
+use super::{watchers::Watchers, KeyValueDatabaseEngine, KvTree};
 use crate::{database::Config, Result};
 use parking_lot::{Mutex, MutexGuard};
 use rusqlite::{Connection, DatabaseName::Main, OptionalExtension};
@@ -80,7 +80,7 @@ impl Engine {
     }
 }
 
-impl DatabaseEngine for Arc<Engine> {
+impl KeyValueDatabaseEngine for Arc<Engine> {
     fn open(config: &Config) -> Result<Self> {
         let path = Path::new(&config.database_path).join("conduit.db");
 
@@ -105,7 +105,7 @@ impl DatabaseEngine for Arc<Engine> {
         Ok(arc)
     }
 
-    fn open_tree(&self, name: &str) -> Result<Arc<dyn Tree>> {
+    fn open_tree(&self, name: &str) -> Result<Arc<dyn KvTree>> {
         self.write_lock().execute(&format!("CREATE TABLE IF NOT EXISTS {} ( \"key\" BLOB PRIMARY KEY, \"value\" BLOB NOT NULL )", name), [])?;
 
         Ok(Arc::new(SqliteTable {
@@ -189,7 +189,7 @@ impl SqliteTable {
     }
 }
 
-impl Tree for SqliteTable {
+impl KvTree for SqliteTable {
     fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
         self.get_with_guard(self.engine.read_lock(), key)
     }

src/database/key_value/appservice.rs

@@ -1,6 +1,8 @@
+use crate::{database::KeyValueDatabase, service, utils, Error};
+
 impl service::appservice::Data for KeyValueDatabase {
     /// Registers an appservice and returns the ID to the caller
-    pub fn register_appservice(&self, yaml: serde_yaml::Value) -> Result<String> {
+    fn register_appservice(&self, yaml: serde_yaml::Value) -> Result<String> {
         // TODO: Rumaify
         let id = yaml.get("id").unwrap().as_str().unwrap();
         self.id_appserviceregistrations.insert(

src/database/key_value/mod.rs

@@ -1,13 +1,13 @@
-mod account_data;
-mod admin;
+//mod account_data;
+//mod admin;
 mod appservice;
-mod globals;
-mod key_backups;
-mod media;
-mod pdu;
+//mod globals;
+//mod key_backups;
+//mod media;
+//mod pdu;
 mod pusher;
 mod rooms;
-mod sending;
+//mod sending;
 mod transaction_ids;
 mod uiaa;
 mod users;

src/database/key_value/pusher.rs

@@ -1,3 +1,7 @@
+use ruma::{UserId, api::client::push::{set_pusher, get_pushers}};
+
+use crate::{service, database::KeyValueDatabase, Error};
+
 impl service::pusher::Data for KeyValueDatabase {
     fn set_pusher(&self, sender: &UserId, pusher: set_pusher::v3::Pusher) -> Result<()> {
         let mut key = sender.as_bytes().to_vec();

src/database/key_value/rooms/alias.rs

@@ -1,4 +1,8 @@
-impl service::room::alias::Data for KeyValueDatabase {
+use ruma::{RoomId, RoomAliasId, api::client::error::ErrorKind};
+
+use crate::{service, database::KeyValueDatabase, utils, Error, services};
+
+impl service::rooms::alias::Data for KeyValueDatabase {
     fn set_alias(
         &self,
         alias: &RoomAliasId,
@@ -8,7 +12,7 @@ impl service::room::alias::Data for KeyValueDatabase {
             .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(&globals.next_count()?.to_be_bytes());
+        aliasid.extend_from_slice(&services().globals.next_count()?.to_be_bytes());
         self.aliasid_alias.insert(&aliasid, &*alias.as_bytes())?;
         Ok(())
     }

src/database/key_value/rooms/directory.rs

@@ -1,10 +1,14 @@
-impl service::room::directory::Data for KeyValueDatabase {
+use ruma::RoomId;
+
+use crate::{service, database::KeyValueDatabase, utils, Error};
+
+impl service::rooms::directory::Data for KeyValueDatabase {
     fn set_public(&self, room_id: &RoomId) -> Result<()> {
-        self.publicroomids.insert(room_id.as_bytes(), &[])?;
+        self.publicroomids.insert(room_id.as_bytes(), &[])
     }
 
     fn set_not_public(&self, room_id: &RoomId) -> Result<()> {
-        self.publicroomids.remove(room_id.as_bytes())?;
+        self.publicroomids.remove(room_id.as_bytes())
     }
 
     fn is_public_room(&self, room_id: &RoomId) -> Result<bool> {

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

@@ -0,0 +1,3 @@
+mod presence;
+mod typing;
+mod read_receipt;

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

@@ -1,4 +1,10 @@
-impl service::room::edus::presence::Data for KeyValueDatabase {
+use std::collections::HashMap;
+
+use ruma::{UserId, RoomId, events::presence::PresenceEvent, presence::PresenceState, UInt};
+
+use crate::{service, database::KeyValueDatabase, utils, Error, services};
+
+impl service::rooms::edus::presence::Data for KeyValueDatabase {
     fn update_presence(
         &self,
         user_id: &UserId,
@@ -7,7 +13,7 @@ impl service::room::edus::presence::Data for KeyValueDatabase {
     ) -> Result<()> {
         // TODO: Remove old entry? Or maybe just wipe completely from time to time?
 
-        let count = globals.next_count()?.to_be_bytes();
+        let count = services().globals.next_count()?.to_be_bytes();
 
         let mut presence_id = room_id.as_bytes().to_vec();
         presence_id.push(0xff);
@@ -101,6 +107,7 @@ impl service::room::edus::presence::Data for KeyValueDatabase {
         Ok(hashmap)
     }
 
+    /*
     fn presence_maintain(&self, db: Arc<TokioRwLock<Database>>) {
         // TODO @M0dEx: move this to a timed tasks module
         tokio::spawn(async move {
@@ -117,6 +124,7 @@ impl service::room::edus::presence::Data for KeyValueDatabase {
             }
         });
     }
+    */
 }
 
 fn parse_presence_event(bytes: &[u8]) -> Result<PresenceEvent> {

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

@@ -1,4 +1,10 @@
-impl service::room::edus::read_receipt::Data for KeyValueDatabase {
+use std::mem;
+
+use ruma::{UserId, RoomId, events::receipt::ReceiptEvent, serde::Raw, signatures::CanonicalJsonObject};
+
+use crate::{database::KeyValueDatabase, service, utils, Error, services};
+
+impl service::rooms::edus::read_receipt::Data for KeyValueDatabase {
     fn readreceipt_update(
         &self,
         user_id: &UserId,
@@ -28,7 +34,7 @@ impl service::room::edus::read_receipt::Data for KeyValueDatabase {
         }
 
         let mut room_latest_id = prefix;
-        room_latest_id.extend_from_slice(&globals.next_count()?.to_be_bytes());
+        room_latest_id.extend_from_slice(&services().globals.next_count()?.to_be_bytes());
         room_latest_id.push(0xff);
         room_latest_id.extend_from_slice(user_id.as_bytes());
 
@@ -40,7 +46,7 @@ impl service::room::edus::read_receipt::Data for KeyValueDatabase {
         Ok(())
     }
 
-    pub fn readreceipts_since<'a>(
+    fn readreceipts_since<'a>(
         &'a self,
         room_id: &RoomId,
         since: u64,
@@ -102,7 +108,7 @@ impl service::room::edus::read_receipt::Data for KeyValueDatabase {
             .insert(&key, &count.to_be_bytes())?;
 
         self.roomuserid_lastprivatereadupdate
-            .insert(&key, &globals.next_count()?.to_be_bytes())?;
+            .insert(&key, &services().globals.next_count()?.to_be_bytes())
     }
 
     fn private_read_get(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {

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

@@ -1,15 +1,20 @@
-impl service::room::edus::typing::Data for KeyValueDatabase {
+use std::collections::HashSet;
+
+use ruma::{UserId, RoomId};
+
+use crate::{database::KeyValueDatabase, service, utils, Error, services};
+
+impl service::rooms::edus::typing::Data for KeyValueDatabase {
     fn typing_add(
         &self,
         user_id: &UserId,
         room_id: &RoomId,
         timeout: u64,
-        globals: &super::super::globals::Globals,
     ) -> Result<()> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
-        let count = globals.next_count()?.to_be_bytes();
+        let count = services().globals.next_count()?.to_be_bytes();
 
         let mut room_typing_id = prefix;
         room_typing_id.extend_from_slice(&timeout.to_be_bytes());
@@ -49,7 +54,7 @@ impl service::room::edus::typing::Data for KeyValueDatabase {
 
         if found_outdated {
             self.roomid_lasttypingupdate
-                .insert(room_id.as_bytes(), &globals.next_count()?.to_be_bytes())?;
+                .insert(room_id.as_bytes(), &services().globals.next_count()?.to_be_bytes())?;
         }
 
         Ok(())

src/database/key_value/rooms/lazy_load.rs

@@ -1,4 +1,8 @@
-impl service::room::lazy_load::Data for KeyValueDatabase {
+use ruma::{UserId, DeviceId, RoomId};
+
+use crate::{service, database::KeyValueDatabase};
+
+impl service::rooms::lazy_loading::Data for KeyValueDatabase {
     fn lazy_load_was_sent_before(
         &self,
         user_id: &UserId,

src/database/key_value/rooms/metadata.rs

@@ -1,4 +1,8 @@
-impl service::room::metadata::Data for KeyValueDatabase {
+use ruma::RoomId;
+
+use crate::{service, database::KeyValueDatabase};
+
+impl service::rooms::metadata::Data for KeyValueDatabase {
     fn exists(&self, room_id: &RoomId) -> Result<bool> {
         let prefix = match self.get_shortroomid(room_id)? {
             Some(b) => b.to_be_bytes().to_vec(),

src/database/key_value/rooms/mod.rs

@@ -1,14 +1,13 @@
-mod state;
 mod alias;
 mod directory;
 mod edus;
-mod event_handler;
-mod lazy_loading;
+//mod event_handler;
+mod lazy_load;
 mod metadata;
 mod outlier;
 mod pdu_metadata;
 mod search;
-mod short;
+//mod short;
 mod state;
 mod state_accessor;
 mod state_cache;

src/database/key_value/rooms/outlier.rs

@@ -1,4 +1,8 @@
-impl service::room::outlier::Data for KeyValueDatabase {
+use ruma::{EventId, signatures::CanonicalJsonObject};
+
+use crate::{service, database::KeyValueDatabase, PduEvent, Error};
+
+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())?

src/database/key_value/rooms/pdu_metadata.rs

@@ -1,4 +1,10 @@
-impl service::room::pdu_metadata::Data for KeyValueDatabase {
+use std::sync::Arc;
+
+use ruma::{RoomId, EventId};
+
+use crate::{service, database::KeyValueDatabase};
+
+impl service::rooms::pdu_metadata::Data for KeyValueDatabase {
     fn mark_as_referenced(&self, room_id: &RoomId, event_ids: &[Arc<EventId>]) -> Result<()> {
         for prev in event_ids {
             let mut key = room_id.as_bytes().to_vec();

src/database/key_value/rooms/search.rs

@@ -1,7 +1,12 @@
-impl service::room::search::Data for KeyValueDatabase {
+use std::mem::size_of;
 
+use ruma::RoomId;
+
+use crate::{service, database::KeyValueDatabase, utils};
+
+impl service::rooms::search::Data for KeyValueDatabase {
     fn index_pdu<'a>(&self, room_id: &RoomId, pdu_id: u64, message_body: String) -> Result<()> {
-        let mut batch = body
+        let mut batch = message_body
             .split_terminator(|c: char| !c.is_alphanumeric())
             .filter(|s| !s.is_empty())
             .filter(|word| word.len() <= 50)
@@ -14,7 +19,7 @@ impl service::room::search::Data for KeyValueDatabase {
                 (key, Vec::new())
             });
 
-        self.tokenids.insert_batch(&mut batch)?;
+        self.tokenids.insert_batch(&mut batch)
     }
 
     fn search_pdus<'a>(
@@ -64,3 +69,4 @@ impl service::room::search::Data for KeyValueDatabase {
             )
         }))
     }
+}

src/database/key_value/rooms/state.rs

@@ -1,4 +1,11 @@
-impl service::room::state::Data for KeyValueDatabase {
+use ruma::{RoomId, EventId};
+use std::sync::Arc;
+use std::{sync::MutexGuard, collections::HashSet};
+use std::fmt::Debug;
+
+use crate::{service, database::KeyValueDatabase, utils, Error};
+
+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())?
@@ -9,21 +16,21 @@ impl service::room::state::Data for KeyValueDatabase {
             })
     }
 
-    fn set_room_state(&self, room_id: &RoomId, new_shortstatehash: u64
-        _mutex_lock: &MutexGuard<'_, StateLock>, // Take mutex guard to make sure users get the room state mutex
+    fn set_room_state(&self, room_id: &RoomId, new_shortstatehash: u64,
+        _mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room state mutex
         ) -> Result<()> {
         self.roomid_shortstatehash
             .insert(room_id.as_bytes(), &new_shortstatehash.to_be_bytes())?;
         Ok(())
     }
 
-    fn set_event_state(&self) -> Result<()> {
-        db.shorteventid_shortstatehash
+    fn set_event_state(&self, shorteventid: Vec<u8>, shortstatehash: Vec<u8>) -> Result<()> {
+        self.shorteventid_shortstatehash
             .insert(&shorteventid.to_be_bytes(), &shortstatehash.to_be_bytes())?;
         Ok(())
     }
 
-    fn get_pdu_leaves(&self, room_id: &RoomId) -> Result<HashSet<Arc<EventId>>> {
+    fn get_forward_extremities(&self, room_id: &RoomId) -> Result<HashSet<Arc<EventId>>> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -38,11 +45,11 @@ impl service::room::state::Data for KeyValueDatabase {
             .collect()
     }
 
-    fn set_forward_extremities(
+    fn set_forward_extremities<'a>(
         &self,
         room_id: &RoomId,
         event_ids: impl IntoIterator<Item = &'a EventId> + Debug,
-        _mutex_lock: &MutexGuard<'_, StateLock>, // Take mutex guard to make sure users get the room state mutex
+        _mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room state mutex
     ) -> Result<()> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);

src/database/key_value/rooms/state_accessor.rs

@@ -1,4 +1,11 @@
-impl service::room::state_accessor::Data for KeyValueDatabase {
+use std::{collections::{BTreeMap, HashMap}, sync::Arc};
+
+use crate::{database::KeyValueDatabase, service, PduEvent, Error, utils};
+use async_trait::async_trait;
+use ruma::{EventId, events::StateEventType, RoomId};
+
+#[async_trait]
+impl service::rooms::state_accessor::Data for KeyValueDatabase {
     async fn state_full_ids(&self, shortstatehash: u64) -> Result<BTreeMap<u64, Arc<EventId>>> {
         let full_state = self
             .load_shortstatehash_info(shortstatehash)?
@@ -149,3 +156,4 @@ impl service::room::state_accessor::Data for KeyValueDatabase {
             Ok(None)
         }
     }
+}

src/database/key_value/rooms/state_cache.rs

@@ -1,8 +1,12 @@
-impl service::room::state_cache::Data for KeyValueDatabase {
-    fn mark_as_once_joined(user_id: &UserId, room_id: &RoomId) -> Result<()> {
+use ruma::{UserId, RoomId};
+
+use crate::{service, database::KeyValueDatabase};
+
+impl service::rooms::state_cache::Data for KeyValueDatabase {
+    fn mark_as_once_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
         let mut userroom_id = user_id.as_bytes().to_vec();
         userroom_id.push(0xff);
         userroom_id.extend_from_slice(room_id.as_bytes());
-        self.roomuseroncejoinedids.insert(&userroom_id, &[])?;
+        self.roomuseroncejoinedids.insert(&userroom_id, &[])
     }
 }

src/database/key_value/rooms/state_compressor.rs

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

src/database/key_value/rooms/timeline.rs

@@ -1,4 +1,11 @@
-impl service::room::timeline::Data for KeyValueDatabase {
+use std::{collections::hash_map, mem::size_of, sync::Arc};
+
+use ruma::{UserId, RoomId, api::client::error::ErrorKind, EventId, signatures::CanonicalJsonObject};
+use tracing::error;
+
+use crate::{service, database::KeyValueDatabase, utils, Error, PduEvent};
+
+impl service::rooms::timeline::Data for KeyValueDatabase {
     fn last_timeline_count(&self, sender_user: &UserId, room_id: &RoomId) -> Result<u64> {
         match self
             .lasttimelinecount_cache
@@ -37,7 +44,7 @@ impl service::room::timeline::Data for KeyValueDatabase {
     }
 
     /// Returns the json of a pdu.
-    pub fn get_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
+    fn get_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
         self.eventid_pduid
             .get(event_id.as_bytes())?
             .map_or_else(
@@ -55,7 +62,7 @@ impl service::room::timeline::Data for KeyValueDatabase {
     }
 
     /// Returns the json of a pdu.
-    pub fn get_non_outlier_pdu_json(
+    fn get_non_outlier_pdu_json(
         &self,
         event_id: &EventId,
     ) -> Result<Option<CanonicalJsonObject>> {
@@ -74,14 +81,14 @@ impl service::room::timeline::Data for KeyValueDatabase {
     }
 
     /// Returns the pdu's id.
-    pub fn get_pdu_id(&self, event_id: &EventId) -> Result<Option<Vec<u8>>> {
+    fn get_pdu_id(&self, event_id: &EventId) -> Result<Option<Vec<u8>>> {
         self.eventid_pduid.get(event_id.as_bytes())
     }
 
     /// Returns the pdu.
     ///
     /// Checks the `eventid_outlierpdu` Tree if not found in the timeline.
-    pub fn get_non_outlier_pdu(&self, event_id: &EventId) -> Result<Option<PduEvent>> {
+    fn get_non_outlier_pdu(&self, event_id: &EventId) -> Result<Option<PduEvent>> {
         self.eventid_pduid
             .get(event_id.as_bytes())?
             .map(|pduid| {
@@ -99,7 +106,7 @@ impl service::room::timeline::Data for KeyValueDatabase {
     /// Returns the pdu.
     ///
     /// Checks the `eventid_outlierpdu` Tree if not found in the timeline.
-    pub fn get_pdu(&self, event_id: &EventId) -> Result<Option<Arc<PduEvent>>> {
+    fn get_pdu(&self, event_id: &EventId) -> Result<Option<Arc<PduEvent>>> {
         if let Some(p) = self.pdu_cache.lock().unwrap().get_mut(event_id) {
             return Ok(Some(Arc::clone(p)));
         }
@@ -135,7 +142,7 @@ impl service::room::timeline::Data for KeyValueDatabase {
     /// Returns the pdu.
     ///
     /// This does __NOT__ check the outliers `Tree`.
-    pub fn get_pdu_from_id(&self, pdu_id: &[u8]) -> Result<Option<PduEvent>> {
+    fn get_pdu_from_id(&self, pdu_id: &[u8]) -> Result<Option<PduEvent>> {
         self.pduid_pdu.get(pdu_id)?.map_or(Ok(None), |pdu| {
             Ok(Some(
                 serde_json::from_slice(&pdu)
@@ -145,7 +152,7 @@ impl service::room::timeline::Data for KeyValueDatabase {
     }
 
     /// Returns the pdu as a `BTreeMap<String, CanonicalJsonValue>`.
-    pub fn get_pdu_json_from_id(&self, pdu_id: &[u8]) -> Result<Option<CanonicalJsonObject>> {
+    fn get_pdu_json_from_id(&self, pdu_id: &[u8]) -> Result<Option<CanonicalJsonObject>> {
         self.pduid_pdu.get(pdu_id)?.map_or(Ok(None), |pdu| {
             Ok(Some(
                 serde_json::from_slice(&pdu)
@@ -155,7 +162,7 @@ impl service::room::timeline::Data for KeyValueDatabase {
     }
 
     /// Returns the `count` of this pdu's id.
-    pub fn pdu_count(&self, pdu_id: &[u8]) -> Result<u64> {
+    fn pdu_count(&self, pdu_id: &[u8]) -> Result<u64> {
         utils::u64_from_bytes(&pdu_id[pdu_id.len() - size_of::<u64>()..])
             .map_err(|_| Error::bad_database("PDU has invalid count bytes."))
     }
@@ -178,7 +185,7 @@ impl service::room::timeline::Data for KeyValueDatabase {
 
     /// Returns an iterator over all events in a room that happened after the event with id `since`
     /// in chronological order.
-    pub fn pdus_since<'a>(
+    fn pdus_since<'a>(
         &'a self,
         user_id: &UserId,
         room_id: &RoomId,
@@ -212,7 +219,7 @@ impl service::room::timeline::Data for KeyValueDatabase {
 
     /// Returns an iterator over all events and their tokens in a room that happened before the
     /// event with id `until` in reverse-chronological order.
-    pub fn pdus_until<'a>(
+    fn pdus_until<'a>(
         &'a self,
         user_id: &UserId,
         room_id: &RoomId,
@@ -246,7 +253,7 @@ impl service::room::timeline::Data for KeyValueDatabase {
             }))
     }
 
-    pub fn pdus_after<'a>(
+    fn pdus_after<'a>(
         &'a self,
         user_id: &UserId,
         room_id: &RoomId,

src/database/key_value/rooms/user.rs

@@ -1,4 +1,8 @@
-impl service::room::user::Data for KeyValueDatabase {
+use ruma::{UserId, RoomId};
+
+use crate::{service, database::KeyValueDatabase, utils, Error};
+
+impl service::rooms::user::Data for KeyValueDatabase {
     fn reset_notification_counts(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
         let mut userroom_id = user_id.as_bytes().to_vec();
         userroom_id.push(0xff);

src/database/key_value/transaction_ids.rs

@@ -1,5 +1,9 @@
-impl service::pusher::Data for KeyValueDatabase {
-    pub fn add_txnid(
+use ruma::{UserId, DeviceId, TransactionId};
+
+use crate::{service, database::KeyValueDatabase};
+
+impl service::transaction_ids::Data for KeyValueDatabase {
+    fn add_txnid(
         &self,
         user_id: &UserId,
         device_id: Option<&DeviceId>,
@@ -17,7 +21,7 @@ impl service::pusher::Data for KeyValueDatabase {
         Ok(())
     }
 
-    pub fn existing_txnid(
+    fn existing_txnid(
         &self,
         user_id: &UserId,
         device_id: Option<&DeviceId>,

src/database/key_value/uiaa.rs

@@ -1,3 +1,9 @@
+use std::io::ErrorKind;
+
+use ruma::{UserId, DeviceId, signatures::CanonicalJsonValue, api::client::uiaa::UiaaInfo};
+
+use crate::{database::KeyValueDatabase, service, Error};
+
 impl service::uiaa::Data for KeyValueDatabase {
     fn set_uiaa_request(
         &self,

src/database/key_value/users.rs

@@ -1,11 +1,18 @@
+use std::{mem::size_of, collections::BTreeMap};
+
+use ruma::{api::client::{filter::IncomingFilterDefinition, error::ErrorKind, device::Device}, UserId, RoomAliasId, MxcUri, DeviceId, MilliSecondsSinceUnixEpoch, DeviceKeyId, encryption::{OneTimeKey, CrossSigningKey, DeviceKeys}, serde::Raw, events::{AnyToDeviceEvent, StateEventType}, DeviceKeyAlgorithm, UInt};
+use tracing::warn;
+
+use crate::{service::{self, users::clean_signatures}, database::KeyValueDatabase, Error, utils, services};
+
 impl service::users::Data for KeyValueDatabase {
     /// Check if a user has an account on this homeserver.
-    pub fn exists(&self, user_id: &UserId) -> Result<bool> {
+    fn exists(&self, user_id: &UserId) -> Result<bool> {
         Ok(self.userid_password.get(user_id.as_bytes())?.is_some())
     }
 
     /// Check if account is deactivated
-    pub fn is_deactivated(&self, user_id: &UserId) -> Result<bool> {
+    fn is_deactivated(&self, user_id: &UserId) -> Result<bool> {
         Ok(self
             .userid_password
             .get(user_id.as_bytes())?
@@ -16,33 +23,13 @@ impl service::users::Data for KeyValueDatabase {
             .is_empty())
     }
 
-    /// Check if a user is an admin
-    pub fn is_admin(
-        &self,
-        user_id: &UserId,
-        rooms: &super::rooms::Rooms,
-        globals: &super::globals::Globals,
-    ) -> Result<bool> {
-        let admin_room_alias_id = RoomAliasId::parse(format!("#admins:{}", globals.server_name()))
-            .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;
-        let admin_room_id = rooms.id_from_alias(&admin_room_alias_id)?.unwrap();
-
-        rooms.is_joined(user_id, &admin_room_id)
-    }
-
-    /// Create a new user account on this homeserver.
-    pub fn create(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
-        self.set_password(user_id, password)?;
-        Ok(())
-    }
-
     /// Returns the number of users registered on this server.
-    pub fn count(&self) -> Result<usize> {
+    fn count(&self) -> Result<usize> {
         Ok(self.userid_password.iter().count())
     }
 
     /// Find out which user an access token belongs to.
-    pub fn find_from_token(&self, token: &str) -> Result<Option<(Box<UserId>, String)>> {
+    fn find_from_token(&self, token: &str) -> Result<Option<(Box<UserId>, String)>> {
         self.token_userdeviceid
             .get(token.as_bytes())?
             .map_or(Ok(None), |bytes| {
@@ -69,7 +56,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Returns an iterator over all users on this homeserver.
-    pub fn iter(&self) -> impl Iterator<Item = Result<Box<UserId>>> + '_ {
+    fn iter(&self) -> impl Iterator<Item = Result<Box<UserId>>> + '_ {
         self.userid_password.iter().map(|(bytes, _)| {
             UserId::parse(utils::string_from_bytes(&bytes).map_err(|_| {
                 Error::bad_database("User ID in userid_password is invalid unicode.")
@@ -81,7 +68,7 @@ impl service::users::Data for KeyValueDatabase {
     /// Returns a list of local users as list of usernames.
     ///
     /// A user account is considered `local` if the length of it's password is greater then zero.
-    pub fn list_local_users(&self) -> Result<Vec<String>> {
+    fn list_local_users(&self) -> Result<Vec<String>> {
         let users: Vec<String> = self
             .userid_password
             .iter()
@@ -113,7 +100,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Returns the password hash for the given user.
-    pub fn password_hash(&self, user_id: &UserId) -> Result<Option<String>> {
+    fn password_hash(&self, user_id: &UserId) -> Result<Option<String>> {
         self.userid_password
             .get(user_id.as_bytes())?
             .map_or(Ok(None), |bytes| {
@@ -124,7 +111,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Hash and set the user's password to the Argon2 hash
-    pub fn set_password(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
+    fn set_password(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
         if let Some(password) = password {
             if let Ok(hash) = utils::calculate_hash(password) {
                 self.userid_password
@@ -143,7 +130,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Returns the displayname of a user on this homeserver.
-    pub fn displayname(&self, user_id: &UserId) -> Result<Option<String>> {
+    fn displayname(&self, user_id: &UserId) -> Result<Option<String>> {
         self.userid_displayname
             .get(user_id.as_bytes())?
             .map_or(Ok(None), |bytes| {
@@ -154,7 +141,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Sets a new displayname or removes it if displayname is None. You still need to nofify all rooms of this change.
-    pub fn set_displayname(&self, user_id: &UserId, displayname: Option<String>) -> Result<()> {
+    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())?;
@@ -166,7 +153,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Get the avatar_url of a user.
-    pub fn avatar_url(&self, user_id: &UserId) -> Result<Option<Box<MxcUri>>> {
+    fn avatar_url(&self, user_id: &UserId) -> Result<Option<Box<MxcUri>>> {
         self.userid_avatarurl
             .get(user_id.as_bytes())?
             .map(|bytes| {
@@ -179,7 +166,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Sets a new avatar_url or removes it if avatar_url is None.
-    pub fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<Box<MxcUri>>) -> Result<()> {
+    fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<Box<MxcUri>>) -> Result<()> {
         if let Some(avatar_url) = avatar_url {
             self.userid_avatarurl
                 .insert(user_id.as_bytes(), avatar_url.to_string().as_bytes())?;
@@ -191,7 +178,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Get the blurhash of a user.
-    pub fn blurhash(&self, user_id: &UserId) -> Result<Option<String>> {
+    fn blurhash(&self, user_id: &UserId) -> Result<Option<String>> {
         self.userid_blurhash
             .get(user_id.as_bytes())?
             .map(|bytes| {
@@ -204,7 +191,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Sets a new avatar_url or removes it if avatar_url is None.
-    pub fn set_blurhash(&self, user_id: &UserId, blurhash: Option<String>) -> Result<()> {
+    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())?;
@@ -216,7 +203,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Adds a new device to a user.
-    pub fn create_device(
+    fn create_device(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -250,7 +237,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Removes a device from a user.
-    pub fn remove_device(&self, user_id: &UserId, device_id: &DeviceId) -> Result<()> {
+    fn remove_device(&self, user_id: &UserId, device_id: &DeviceId) -> Result<()> {
         let mut userdeviceid = user_id.as_bytes().to_vec();
         userdeviceid.push(0xff);
         userdeviceid.extend_from_slice(device_id.as_bytes());
@@ -280,7 +267,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Returns an iterator over all device ids of this user.
-    pub fn all_device_ids<'a>(
+    fn all_device_ids<'a>(
         &'a self,
         user_id: &UserId,
     ) -> impl Iterator<Item = Result<Box<DeviceId>>> + 'a {
@@ -302,7 +289,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Replaces the access token of one device.
-    pub fn set_token(&self, user_id: &UserId, device_id: &DeviceId, token: &str) -> Result<()> {
+    fn set_token(&self, user_id: &UserId, device_id: &DeviceId, token: &str) -> Result<()> {
         let mut userdeviceid = user_id.as_bytes().to_vec();
         userdeviceid.push(0xff);
         userdeviceid.extend_from_slice(device_id.as_bytes());
@@ -325,13 +312,12 @@ impl service::users::Data for KeyValueDatabase {
         Ok(())
     }
 
-    pub fn add_one_time_key(
+    fn add_one_time_key(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
         one_time_key_key: &DeviceKeyId,
         one_time_key_value: &Raw<OneTimeKey>,
-        globals: &super::globals::Globals,
     ) -> Result<()> {
         let mut key = user_id.as_bytes().to_vec();
         key.push(0xff);
@@ -356,12 +342,12 @@ impl service::users::Data for KeyValueDatabase {
         )?;
 
         self.userid_lastonetimekeyupdate
-            .insert(user_id.as_bytes(), &globals.next_count()?.to_be_bytes())?;
+            .insert(user_id.as_bytes(), &services().globals.next_count()?.to_be_bytes())?;
 
         Ok(())
     }
 
-    pub fn last_one_time_keys_update(&self, user_id: &UserId) -> Result<u64> {
+    fn last_one_time_keys_update(&self, user_id: &UserId) -> Result<u64> {
         self.userid_lastonetimekeyupdate
             .get(user_id.as_bytes())?
             .map(|bytes| {
@@ -372,12 +358,11 @@ impl service::users::Data for KeyValueDatabase {
             .unwrap_or(Ok(0))
     }
 
-    pub fn take_one_time_key(
+    fn take_one_time_key(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
         key_algorithm: &DeviceKeyAlgorithm,
-        globals: &super::globals::Globals,
     ) -> Result<Option<(Box<DeviceKeyId>, Raw<OneTimeKey>)>> {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
@@ -388,7 +373,7 @@ impl service::users::Data for KeyValueDatabase {
         prefix.push(b':');
 
         self.userid_lastonetimekeyupdate
-            .insert(user_id.as_bytes(), &globals.next_count()?.to_be_bytes())?;
+            .insert(user_id.as_bytes(), &services().globals.next_count()?.to_be_bytes())?;
 
         self.onetimekeyid_onetimekeys
             .scan_prefix(prefix)
@@ -411,7 +396,7 @@ impl service::users::Data for KeyValueDatabase {
             .transpose()
     }
 
-    pub fn count_one_time_keys(
+    fn count_one_time_keys(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -443,13 +428,11 @@ impl service::users::Data for KeyValueDatabase {
         Ok(counts)
     }
 
-    pub fn add_device_keys(
+    fn add_device_keys(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
         device_keys: &Raw<DeviceKeys>,
-        rooms: &super::rooms::Rooms,
-        globals: &super::globals::Globals,
     ) -> Result<()> {
         let mut userdeviceid = user_id.as_bytes().to_vec();
         userdeviceid.push(0xff);
@@ -460,19 +443,17 @@ impl service::users::Data for KeyValueDatabase {
             &serde_json::to_vec(&device_keys).expect("DeviceKeys::to_vec always works"),
         )?;
 
-        self.mark_device_key_update(user_id, rooms, globals)?;
+        self.mark_device_key_update(user_id)?;
 
         Ok(())
     }
 
-    pub fn add_cross_signing_keys(
+    fn add_cross_signing_keys(
         &self,
         user_id: &UserId,
         master_key: &Raw<CrossSigningKey>,
         self_signing_key: &Option<Raw<CrossSigningKey>>,
         user_signing_key: &Option<Raw<CrossSigningKey>>,
-        rooms: &super::rooms::Rooms,
-        globals: &super::globals::Globals,
     ) -> Result<()> {
         // TODO: Check signatures
 
@@ -575,19 +556,17 @@ impl service::users::Data for KeyValueDatabase {
                 .insert(user_id.as_bytes(), &user_signing_key_key)?;
         }
 
-        self.mark_device_key_update(user_id, rooms, globals)?;
+        self.mark_device_key_update(user_id)?;
 
         Ok(())
     }
 
-    pub fn sign_key(
+    fn sign_key(
         &self,
         target_id: &UserId,
         key_id: &str,
         signature: (String, String),
         sender_id: &UserId,
-        rooms: &super::rooms::Rooms,
-        globals: &super::globals::Globals,
     ) -> Result<()> {
         let mut key = target_id.as_bytes().to_vec();
         key.push(0xff);
@@ -619,12 +598,12 @@ impl service::users::Data for KeyValueDatabase {
         )?;
 
         // TODO: Should we notify about this change?
-        self.mark_device_key_update(target_id, rooms, globals)?;
+        self.mark_device_key_update(target_id)?;
 
         Ok(())
     }
 
-    pub fn keys_changed<'a>(
+    fn keys_changed<'a>(
         &'a self,
         user_or_room_id: &str,
         from: u64,
@@ -662,16 +641,14 @@ impl service::users::Data for KeyValueDatabase {
             })
     }
 
-    pub fn mark_device_key_update(
+    fn mark_device_key_update(
         &self,
         user_id: &UserId,
-        rooms: &super::rooms::Rooms,
-        globals: &super::globals::Globals,
     ) -> Result<()> {
-        let count = globals.next_count()?.to_be_bytes();
-        for room_id in rooms.rooms_joined(user_id).filter_map(|r| r.ok()) {
+        let count = services().globals.next_count()?.to_be_bytes();
+        for room_id in services().rooms.rooms_joined(user_id).filter_map(|r| r.ok()) {
             // Don't send key updates to unencrypted rooms
-            if rooms
+            if services().rooms
                 .room_state_get(&room_id, &StateEventType::RoomEncryption, "")?
                 .is_none()
             {
@@ -693,7 +670,7 @@ impl service::users::Data for KeyValueDatabase {
         Ok(())
     }
 
-    pub fn get_device_keys(
+    fn get_device_keys(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -709,7 +686,7 @@ impl service::users::Data for KeyValueDatabase {
         })
     }
 
-    pub fn get_master_key<F: Fn(&UserId) -> bool>(
+    fn get_master_key<F: Fn(&UserId) -> bool>(
         &self,
         user_id: &UserId,
         allowed_signatures: F,
@@ -730,7 +707,7 @@ impl service::users::Data for KeyValueDatabase {
             })
     }
 
-    pub fn get_self_signing_key<F: Fn(&UserId) -> bool>(
+    fn get_self_signing_key<F: Fn(&UserId) -> bool>(
         &self,
         user_id: &UserId,
         allowed_signatures: F,
@@ -751,7 +728,7 @@ impl service::users::Data for KeyValueDatabase {
             })
     }
 
-    pub fn get_user_signing_key(&self, user_id: &UserId) -> Result<Option<Raw<CrossSigningKey>>> {
+    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| {
@@ -763,20 +740,19 @@ impl service::users::Data for KeyValueDatabase {
             })
     }
 
-    pub fn add_to_device_event(
+    fn add_to_device_event(
         &self,
         sender: &UserId,
         target_user_id: &UserId,
         target_device_id: &DeviceId,
         event_type: &str,
         content: serde_json::Value,
-        globals: &super::globals::Globals,
     ) -> Result<()> {
         let mut key = target_user_id.as_bytes().to_vec();
         key.push(0xff);
         key.extend_from_slice(target_device_id.as_bytes());
         key.push(0xff);
-        key.extend_from_slice(&globals.next_count()?.to_be_bytes());
+        key.extend_from_slice(&services().globals.next_count()?.to_be_bytes());
 
         let mut json = serde_json::Map::new();
         json.insert("type".to_owned(), event_type.to_owned().into());
@@ -790,7 +766,7 @@ impl service::users::Data for KeyValueDatabase {
         Ok(())
     }
 
-    pub fn get_to_device_events(
+    fn get_to_device_events(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -812,7 +788,7 @@ impl service::users::Data for KeyValueDatabase {
         Ok(events)
     }
 
-    pub fn remove_to_device_events(
+    fn remove_to_device_events(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -833,7 +809,7 @@ impl service::users::Data for KeyValueDatabase {
             .map(|(key, _)| {
                 Ok::<_, Error>((
                     key.clone(),
-                    utils::u64_from_bytes(&key[key.len() - mem::size_of::<u64>()..key.len()])
+                    utils::u64_from_bytes(&key[key.len() - size_of::<u64>()..key.len()])
                         .map_err(|_| Error::bad_database("ToDeviceId has invalid count bytes."))?,
                 ))
             })
@@ -846,7 +822,7 @@ impl service::users::Data for KeyValueDatabase {
         Ok(())
     }
 
-    pub fn update_device_metadata(
+    fn update_device_metadata(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -871,7 +847,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Get device metadata.
-    pub fn get_device_metadata(
+    fn get_device_metadata(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
@@ -889,7 +865,7 @@ impl service::users::Data for KeyValueDatabase {
             })
     }
 
-    pub fn get_devicelist_version(&self, user_id: &UserId) -> Result<Option<u64>> {
+    fn get_devicelist_version(&self, user_id: &UserId) -> Result<Option<u64>> {
         self.userid_devicelistversion
             .get(user_id.as_bytes())?
             .map_or(Ok(None), |bytes| {
@@ -899,7 +875,7 @@ impl service::users::Data for KeyValueDatabase {
             })
     }
 
-    pub fn all_devices_metadata<'a>(
+    fn all_devices_metadata<'a>(
         &'a self,
         user_id: &UserId,
     ) -> impl Iterator<Item = Result<Device>> + 'a {
@@ -915,7 +891,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Creates a new sync filter. Returns the filter id.
-    pub fn create_filter(
+    fn create_filter(
         &self,
         user_id: &UserId,
         filter: &IncomingFilterDefinition,
@@ -934,7 +910,7 @@ impl service::users::Data for KeyValueDatabase {
         Ok(filter_id)
     }
 
-    pub fn get_filter(
+    fn get_filter(
         &self,
         user_id: &UserId,
         filter_id: &str,

src/database/mod.rs

@@ -1,20 +1,7 @@
 pub mod abstraction;
+pub mod key_value;
 
-pub mod account_data;
-pub mod admin;
-pub mod appservice;
-pub mod globals;
-pub mod key_backups;
-pub mod media;
-pub mod pusher;
-pub mod rooms;
-pub mod sending;
-pub mod transaction_ids;
-pub mod uiaa;
-pub mod users;
-
-use self::admin::create_admin_room;
-use crate::{utils, Config, Error, Result};
+use crate::{utils, Config, Error, Result, service::{users, globals, uiaa, rooms, account_data, media, key_backups, transaction_ids, sending, admin::{self, create_admin_room}, appservice, pusher}};
 use abstraction::KeyValueDatabaseEngine;
 use directories::ProjectDirs;
 use futures_util::{stream::FuturesUnordered, StreamExt};
@@ -25,7 +12,7 @@ use ruma::{
         GlobalAccountDataEvent, GlobalAccountDataEventType,
     },
     push::Ruleset,
-    DeviceId, EventId, RoomId, UserId,
+    DeviceId, EventId, RoomId, UserId, signatures::CanonicalJsonValue,
 };
 use std::{
     collections::{BTreeMap, HashMap, HashSet},
@@ -38,21 +25,132 @@ use std::{
 };
 use tokio::sync::{mpsc, OwnedRwLockReadGuard, RwLock as TokioRwLock, Semaphore};
 use tracing::{debug, error, info, warn};
+use abstraction::KvTree;
 
 pub struct KeyValueDatabase {
     _db: Arc<dyn KeyValueDatabaseEngine>,
-    pub globals: globals::Globals,
-    pub users: users::Users,
-    pub uiaa: uiaa::Uiaa,
-    pub rooms: rooms::Rooms,
-    pub account_data: account_data::AccountData,
-    pub media: media::Media,
-    pub key_backups: key_backups::KeyBackups,
-    pub transaction_ids: transaction_ids::TransactionIds,
-    pub sending: sending::Sending,
-    pub admin: admin::Admin,
-    pub appservice: appservice::Appservice,
-    pub pusher: pusher::PushData,
+
+    //pub globals: globals::Globals,
+    pub(super) global: Arc<dyn KvTree>,
+    pub(super) server_signingkeys: Arc<dyn KvTree>,
+
+    //pub users: users::Users,
+    pub(super) userid_password: Arc<dyn KvTree>,
+    pub(super) userid_displayname: Arc<dyn KvTree>,
+    pub(super) userid_avatarurl: Arc<dyn KvTree>,
+    pub(super) userid_blurhash: Arc<dyn KvTree>,
+    pub(super) userdeviceid_token: Arc<dyn KvTree>,
+    pub(super) userdeviceid_metadata: Arc<dyn KvTree>, // This is also used to check if a device exists
+    pub(super) userid_devicelistversion: Arc<dyn KvTree>, // DevicelistVersion = u64
+    pub(super) token_userdeviceid: Arc<dyn KvTree>,
+
+    pub(super) onetimekeyid_onetimekeys: Arc<dyn KvTree>, // OneTimeKeyId = UserId + DeviceKeyId
+    pub(super) userid_lastonetimekeyupdate: Arc<dyn KvTree>, // LastOneTimeKeyUpdate = Count
+    pub(super) keychangeid_userid: Arc<dyn KvTree>,       // KeyChangeId = UserId/RoomId + Count
+    pub(super) keyid_key: Arc<dyn KvTree>, // KeyId = UserId + KeyId (depends on key type)
+    pub(super) userid_masterkeyid: Arc<dyn KvTree>,
+    pub(super) userid_selfsigningkeyid: Arc<dyn KvTree>,
+    pub(super) userid_usersigningkeyid: Arc<dyn KvTree>,
+
+    pub(super) userfilterid_filter: Arc<dyn KvTree>, // UserFilterId = UserId + FilterId
+
+    pub(super) todeviceid_events: Arc<dyn KvTree>, // ToDeviceId = UserId + DeviceId + Count
+
+    //pub uiaa: uiaa::Uiaa,
+    pub(super) userdevicesessionid_uiaainfo: Arc<dyn KvTree>, // User-interactive authentication
+    pub(super) userdevicesessionid_uiaarequest:
+        RwLock<BTreeMap<(Box<UserId>, Box<DeviceId>, String), CanonicalJsonValue>>,
+
+    //pub edus: RoomEdus,
+    pub(super) readreceiptid_readreceipt: Arc<dyn KvTree>, // ReadReceiptId = RoomId + Count + UserId
+    pub(super) roomuserid_privateread: Arc<dyn KvTree>, // RoomUserId = Room + User, PrivateRead = Count
+    pub(super) roomuserid_lastprivatereadupdate: Arc<dyn KvTree>, // LastPrivateReadUpdate = Count
+    pub(super) typingid_userid: Arc<dyn KvTree>, // TypingId = RoomId + TimeoutTime + Count
+    pub(super) roomid_lasttypingupdate: Arc<dyn KvTree>, // LastRoomTypingUpdate = Count
+    pub(super) presenceid_presence: Arc<dyn KvTree>, // PresenceId = RoomId + Count + UserId
+    pub(super) userid_lastpresenceupdate: Arc<dyn KvTree>, // LastPresenceUpdate = Count
+
+    //pub rooms: rooms::Rooms,
+    pub(super) pduid_pdu: Arc<dyn KvTree>, // PduId = ShortRoomId + Count
+    pub(super) eventid_pduid: Arc<dyn KvTree>,
+    pub(super) roomid_pduleaves: Arc<dyn KvTree>,
+    pub(super) alias_roomid: Arc<dyn KvTree>,
+    pub(super) aliasid_alias: Arc<dyn KvTree>, // AliasId = RoomId + Count
+    pub(super) publicroomids: Arc<dyn KvTree>,
+
+    pub(super) tokenids: Arc<dyn KvTree>, // TokenId = ShortRoomId + Token + PduIdCount
+
+    /// Participating servers in a room.
+    pub(super) roomserverids: Arc<dyn KvTree>, // RoomServerId = RoomId + ServerName
+    pub(super) serverroomids: Arc<dyn KvTree>, // ServerRoomId = ServerName + RoomId
+
+    pub(super) userroomid_joined: Arc<dyn KvTree>,
+    pub(super) roomuserid_joined: Arc<dyn KvTree>,
+    pub(super) roomid_joinedcount: Arc<dyn KvTree>,
+    pub(super) roomid_invitedcount: Arc<dyn KvTree>,
+    pub(super) roomuseroncejoinedids: Arc<dyn KvTree>,
+    pub(super) userroomid_invitestate: Arc<dyn KvTree>, // InviteState = Vec<Raw<Pdu>>
+    pub(super) roomuserid_invitecount: Arc<dyn KvTree>, // InviteCount = Count
+    pub(super) userroomid_leftstate: Arc<dyn KvTree>,
+    pub(super) roomuserid_leftcount: Arc<dyn KvTree>,
+
+    pub(super) disabledroomids: Arc<dyn KvTree>, // Rooms where incoming federation handling is disabled
+
+    pub(super) lazyloadedids: Arc<dyn KvTree>, // LazyLoadedIds = UserId + DeviceId + RoomId + LazyLoadedUserId
+
+    pub(super) userroomid_notificationcount: Arc<dyn KvTree>, // NotifyCount = u64
+    pub(super) userroomid_highlightcount: Arc<dyn KvTree>,    // HightlightCount = u64
+
+    /// Remember the current state hash of a room.
+    pub(super) roomid_shortstatehash: Arc<dyn KvTree>,
+    pub(super) roomsynctoken_shortstatehash: Arc<dyn KvTree>,
+    /// Remember the state hash at events in the past.
+    pub(super) shorteventid_shortstatehash: Arc<dyn KvTree>,
+    /// StateKey = EventType + StateKey, ShortStateKey = Count
+    pub(super) statekey_shortstatekey: Arc<dyn KvTree>,
+    pub(super) shortstatekey_statekey: Arc<dyn KvTree>,
+
+    pub(super) roomid_shortroomid: Arc<dyn KvTree>,
+
+    pub(super) shorteventid_eventid: Arc<dyn KvTree>,
+    pub(super) eventid_shorteventid: Arc<dyn KvTree>,
+
+    pub(super) statehash_shortstatehash: Arc<dyn KvTree>,
+    pub(super) shortstatehash_statediff: Arc<dyn KvTree>, // StateDiff = parent (or 0) + (shortstatekey+shorteventid++) + 0_u64 + (shortstatekey+shorteventid--)
+
+    pub(super) shorteventid_authchain: Arc<dyn KvTree>,
+
+    /// RoomId + EventId -> outlier PDU.
+    /// Any pdu that has passed the steps 1-8 in the incoming event /federation/send/txn.
+    pub(super) eventid_outlierpdu: Arc<dyn KvTree>,
+    pub(super) softfailedeventids: Arc<dyn KvTree>,
+
+    /// RoomId + EventId -> Parent PDU EventId.
+    pub(super) referencedevents: Arc<dyn KvTree>,
+
+    //pub account_data: account_data::AccountData,
+    pub(super) roomuserdataid_accountdata: Arc<dyn KvTree>, // RoomUserDataId = Room + User + Count + Type
+    pub(super) roomusertype_roomuserdataid: Arc<dyn KvTree>, // RoomUserType = Room + User + Type
+
+    //pub media: media::Media,
+    pub(super) mediaid_file: Arc<dyn KvTree>, // MediaId = MXC + WidthHeight + ContentDisposition + ContentType
+    //pub key_backups: key_backups::KeyBackups,
+    pub(super) backupid_algorithm: Arc<dyn KvTree>, // BackupId = UserId + Version(Count)
+    pub(super) backupid_etag: Arc<dyn KvTree>,      // BackupId = UserId + Version(Count)
+    pub(super) backupkeyid_backup: Arc<dyn KvTree>, // BackupKeyId = UserId + Version + RoomId + SessionId
+
+    //pub transaction_ids: transaction_ids::TransactionIds,
+    pub(super) userdevicetxnid_response: Arc<dyn KvTree>, // Response can be empty (/sendToDevice) or the event id (/send)
+    //pub sending: sending::Sending,
+    pub(super) servername_educount: Arc<dyn KvTree>, // EduCount: Count of last EDU sync
+    pub(super) servernameevent_data: Arc<dyn KvTree>, // ServernameEvent = (+ / $)SenderKey / ServerName / UserId + PduId / Id (for edus), Data = EDU content
+    pub(super) servercurrentevent_data: Arc<dyn KvTree>, // ServerCurrentEvents = (+ / $)ServerName / UserId + PduId / Id (for edus), Data = EDU content
+
+    //pub appservice: appservice::Appservice,
+    pub(super) id_appserviceregistrations: Arc<dyn KvTree>,
+
+    //pub pusher: pusher::PushData,
+    pub(super) senderkey_pusher: Arc<dyn KvTree>,
 }
 
 impl KeyValueDatabase {
@@ -157,7 +255,6 @@ impl KeyValueDatabase {
 
         let db = Arc::new(TokioRwLock::from(Self {
             _db: builder.clone(),
-            users: users::Users {
                 userid_password: builder.open_tree("userid_password")?,
                 userid_displayname: builder.open_tree("userid_displayname")?,
                 userid_avatarurl: builder.open_tree("userid_avatarurl")?,
@@ -175,13 +272,9 @@ impl KeyValueDatabase {
                 userid_usersigningkeyid: builder.open_tree("userid_usersigningkeyid")?,
                 userfilterid_filter: builder.open_tree("userfilterid_filter")?,
                 todeviceid_events: builder.open_tree("todeviceid_events")?,
-            },
-            uiaa: uiaa::Uiaa {
+
                 userdevicesessionid_uiaainfo: builder.open_tree("userdevicesessionid_uiaainfo")?,
                 userdevicesessionid_uiaarequest: RwLock::new(BTreeMap::new()),
-            },
-            rooms: rooms::Rooms {
-                edus: rooms::RoomEdus {
                     readreceiptid_readreceipt: builder.open_tree("readreceiptid_readreceipt")?,
                     roomuserid_privateread: builder.open_tree("roomuserid_privateread")?, // "Private" read receipt
                     roomuserid_lastprivatereadupdate: builder
@@ -190,7 +283,6 @@ impl KeyValueDatabase {
                     roomid_lasttypingupdate: builder.open_tree("roomid_lasttypingupdate")?,
                     presenceid_presence: builder.open_tree("presenceid_presence")?,
                     userid_lastpresenceupdate: builder.open_tree("userid_lastpresenceupdate")?,
-                },
                 pduid_pdu: builder.open_tree("pduid_pdu")?,
                 eventid_pduid: builder.open_tree("eventid_pduid")?,
                 roomid_pduleaves: builder.open_tree("roomid_pduleaves")?,
@@ -239,74 +331,23 @@ impl KeyValueDatabase {
                 softfailedeventids: builder.open_tree("softfailedeventids")?,
 
                 referencedevents: builder.open_tree("referencedevents")?,
-                pdu_cache: Mutex::new(LruCache::new(
-                    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(
-                    (100_000.0 * config.conduit_cache_capacity_modifier) as usize,
-                )),
-                eventidshort_cache: Mutex::new(LruCache::new(
-                    (100_000.0 * config.conduit_cache_capacity_modifier) as usize,
-                )),
-                shortstatekey_cache: Mutex::new(LruCache::new(
-                    (100_000.0 * config.conduit_cache_capacity_modifier) as usize,
-                )),
-                statekeyshort_cache: Mutex::new(LruCache::new(
-                    (100_000.0 * config.conduit_cache_capacity_modifier) as usize,
-                )),
-                our_real_users_cache: RwLock::new(HashMap::new()),
-                appservice_in_room_cache: RwLock::new(HashMap::new()),
-                lazy_load_waiting: Mutex::new(HashMap::new()),
-                stateinfo_cache: Mutex::new(LruCache::new(
-                    (100.0 * config.conduit_cache_capacity_modifier) as usize,
-                )),
-                lasttimelinecount_cache: Mutex::new(HashMap::new()),
-            },
-            account_data: account_data::AccountData {
                 roomuserdataid_accountdata: builder.open_tree("roomuserdataid_accountdata")?,
                 roomusertype_roomuserdataid: builder.open_tree("roomusertype_roomuserdataid")?,
-            },
-            media: media::Media {
                 mediaid_file: builder.open_tree("mediaid_file")?,
-            },
-            key_backups: key_backups::KeyBackups {
                 backupid_algorithm: builder.open_tree("backupid_algorithm")?,
                 backupid_etag: builder.open_tree("backupid_etag")?,
                 backupkeyid_backup: builder.open_tree("backupkeyid_backup")?,
-            },
-            transaction_ids: transaction_ids::TransactionIds {
                 userdevicetxnid_response: builder.open_tree("userdevicetxnid_response")?,
-            },
-            sending: sending::Sending {
                 servername_educount: builder.open_tree("servername_educount")?,
                 servernameevent_data: builder.open_tree("servernameevent_data")?,
                 servercurrentevent_data: builder.open_tree("servercurrentevent_data")?,
-                maximum_requests: Arc::new(Semaphore::new(config.max_concurrent_requests as usize)),
-                sender: sending_sender,
-            },
-            admin: admin::Admin {
-                sender: admin_sender,
-            },
-            appservice: appservice::Appservice {
-                cached_registrations: Arc::new(RwLock::new(HashMap::new())),
                 id_appserviceregistrations: builder.open_tree("id_appserviceregistrations")?,
-            },
-            pusher: pusher::PushData {
                 senderkey_pusher: builder.open_tree("senderkey_pusher")?,
-            },
-            globals: globals::Globals::load(
-                builder.open_tree("global")?,
-                builder.open_tree("server_signingkeys")?,
-                config.clone(),
-            )?,
+                global: builder.open_tree("global")?,
+                server_signingkeys: builder.open_tree("server_signingkeys")?,
         }));
 
+        // TODO: do this after constructing the db
         let guard = db.read().await;
 
         // Matrix resource ownership is based on the server name; changing it
@@ -744,7 +785,7 @@ impl KeyValueDatabase {
                 .bump_database_version(latest_database_version)?;
 
             // Create the admin room and server user on first run
-            create_admin_room(&guard).await?;
+            create_admin_room().await?;
 
             warn!(
                 "Created new {} database with version {}",