fix: some compile time errors

Only 174 errors left!

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);