matrix-rust-sdk

public

Star0

Fork 0

Watch0

37 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `7a0452c1960f`

tarball

atagen <boss@atagen.co>2026-10-26 07:33 UTC

3 files changed+36-3

room: never wait on the server to label an undecryptable event

crypto_context_info awaited backups().exists_on_server() for every UTD the timeline handles, under its state lock, and with nothing cached that is a room_keys/version request. Opening an encrypted room waited on it, and an erroring endpoint cost one request per UTD in series. It now reads the cache or guesses from the local backup state while one background fetch fills it. The answer only feeds UtdCause's historical labels.

Modified file: crates/matrix-sdk/src/encryption/backups/mod.rs+30 additions@@ -416,6 +416,36 @@ impl Backups {
         Ok(exists_on_server)
     }
 
+    /// The cached answer to [`Self::exists_on_server`], or while nothing is cached, whether
+    /// backups are enabled locally, with a fetch filling the cache in the background.
+    ///
+    /// For callers that must not wait on the network, such as UTD classification, which
+    /// runs under the timeline's state lock for every undecryptable event it handles.
+    pub(crate) fn exists_on_server_without_waiting(&self) -> bool {
+        use std::sync::atomic::Ordering;
+
+        let state = &self.client.inner.e2ee.backup_state;
+        if let Some(cached) = state.backup_exists_on_server() {
+            return cached;
+        }
+        if !state.refreshing_exists_on_server.swap(true, Ordering::AcqRel) {
+            let backups = self.clone();
+            matrix_sdk_common::executor::spawn(async move {
+                if let Err(error) = backups.fetch_exists_on_server().await {
+                    warn!("Couldn't check whether a backup exists on the server: {error:?}");
+                }
+                backups
+                    .client
+                    .inner
+                    .e2ee
+                    .backup_state
+                    .refreshing_exists_on_server
+                    .store(false, Ordering::Release);
+            });
+        }
+        self.state() == BackupState::Enabled
+    }
+
     /// Does a backup exist on the server?
     ///
     /// This method is identical to [`Self::fetch_exists_on_server`] except that

Modified file: crates/matrix-sdk/src/encryption/backups/types.rs+5 additions−1 deletions@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use std::{
-    sync::{Arc, RwLock},
+    sync::{Arc, RwLock, atomic::AtomicBool},
     time::Duration,
 };
 
@@ -61,6 +61,9 @@ pub(crate) struct BackupClientState {
     /// on the server was changed by some other client, we will have a old
     /// value.
     pub(super) backup_exists_on_server: RwLock<Option<bool>>,
+
+    /// Whether a background fetch is filling `backup_exists_on_server`.
+    pub(super) refreshing_exists_on_server: AtomicBool,
 }
 
 impl BackupClientState {
@@ -96,6 +99,7 @@ impl Default for BackupClientState {
             global_state: Default::default(),
             room_keys_broadcaster: broadcast::Sender::new(100),
             backup_exists_on_server: RwLock::new(None),
+            refreshing_exists_on_server: AtomicBool::new(false),
         }
     }
 }

Modified file: crates/matrix-sdk/src/room/mod.rs+1 additions−2 deletions@@ -1146,8 +1146,7 @@ impl Room {
             _ => true,
         };
 
-        let backup_exists_on_server =
-            encryption.backups().exists_on_server().await.unwrap_or(false);
+        let backup_exists_on_server = encryption.backups().exists_on_server_without_waiting();
 
         CryptoContextInfo {
             device_creation_ts: encryption.device_creation_timestamp().await,

matrix-rust-sdk

Commit 7a0452c1960f

Commit `7a0452c1960f`