Merge branch 'main' into johannes/send-queue-media-progress

Author: Johennes

Cargo.lock

@@ -59,7 +59,7 @@ reqwest = { version = "0.12.12", default-features = false }
 rmp-serde = "1.3.0"
 # Be careful to use commits from the https://github.com/ruma/ruma/tree/ruma-0.12
 # branch until a proper release with breaking changes happens.
-ruma = { git = "https://github.com/ruma/ruma", rev = "a8fd1b0322649bf59e2a5cfc73ab4fe46b21edd7", features = [
+ruma = { git = "https://github.com/ruma/ruma", rev = "b4941a991919685345646a230b05b985338ec3f8", features = [
     "client-api-c",
     "compat-upload-signatures",
     "compat-user-id",
@@ -74,8 +74,9 @@ ruma = { git = "https://github.com/ruma/ruma", rev = "a8fd1b0322649bf59e2a5cfc73
     "unstable-msc4140",
     "unstable-msc4171",
     "unstable-msc4278",
+    "unstable-msc4286",
     ] }
-ruma-common = { git = "https://github.com/ruma/ruma", rev = "a8fd1b0322649bf59e2a5cfc73ab4fe46b21edd7" }
+ruma-common = { git = "https://github.com/ruma/ruma", rev = "b4941a991919685345646a230b05b985338ec3f8" }
 sentry = "0.36.0"
 sentry-tracing = "0.36.0"
 serde = "1.0.217"

Cargo.toml

@@ -1,6 +1,7 @@
 use std::{
     collections::HashMap,
     fmt::Debug,
+    path::PathBuf,
     sync::{Arc, OnceLock, RwLock},
     time::Duration,
 };
@@ -38,6 +39,7 @@ use matrix_sdk::{
     sliding_sync::Version as SdkSlidingSyncVersion,
     store::RoomLoadSettings as SdkRoomLoadSettings,
     AuthApi, AuthSession, Client as MatrixClient, SessionChange, SessionTokens,
+    STATE_STORE_DATABASE_NAME,
 };
 use matrix_sdk_ui::{
     notification_client::{
@@ -223,13 +225,18 @@ pub struct Client {
     pub(crate) utd_hook_manager: OnceLock<Arc<UtdHookManager>>,
     session_verification_controller:
         Arc<tokio::sync::RwLock<Option<SessionVerificationController>>>,
+    /// The path to the directory where the state store and the crypto store are
+    /// located, if the `Client` instance has been built with a SQLite store
+    /// backend.
+    store_path: Option<PathBuf>,
 }
 
 impl Client {
     pub async fn new(
         sdk_client: MatrixClient,
         enable_oidc_refresh_lock: bool,
         session_delegate: Option<Arc<dyn ClientSessionDelegate>>,
+        store_path: Option<PathBuf>,
     ) -> Result<Self, ClientError> {
         let session_verification_controller: Arc<
             tokio::sync::RwLock<Option<SessionVerificationController>>,
@@ -267,6 +274,7 @@ impl Client {
             delegate: OnceLock::new(),
             utd_hook_manager: OnceLock::new(),
             session_verification_controller,
+            store_path,
         };
 
         if enable_oidc_refresh_lock {
@@ -1408,25 +1416,70 @@ impl Client {
 
     /// Clear all the non-critical caches for this Client instance.
     ///
+    /// WARNING: This will clear all the caches, including the base store (state
+    /// store), so callers must make sure that any sync is inactive before
+    /// calling this method. In particular, the `SyncService` must not be
+    /// running. After the method returns, the Client will be in an unstable
+    /// state, and it is required that the caller reinstantiates a new
+    /// Client instance, be it via dropping the previous and re-creating it,
+    /// restarting their application, or any other similar means.
+    ///
+    /// - This will get rid of the backing state store file, if provided.
     /// - This will empty all the room's persisted event caches, so all rooms
     ///   will start as if they were empty.
     /// - This will empty the media cache according to the current media
     ///   retention policy.
     pub async fn clear_caches(&self) -> Result<(), ClientError> {
-        let closure = async || -> Result<_, EventCacheError> {
+        let closure = async || -> Result<_, ClientError> {
             // Clean up the media cache according to the current media retention policy.
-            self.inner.event_cache_store().lock().await?.clean_up_media_cache().await?;
+            self.inner
+                .event_cache_store()
+                .lock()
+                .await
+                .map_err(EventCacheError::from)?
+                .clean_up_media_cache()
+                .await
+                .map_err(EventCacheError::from)?;
 
             // Clear all the room chunks. It's important to *not* call
             // `EventCacheStore::clear_all_rooms_chunks` here, because there might be live
             // observers of the linked chunks, and that would cause some very bad state
             // mismatch.
             self.inner.event_cache().clear_all_rooms().await?;
 
+            // Delete the state store file, if it exists.
+            if let Some(store_path) = &self.store_path {
+                debug!("Removing the state store: {}", store_path.display());
+
+                // The state store and the crypto store both live in the same store path, so we
+                // can't blindly delete the directory.
+                //
+                // Delete the state store SQLite file, as well as the write-ahead log (WAL) and
+                // shared-memory (SHM) files, if they exist.
+
+                for file_name in [
+                    PathBuf::from(STATE_STORE_DATABASE_NAME),
+                    PathBuf::from(format!("{STATE_STORE_DATABASE_NAME}.wal")),
+                    PathBuf::from(format!("{STATE_STORE_DATABASE_NAME}.shm")),
+                ] {
+                    let file_path = store_path.join(file_name);
+                    if file_path.exists() {
+                        debug!("Removing file: {}", file_path.display());
+                        std::fs::remove_file(&file_path).map_err(|err| ClientError::Generic {
+                            msg: format!(
+                                "couldn't delete the state store file {}: {err}",
+                                file_path.display()
+                            ),
+                            details: None,
+                        })?;
+                    }
+                }
+            }
+
             Ok(())
         };
 
-        Ok(closure().await?)
+        closure().await
     }
 
     /// Checks if the server supports the report room API.

bindings/matrix-sdk-ffi/src/client.rs

@@ -568,14 +568,16 @@ impl ClientBuilder {
                 inner_builder.cross_process_store_locks_holder_name(holder_name.clone());
         }
 
-        if let Some(session_paths) = &builder.session_paths {
+        let store_path = if let Some(session_paths) = &builder.session_paths {
+            // This is the path where both the state store and the crypto store will live.
             let data_path = Path::new(&session_paths.data_path);
+            // This is the path where the event cache store will live.
             let cache_path = Path::new(&session_paths.cache_path);
 
             debug!(
                 data_path = %data_path.to_string_lossy(),
-                cache_path = %cache_path.to_string_lossy(),
-                "Creating directories for data and cache stores.",
+                event_cache_path = %cache_path.to_string_lossy(),
+                "Creating directories for data (state and crypto) and cache stores.",
             );
 
             fs::create_dir_all(data_path)?;
@@ -604,9 +606,12 @@ impl ClientBuilder {
 
             inner_builder = inner_builder
                 .sqlite_store_with_config_and_cache_path(sqlite_store_config, Some(cache_path));
+
+            Some(data_path.to_owned())
         } else {
             debug!("Not using a store path.");
-        }
+            None
+        };
 
         // Determine server either from URL, server name or user ID.
         inner_builder = match builder.homeserver_cfg {
@@ -718,8 +723,13 @@ impl ClientBuilder {
         let sdk_client = inner_builder.build().await?;
 
         Ok(Arc::new(
-            Client::new(sdk_client, builder.enable_oidc_refresh_lock, builder.session_delegate)
-                .await?,
+            Client::new(
+                sdk_client,
+                builder.enable_oidc_refresh_lock,
+                builder.session_delegate,
+                store_path,
+            )
+            .await?,
         ))
     }
 

bindings/matrix-sdk-ffi/src/client_builder.rs

@@ -33,7 +33,7 @@ use matrix_sdk::{
 };
 use matrix_sdk_ui::timeline::{
     self, AttachmentSource, EventItemOrigin, EventSendProgress as SdkEventSendProgress, Profile,
-    RepliedToEvent, TimelineDetails, TimelineUniqueId as SdkTimelineUniqueId,
+    TimelineDetails, TimelineUniqueId as SdkTimelineUniqueId,
 };
 use mime::Mime;
 use reply::{InReplyToDetails, RepliedToEventDetails};

bindings/matrix-sdk-ffi/src/timeline/mod.rs

@@ -15,6 +15,8 @@
 pub mod extensions;
 
 use std::collections::BTreeMap;
+#[cfg(feature = "e2e-encryption")]
+use std::collections::BTreeSet;
 
 #[cfg(feature = "e2e-encryption")]
 use matrix_sdk_common::deserialized_responses::TimelineEvent;
@@ -104,12 +106,18 @@ pub async fn update_any_room(
     room_info.mark_state_partially_synced();
     room_info.handle_encryption_state(requested_required_states.for_room(room_id));
 
-    #[cfg_attr(not(feature = "e2e-encryption"), allow(unused))]
-    let new_user_ids = state_events::sync::dispatch_and_get_new_users(
+    #[cfg(feature = "e2e-encryption")]
+    let mut new_user_ids = BTreeSet::new();
+
+    #[cfg(not(feature = "e2e-encryption"))]
+    let mut new_user_ids = ();
+
+    state_events::sync::dispatch(
         context,
         (&raw_state_events, &state_events),
         &mut room_info,
         ambiguity_cache,
+        &mut new_user_ids,
     )
     .await?;
 

crates/matrix-sdk-base/src/response_processors/room/msc4186/mod.rs

@@ -63,11 +63,14 @@ pub async fn update_joined_room(
 
     let (raw_state_events, state_events) = state_events::sync::collect(&joined_room.state.events);
 
-    let mut new_user_ids = state_events::sync::dispatch_and_get_new_users(
+    let mut new_user_ids = BTreeSet::new();
+
+    state_events::sync::dispatch(
         context,
         (&raw_state_events, &state_events),
         &mut room_info,
         ambiguity_cache,
+        &mut new_user_ids,
     )
     .await?;
 
@@ -80,15 +83,14 @@ pub async fn update_joined_room(
     let (raw_state_events_from_timeline, state_events_from_timeline) =
         state_events::sync::collect_from_timeline(&joined_room.timeline.events);
 
-    let mut other_new_user_ids = state_events::sync::dispatch_and_get_new_users(
+    state_events::sync::dispatch(
         context,
         (&raw_state_events_from_timeline, &state_events_from_timeline),
         &mut room_info,
         ambiguity_cache,
+        &mut new_user_ids,
     )
     .await?;
-    new_user_ids.append(&mut other_new_user_ids);
-    updated_members_in_room.insert(room_id.to_owned(), new_user_ids.clone());
 
     #[cfg(feature = "e2e-encryption")]
     let olm_machine = e2ee.olm_machine;
@@ -132,6 +134,8 @@ pub async fn update_joined_room(
     )
     .await?;
 
+    updated_members_in_room.insert(room_id.to_owned(), new_user_ids);
+
     let notification_count = joined_room.unread_notifications.into();
     room_info.update_notification_count(notification_count);
 
@@ -175,22 +179,24 @@ pub async fn update_left_room(
 
     let (raw_state_events, state_events) = state_events::sync::collect(&left_room.state.events);
 
-    let _ = state_events::sync::dispatch_and_get_new_users(
+    state_events::sync::dispatch(
         context,
         (&raw_state_events, &state_events),
         &mut room_info,
         ambiguity_cache,
+        &mut (),
     )
     .await?;
 
     let (raw_state_events_from_timeline, state_events_from_timeline) =
         state_events::sync::collect_from_timeline(&left_room.timeline.events);
 
-    let _ = state_events::sync::dispatch_and_get_new_users(
+    state_events::sync::dispatch(
         context,
         (&raw_state_events_from_timeline, &state_events_from_timeline),
         &mut room_info,
         ambiguity_cache,
+        &mut (),
     )
     .await?;