Fixed more compile time errors

10 files changed, 68 insertions, 46 deletions

diff --git a/src/api/client_server/account.rs b/src/api/client_server/account.rs
index 848bfaa..6af597e 100644
--- a/src/api/client_server/account.rs
+++ b/src/api/client_server/account.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use super::{DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
 use crate::{
-    utils, Error, Result, Ruma, services,
+    utils, Error, Result, Ruma, services, api::client_server,
 };
 use ruma::{
     api::client::{
@@ -381,7 +381,7 @@ pub async fn deactivate_route(
     }
 
     // Make the user leave all rooms before deactivation
-    services().rooms.leave_all_rooms(&sender_user).await?;
+    client_server::leave_all_rooms(&sender_user).await?;
 
     // Remove devices and mark account as deactivated
     services().users.deactivate_account(sender_user)?;
diff --git a/src/api/client_server/alias.rs b/src/api/client_server/alias.rs
index 7aa5fb2..444cc15 100644
--- a/src/api/client_server/alias.rs
+++ b/src/api/client_server/alias.rs
@@ -25,12 +25,12 @@ pub async fn create_alias_route(
         ));
     }
 
-    if services().rooms.id_from_alias(&body.room_alias)?.is_some() {
+    if services().rooms.alias.resolve_local_alias(&body.room_alias)?.is_some() {
         return Err(Error::Conflict("Alias already exists."));
     }
 
-    services().rooms
-        .set_alias(&body.room_alias, Some(&body.room_id))?;
+    services().rooms.alias
+        .set_alias(&body.room_alias, &body.room_id)?;
 
     Ok(create_alias::v3::Response::new())
 }
@@ -51,7 +51,7 @@ pub async fn delete_alias_route(
         ));
     }
 
-    services().rooms.set_alias(&body.room_alias, None)?;
+    services().rooms.alias.remove_alias(&body.room_alias)?;
 
     // TODO: update alt_aliases?
 
@@ -88,7 +88,7 @@ pub(crate) async fn get_alias_helper(
     }
 
     let mut room_id = None;
-    match services().rooms.id_from_alias(room_alias)? {
+    match services().rooms.alias.resolve_local_alias(room_alias)? {
         Some(r) => room_id = Some(r),
         None => {
             for (_id, registration) in services().appservice.all()? {
@@ -115,7 +115,7 @@ pub(crate) async fn get_alias_helper(
                         .await
                         .is_ok()
                 {
-                    room_id = Some(services().rooms.id_from_alias(room_alias)?.ok_or_else(|| {
+                    room_id = Some(services().rooms.alias.resolve_local_alias(room_alias)?.ok_or_else(|| {
                         Error::bad_config("Appservice lied to us. Room does not exist.")
                     })?);
                     break;
diff --git a/src/api/client_server/context.rs b/src/api/client_server/context.rs
index 3551dcf..c407c71 100644
--- a/src/api/client_server/context.rs
+++ b/src/api/client_server/context.rs
@@ -29,16 +29,18 @@ pub async fn get_context_route(
 
     let base_pdu_id = services()
         .rooms
+        .timeline
         .get_pdu_id(&body.event_id)?
         .ok_or(Error::BadRequest(
             ErrorKind::NotFound,
             "Base event id not found.",
         ))?;
 
-    let base_token = services().rooms.pdu_count(&base_pdu_id)?;
+    let base_token = services().rooms.timeline.pdu_count(&base_pdu_id)?;
 
     let base_event = services()
         .rooms
+        .timeline
         .get_pdu_from_id(&base_pdu_id)?
         .ok_or(Error::BadRequest(
             ErrorKind::NotFound,
@@ -47,14 +49,14 @@ pub async fn get_context_route(
 
     let room_id = base_event.room_id.clone();
 
-    if !services().rooms.is_joined(sender_user, &room_id)? {
+    if !services().rooms.state_cache.is_joined(sender_user, &room_id)? {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "You don't have permission to view this room.",
         ));
     }
 
-    if !services().rooms.lazy_load_was_sent_before(
+    if !services().rooms.lazy_loading.lazy_load_was_sent_before(
         sender_user,
         sender_device,
         &room_id,
@@ -68,6 +70,7 @@ pub async fn get_context_route(
 
     let events_before: Vec<_> = services()
         .rooms
+        .timeline
         .pdus_until(sender_user, &room_id, base_token)?
         .take(
             u32::try_from(body.limit).map_err(|_| {
@@ -79,7 +82,7 @@ pub async fn get_context_route(
         .collect();
 
     for (_, event) in &events_before {
-        if !services().rooms.lazy_load_was_sent_before(
+        if !services().rooms.lazy_loading.lazy_load_was_sent_before(
             sender_user,
             sender_device,
             &room_id,
@@ -92,7 +95,7 @@ pub async fn get_context_route(
 
     let start_token = events_before
         .last()
-        .and_then(|(pdu_id, _)| services().rooms.pdu_count(pdu_id).ok())
+        .and_then(|(pdu_id, _)| services().rooms.timeline.pdu_count(pdu_id).ok())
         .map(|count| count.to_string());
 
     let events_before: Vec<_> = events_before
@@ -102,6 +105,7 @@ pub async fn get_context_route(
 
     let events_after: Vec<_> = services()
         .rooms
+        .timeline
         .pdus_after(sender_user, &room_id, base_token)?
         .take(
             u32::try_from(body.limit).map_err(|_| {
@@ -113,7 +117,7 @@ pub async fn get_context_route(
         .collect();
 
     for (_, event) in &events_after {
-        if !services().rooms.lazy_load_was_sent_before(
+        if !services().rooms.lazy_loading.lazy_load_was_sent_before(
             sender_user,
             sender_device,
             &room_id,
@@ -124,7 +128,7 @@ pub async fn get_context_route(
         }
     }
 
-    let shortstatehash = match services().rooms.pdu_shortstatehash(
+    let shortstatehash = match services().rooms.state_accessor.pdu_shortstatehash(
         events_after
             .last()
             .map_or(&*body.event_id, |(_, e)| &*e.event_id),
@@ -132,15 +136,16 @@ pub async fn get_context_route(
         Some(s) => s,
         None => services()
             .rooms
-            .current_shortstatehash(&room_id)?
+            .state
+            .get_room_shortstatehash(&room_id)?
             .expect("All rooms have state"),
     };
 
-    let state_ids = services().rooms.state_full_ids(shortstatehash).await?;
+    let state_ids = services().rooms.state_accessor.state_full_ids(shortstatehash).await?;
 
     let end_token = events_after
         .last()
-        .and_then(|(pdu_id, _)| services().rooms.pdu_count(pdu_id).ok())
+        .and_then(|(pdu_id, _)| services().rooms.timeline.pdu_count(pdu_id).ok())
         .map(|count| count.to_string());
 
     let events_after: Vec<_> = events_after
@@ -151,10 +156,10 @@ pub async fn get_context_route(
     let mut state = Vec::new();
 
     for (shortstatekey, id) in state_ids {
-        let (event_type, state_key) = services().rooms.get_statekey_from_short(shortstatekey)?;
+        let (event_type, state_key) = services().rooms.short.get_statekey_from_short(shortstatekey)?;
 
         if event_type != StateEventType::RoomMember {
-            let pdu = match services().rooms.get_pdu(&id)? {
+            let pdu = match services().rooms.timeline.get_pdu(&id)? {
                 Some(pdu) => pdu,
                 None => {
                     error!("Pdu in state not found: {}", id);
@@ -163,7 +168,7 @@ pub async fn get_context_route(
             };
             state.push(pdu.to_state_event());
         } else if !lazy_load_enabled || lazy_loaded.contains(&state_key) {
-            let pdu = match services().rooms.get_pdu(&id)? {
+            let pdu = match services().rooms.timeline.get_pdu(&id)? {
                 Some(pdu) => pdu,
                 None => {
                     error!("Pdu in state not found: {}", id);
diff --git a/src/api/client_server/directory.rs b/src/api/client_server/directory.rs
index 87493fa..2a60f67 100644
--- a/src/api/client_server/directory.rs
+++ b/src/api/client_server/directory.rs
@@ -86,10 +86,10 @@ pub async fn set_room_visibility_route(
 
     match &body.visibility {
         room::Visibility::Public => {
-            services().rooms.set_public(&body.room_id, true)?;
+            services().rooms.directory.set_public(&body.room_id)?;
             info!("{} made {} public", sender_user, body.room_id);
         }
-        room::Visibility::Private => services().rooms.set_public(&body.room_id, false)?,
+        room::Visibility::Private => services().rooms.directory.set_not_public(&body.room_id)?,
         _ => {
             return Err(Error::BadRequest(
                 ErrorKind::InvalidParam,
@@ -108,7 +108,7 @@ pub async fn get_room_visibility_route(
     body: Ruma<get_room_visibility::v3::IncomingRequest>,
 ) -> Result<get_room_visibility::v3::Response> {
     Ok(get_room_visibility::v3::Response {
-        visibility: if services().rooms.is_public_room(&body.room_id)? {
+        visibility: if services().rooms.directory.is_public_room(&body.room_id)? {
             room::Visibility::Public
         } else {
             room::Visibility::Private
@@ -176,6 +176,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
 
     let mut all_rooms: Vec<_> = services()
         .rooms
+        .directory
         .public_rooms()
         .map(|room_id| {
             let room_id = room_id?;
@@ -183,6 +184,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
             let chunk = PublicRoomsChunk {
                 canonical_alias: services()
                     .rooms
+                    .state_accessor
                     .room_state_get(&room_id, &StateEventType::RoomCanonicalAlias, "")?
                     .map_or(Ok(None), |s| {
                         serde_json::from_str(s.content.get())
@@ -193,6 +195,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                     })?,
                 name: services()
                     .rooms
+                    .state_accessor
                     .room_state_get(&room_id, &StateEventType::RoomName, "")?
                     .map_or(Ok(None), |s| {
                         serde_json::from_str(s.content.get())
@@ -203,6 +206,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                     })?,
                 num_joined_members: services()
                     .rooms
+                    .state_cache
                     .room_joined_count(&room_id)?
                     .unwrap_or_else(|| {
                         warn!("Room {} has no member count", room_id);
@@ -212,6 +216,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                     .expect("user count should not be that big"),
                 topic: services()
                     .rooms
+                    .state_accessor
                     .room_state_get(&room_id, &StateEventType::RoomTopic, "")?
                     .map_or(Ok(None), |s| {
                         serde_json::from_str(s.content.get())
@@ -222,6 +227,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                     })?,
                 world_readable: services()
                     .rooms
+                    .state_accessor
                     .room_state_get(&room_id, &StateEventType::RoomHistoryVisibility, "")?
                     .map_or(Ok(false), |s| {
                         serde_json::from_str(s.content.get())
@@ -236,6 +242,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                     })?,
                 guest_can_join: services()
                     .rooms
+                    .state_accessor
                     .room_state_get(&room_id, &StateEventType::RoomGuestAccess, "")?
                     .map_or(Ok(false), |s| {
                         serde_json::from_str(s.content.get())
@@ -248,6 +255,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                     })?,
                 avatar_url: services()
                     .rooms
+                    .state_accessor
                     .room_state_get(&room_id, &StateEventType::RoomAvatar, "")?
                     .map(|s| {
                         serde_json::from_str(s.content.get())
@@ -261,6 +269,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                     .flatten(),
                 join_rule: services()
                     .rooms
+                    .state_accessor
                     .room_state_get(&room_id, &StateEventType::RoomJoinRules, "")?
                     .map(|s| {
                         serde_json::from_str(s.content.get())
diff --git a/src/api/client_server/keys.rs b/src/api/client_server/keys.rs
index 698bd1e..4ce5d4c 100644
--- a/src/api/client_server/keys.rs
+++ b/src/api/client_server/keys.rs
@@ -230,7 +230,7 @@ pub async fn get_key_changes_route(
             .filter_map(|r| r.ok()),
     );
 
-    for room_id in services().rooms.rooms_joined(sender_user).filter_map(|r| r.ok()) {
+    for room_id in services().rooms.state_cache.rooms_joined(sender_user).filter_map(|r| r.ok()) {
         device_list_updates.extend(
             services().users
                 .keys_changed(
diff --git a/src/api/client_server/media.rs b/src/api/client_server/media.rs
index f0da084..d6e8213 100644
--- a/src/api/client_server/media.rs
+++ b/src/api/client_server/media.rs
@@ -99,7 +99,7 @@ pub async fn get_content_route(
         content_disposition,
         content_type,
         file,
-    }) = services().media.get(&mxc).await?
+    }) = services().media.get(mxc.clone()).await?
     {
         Ok(get_content::v3::Response {
             file,
@@ -129,7 +129,7 @@ pub async fn get_content_as_filename_route(
         content_disposition: _,
         content_type,
         file,
-    }) = services().media.get(&mxc).await?
+    }) = services().media.get(mxc.clone()).await?
     {
         Ok(get_content_as_filename::v3::Response {
             file,
@@ -165,7 +165,7 @@ pub async fn get_content_thumbnail_route(
     }) = services()
         .media
         .get_thumbnail(
-            &mxc,
+            mxc.clone(),
             body.width
                 .try_into()
                 .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Width is invalid."))?,
diff --git a/src/api/client_server/membership.rs b/src/api/client_server/membership.rs
index b000ec1..d6f820a 100644
--- a/src/api/client_server/membership.rs
+++ b/src/api/client_server/membership.rs
@@ -30,7 +30,7 @@ use std::{
 };
 use tracing::{debug, error, warn};
 
-use crate::{services, PduEvent, service::pdu::{gen_event_id_canonical_json, PduBuilder}, Error, api::{server_server}, utils, Ruma};
+use crate::{Result, services, PduEvent, service::pdu::{gen_event_id_canonical_json, PduBuilder}, Error, api::{server_server, client_server}, utils, Ruma};
 
 use super::get_alias_helper;
 
@@ -48,6 +48,7 @@ pub async fn join_room_by_id_route(
     let mut servers = Vec::new(); // There is no body.server_name for /roomId/join
     servers.extend(
         services().rooms
+        .state_cache
             .invite_state(sender_user, &body.room_id)?
             .unwrap_or_default()
             .iter()
@@ -88,6 +89,7 @@ pub async fn join_room_by_id_or_alias_route(
             let mut servers = body.server_name.clone();
             servers.extend(
                 services().rooms
+                .state_cache
                     .invite_state(sender_user, &room_id)?
                     .unwrap_or_default()
                     .iter()
@@ -131,7 +133,7 @@ pub async fn leave_room_route(
 ) -> Result<leave_room::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    services().rooms.leave_room(sender_user, &body.room_id).await?;
+    leave_room(sender_user, &body.room_id).await?;
 
     Ok(leave_room::v3::Response::new())
 }
@@ -162,6 +164,7 @@ pub async fn kick_user_route(
 
     let mut event: RoomMemberEventContent = serde_json::from_str(
         services().rooms
+        .state_accessor
             .room_state_get(
                 &body.room_id,
                 &StateEventType::RoomMember,
@@ -189,7 +192,7 @@ pub async fn kick_user_route(
     );
     let state_lock = mutex_state.lock().await;
 
-    services().rooms.build_and_append_pdu(
+    services().rooms.timeline.build_and_append_pdu(
         PduBuilder {
             event_type: RoomEventType::RoomMember,
             content: to_raw_value(&event).expect("event is valid, we just created it"),
@@ -219,6 +222,7 @@ pub async fn ban_user_route(
 
     let event = services()
         .rooms
+        .state_accessor
         .room_state_get(
             &body.room_id,
             &StateEventType::RoomMember,
@@ -255,7 +259,7 @@ pub async fn ban_user_route(
     );
     let state_lock = mutex_state.lock().await;
 
-    services().rooms.build_and_append_pdu(
+    services().rooms.timeline.build_and_append_pdu(
         PduBuilder {
             event_type: RoomEventType::RoomMember,
             content: to_raw_value(&event).expect("event is valid, we just created it"),
@@ -283,6 +287,7 @@ pub async fn unban_user_route(
 
     let mut event: RoomMemberEventContent = serde_json::from_str(
         services().rooms
+        .state_accessor
             .room_state_get(
                 &body.room_id,
                 &StateEventType::RoomMember,
@@ -309,7 +314,7 @@ pub async fn unban_user_route(
     );
     let state_lock = mutex_state.lock().await;
 
-    services().rooms.build_and_append_pdu(
+    services().rooms.timeline.build_and_append_pdu(
         PduBuilder {
             event_type: RoomEventType::RoomMember,
             content: to_raw_value(&event).expect("event is valid, we just created it"),
@@ -340,7 +345,7 @@ pub async fn forget_room_route(
 ) -> Result<forget_room::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    services().rooms.forget(&body.room_id, sender_user)?;
+    services().rooms.state_cache.forget(&body.room_id, sender_user)?;
 
     Ok(forget_room::v3::Response::new())
 }
@@ -356,6 +361,7 @@ pub async fn joined_rooms_route(
     Ok(joined_rooms::v3::Response {
         joined_rooms: services()
             .rooms
+            .state_cache
             .rooms_joined(sender_user)
             .filter_map(|r| r.ok())
             .collect(),
@@ -373,7 +379,7 @@ pub async fn get_member_events_route(
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
     // TODO: check history visibility?
-    if !services().rooms.is_joined(sender_user, &body.room_id)? {
+    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)? {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "You don't have permission to view this room.",
@@ -383,6 +389,7 @@ pub async fn get_member_events_route(
     Ok(get_member_events::v3::Response {
         chunk: services()
             .rooms
+            .state_accessor
             .room_state_full(&body.room_id)
             .await?
             .iter()
@@ -403,7 +410,7 @@ pub async fn joined_members_route(
 ) -> Result<joined_members::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    if !services().rooms.is_joined(sender_user, &body.room_id)? {
+    if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)? {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "You aren't a member of the room.",
@@ -411,7 +418,7 @@ pub async fn joined_members_route(
     }
 
     let mut joined = BTreeMap::new();
-    for user_id in services().rooms.room_members(&body.room_id).filter_map(|r| r.ok()) {
+    for user_id in services().rooms.state_cache.room_members(&body.room_id).filter_map(|r| r.ok()) {
         let display_name = services().users.displayname(&user_id)?;
         let avatar_url = services().users.avatar_url(&user_id)?;
 
@@ -446,7 +453,7 @@ async fn join_room_by_id_helper(
     let state_lock = mutex_state.lock().await;
 
     // Ask a remote server if we don't have this room
-    if !services().rooms.exists(room_id)? {
+    if !services().rooms.metadata.exists(room_id)? {
         let mut make_join_response_and_server = Err(Error::BadServerResponse(
             "No server available to assist in joining.",
         ));
@@ -553,7 +560,7 @@ async fn join_room_by_id_helper(
             )
             .await?;
 
-        services().rooms.get_or_create_shortroomid(room_id, &services().globals)?;
+        services().rooms.short.get_or_create_shortroomid(room_id)?;
 
         let parsed_pdu = PduEvent::from_id_val(event_id, join_event.clone())
             .map_err(|_| Error::BadServerResponse("Invalid join event PDU."))?;
@@ -586,7 +593,7 @@ async fn join_room_by_id_helper(
 
             services().rooms.add_pdu_outlier(&event_id, &value)?;
             if let Some(state_key) = &pdu.state_key {
-                let shortstatekey = services().rooms.get_or_create_shortstatekey(
+                let shortstatekey = services().rooms.short.get_or_create_shortstatekey(
                     &pdu.kind.to_string().into(),
                     state_key,
                 )?;
@@ -594,7 +601,7 @@ async fn join_room_by_id_helper(
             }
         }
 
-        let incoming_shortstatekey = services().rooms.get_or_create_shortstatekey(
+        let incoming_shortstatekey = services().rooms.short.get_or_create_shortstatekey(
             &parsed_pdu.kind.to_string().into(),
             parsed_pdu
                 .state_key
@@ -606,6 +613,7 @@ async fn join_room_by_id_helper(
 
         let create_shortstatekey = services()
             .rooms
+            .short
             .get_shortstatekey(&StateEventType::RoomCreate, "")?
             .expect("Room exists");
 
@@ -613,7 +621,7 @@ async fn join_room_by_id_helper(
             return Err(Error::BadServerResponse("State contained no create event."));
         }
 
-        services().rooms.force_state(
+        services().rooms.state.force_state(
             room_id,
             state
                 .into_iter()
@@ -780,7 +788,7 @@ pub(crate) async fn invite_helper<'a>(
                 redacts: None,
             }, sender_user, room_id, &state_lock);
 
-            let invite_room_state = services().rooms.calculate_invite_state(&pdu)?;
+            let invite_room_state = services().rooms.state.calculate_invite_state(&pdu)?;
 
             drop(state_lock);
 
diff --git a/src/api/client_server/room.rs b/src/api/client_server/room.rs
index 14affc6..f8d0602 100644
--- a/src/api/client_server/room.rs
+++ b/src/api/client_server/room.rs
@@ -87,7 +87,7 @@ pub async fn create_room_route(
                             Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias.")
                         })?;
 
-                if services().rooms.id_from_alias(&alias)?.is_some() {
+                if services().rooms.alias.resolve_local_alias(&alias)?.is_some() {
                     Err(Error::BadRequest(
                         ErrorKind::RoomInUse,
                         "Room alias already exists.",
diff --git a/src/api/client_server/state.rs b/src/api/client_server/state.rs
index 4e8d594..b2dfe2a 100644
--- a/src/api/client_server/state.rs
+++ b/src/api/client_server/state.rs
@@ -246,7 +246,7 @@ async fn send_state_event_for_key_helper(
             if alias.server_name() != services().globals.server_name()
                 || services()
                     .rooms
-                    .id_from_alias(&alias)?
+                    .alias.resolve_local_alias(&alias)?
                     .filter(|room| room == room_id) // Make sure it's the right room
                     .is_none()
             {
diff --git a/src/api/server_server.rs b/src/api/server_server.rs
index 776777d..bacc1ac 100644
--- a/src/api/server_server.rs
+++ b/src/api/server_server.rs
@@ -1842,7 +1842,7 @@ pub async fn get_room_information_route(
 
     let room_id = services()
         .rooms
-        .id_from_alias(&body.room_alias)?
+        .alias.resolve_local_alias(&body.room_alias)?
         .ok_or(Error::BadRequest(
             ErrorKind::NotFound,
             "Room alias not found.",