Merge branch 'main' into feat-sliding-sync-room

Author: Hywan

Cargo.lock

@@ -11,6 +11,7 @@ publish = false
 criterion = { version = "0.4.0", features = ["async", "async_tokio", "html_reports"] }
 matrix-sdk-crypto = { path = "../crates/matrix-sdk-crypto", version = "0.6.0"}
 matrix-sdk-sqlite = { path = "../crates/matrix-sdk-sqlite", version = "0.1.0", default-features = false, features = ["crypto-store"] }
+matrix-sdk-sled = { path = "../crates/matrix-sdk-sled", version = "0.2.0", default-features = false, features = ["crypto-store"] }
 matrix-sdk-test = { path = "../testing/matrix-sdk-test", version = "0.6.0"}
 ruma = { workspace = true }
 serde_json = { workspace = true }

benchmarks/Cargo.toml

@@ -2,6 +2,7 @@ use std::{ops::Deref, sync::Arc};
 
 use criterion::*;
 use matrix_sdk_crypto::{EncryptionSettings, OlmMachine};
+use matrix_sdk_sled::SledCryptoStore;
 use matrix_sdk_sqlite::SqliteCryptoStore;
 use matrix_sdk_test::response_from_file;
 use ruma::{
@@ -65,11 +66,15 @@ pub fn keys_query(c: &mut Criterion) {
 
     let name = format!("{count} device and cross signing keys");
 
+    // Benchmark memory store.
+
     group.bench_with_input(BenchmarkId::new("memory store", &name), &response, |b, response| {
         b.to_async(&runtime)
             .iter(|| async { machine.mark_request_as_sent(&txn_id, response).await.unwrap() })
     });
 
+    // Benchmark sqlite store.
+
     let dir = tempfile::tempdir().unwrap();
     let store = Arc::new(runtime.block_on(SqliteCryptoStore::open(dir.path(), None)).unwrap());
     let machine =
@@ -80,6 +85,23 @@ pub fn keys_query(c: &mut Criterion) {
             .iter(|| async { machine.mark_request_as_sent(&txn_id, response).await.unwrap() })
     });
 
+    {
+        let _guard = runtime.enter();
+        drop(machine);
+    }
+
+    // Benchmark (deprecated) sled store.
+
+    let dir = tempfile::tempdir().unwrap();
+    let store = Arc::new(runtime.block_on(SledCryptoStore::open(dir.path(), None)).unwrap());
+    let machine =
+        runtime.block_on(OlmMachine::with_store(alice_id(), alice_device_id(), store)).unwrap();
+
+    group.bench_with_input(BenchmarkId::new("sled store", &name), &response, |b, response| {
+        b.to_async(&runtime)
+            .iter(|| async { machine.mark_request_as_sent(&txn_id, response).await.unwrap() })
+    });
+
     group.finish()
 }
 
@@ -108,7 +130,10 @@ pub fn keys_claiming(c: &mut Criterion) {
                 (machine, &runtime, &txn_id)
             },
             move |(machine, runtime, txn_id)| {
-                runtime.block_on(machine.mark_request_as_sent(txn_id, response)).unwrap()
+                runtime.block_on(async {
+                    machine.mark_request_as_sent(txn_id, response).await.unwrap();
+                    drop(machine);
+                })
             },
             BatchSize::SmallInput,
         )
@@ -129,6 +154,31 @@ pub fn keys_claiming(c: &mut Criterion) {
                     .unwrap();
                 (machine, &runtime, &txn_id)
             },
+            move |(machine, runtime, txn_id)| {
+                runtime.block_on(async {
+                    machine.mark_request_as_sent(txn_id, response).await.unwrap();
+                    drop(machine)
+                })
+            },
+            BatchSize::SmallInput,
+        )
+    });
+
+    group.bench_with_input(BenchmarkId::new("sled store", &name), &response, |b, response| {
+        b.iter_batched(
+            || {
+                let dir = tempfile::tempdir().unwrap();
+                let store =
+                    Arc::new(runtime.block_on(SledCryptoStore::open(dir.path(), None)).unwrap());
+
+                let machine = runtime
+                    .block_on(OlmMachine::with_store(alice_id(), alice_device_id(), store))
+                    .unwrap();
+                runtime
+                    .block_on(machine.mark_request_as_sent(&txn_id, &keys_query_response))
+                    .unwrap();
+                (machine, &runtime, &txn_id)
+            },
             move |(machine, runtime, txn_id)| {
                 runtime.block_on(machine.mark_request_as_sent(txn_id, response)).unwrap()
             },
@@ -160,6 +210,8 @@ pub fn room_key_sharing(c: &mut Criterion) {
     group.throughput(Throughput::Elements(count as u64));
     let name = format!("{count} devices");
 
+    // Benchmark memory store.
+
     group.bench_function(BenchmarkId::new("memory store", &name), |b| {
         b.to_async(&runtime).iter(|| async {
             let requests = machine
@@ -180,6 +232,9 @@ pub fn room_key_sharing(c: &mut Criterion) {
             machine.invalidate_group_session(room_id).await.unwrap();
         })
     });
+
+    // Benchmark sqlite store.
+
     let dir = tempfile::tempdir().unwrap();
     let store = Arc::new(runtime.block_on(SqliteCryptoStore::open(dir.path(), None)).unwrap());
 
@@ -209,6 +264,42 @@ pub fn room_key_sharing(c: &mut Criterion) {
         })
     });
 
+    {
+        let _guard = runtime.enter();
+        drop(machine);
+    }
+
+    // Benchmark (deprecated) sled store.
+
+    let dir = tempfile::tempdir().unwrap();
+    let store = Arc::new(runtime.block_on(SledCryptoStore::open(dir.path(), None)).unwrap());
+
+    let machine =
+        runtime.block_on(OlmMachine::with_store(alice_id(), alice_device_id(), store)).unwrap();
+    runtime.block_on(machine.mark_request_as_sent(&txn_id, &keys_query_response)).unwrap();
+    runtime.block_on(machine.mark_request_as_sent(&txn_id, &response)).unwrap();
+
+    group.bench_function(BenchmarkId::new("sled store", &name), |b| {
+        b.to_async(&runtime).iter(|| async {
+            let requests = machine
+                .share_room_key(
+                    room_id,
+                    users.iter().map(Deref::deref),
+                    EncryptionSettings::default(),
+                )
+                .await
+                .unwrap();
+
+            assert!(!requests.is_empty());
+
+            for request in requests {
+                machine.mark_request_as_sent(&request.txn_id, &to_device_response).await.unwrap();
+            }
+
+            machine.invalidate_group_session(room_id).await.unwrap();
+        })
+    });
+
     group.finish()
 }
 
@@ -229,12 +320,16 @@ pub fn devices_missing_sessions_collecting(c: &mut Criterion) {
 
     runtime.block_on(machine.mark_request_as_sent(&txn_id, &response)).unwrap();
 
+    // Benchmark memory store.
+
     group.bench_function(BenchmarkId::new("memory store", &name), |b| {
         b.to_async(&runtime).iter_with_large_drop(|| async {
             machine.get_missing_sessions(users.iter().map(Deref::deref)).await.unwrap()
         })
     });
 
+    // Benchmark sqlite store.
+
     let dir = tempfile::tempdir().unwrap();
     let store = Arc::new(runtime.block_on(SqliteCryptoStore::open(dir.path(), None)).unwrap());
 
@@ -249,6 +344,27 @@ pub fn devices_missing_sessions_collecting(c: &mut Criterion) {
         })
     });
 
+    {
+        let _guard = runtime.enter();
+        drop(machine);
+    }
+
+    // Benchmark (deprecated) sled store.
+
+    let dir = tempfile::tempdir().unwrap();
+    let store = Arc::new(runtime.block_on(SledCryptoStore::open(dir.path(), None)).unwrap());
+
+    let machine =
+        runtime.block_on(OlmMachine::with_store(alice_id(), alice_device_id(), store)).unwrap();
+
+    runtime.block_on(machine.mark_request_as_sent(&txn_id, &response)).unwrap();
+
+    group.bench_function(BenchmarkId::new("sled store", &name), |b| {
+        b.to_async(&runtime).iter(|| async {
+            machine.get_missing_sessions(users.iter().map(Deref::deref)).await.unwrap()
+        })
+    });
+
     group.finish()
 }
 

benchmarks/benches/crypto_bench.rs

@@ -18,7 +18,7 @@ dictionary NotificationItem {
     string? room_canonical_alias;
     boolean is_noisy;
     boolean is_direct;
-    boolean is_encrypted;
+    boolean? is_encrypted;
 };
 
 interface TimelineEvent {};
@@ -154,7 +154,15 @@ interface PaginationOptions {
 
 interface RoomMessageEventContent {};
 
+[Error]
+interface ClientError {
+    Generic(string msg);
+};
+
 interface MediaSource {
+    [Name=from_json, Throws=ClientError]
+    constructor(string json);
+    string to_json();
     string url();
 };
 

bindings/matrix-sdk-ffi/src/api.udl

@@ -1,6 +1,6 @@
 use matrix_sdk::{self, encryption::CryptoStoreError, HttpError, IdParseError, StoreError};
 
-#[derive(Debug, thiserror::Error, uniffi::Error)]
+#[derive(Debug, thiserror::Error)]
 pub enum ClientError {
     #[error("client error: {msg}")]
     Generic { msg: String },

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

@@ -21,7 +21,7 @@ pub struct NotificationItem {
 
     pub is_noisy: bool,
     pub is_direct: bool,
-    pub is_encrypted: bool,
+    pub is_encrypted: Option<bool>,
 }
 
 impl NotificationItem {
@@ -46,7 +46,10 @@ impl NotificationItem {
         room: Room,
         actions: Vec<Action>,
     ) -> anyhow::Result<Self> {
-        let sender = room.get_member(event.sender()).await?;
+        let sender = match &room {
+            Room::Invited(invited) => invited.invite_details().await?.inviter,
+            _ => room.get_member(event.sender()).await?,
+        };
         let mut sender_display_name = None;
         let mut sender_avatar_url = None;
         if let Some(sender) = sender {
@@ -65,7 +68,7 @@ impl NotificationItem {
             room_canonical_alias: room.canonical_alias().map(|c| c.to_string()),
             is_noisy,
             is_direct: room.is_direct().await?,
-            is_encrypted: room.is_encrypted().await?,
+            is_encrypted: room.is_encrypted().await.ok(),
         };
         Ok(item)
     }

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

@@ -8,7 +8,7 @@ use matrix_sdk::ruma::{
         v4::RoomSubscription as RumaRoomSubscription,
         UnreadNotificationsCount as RumaUnreadNotificationsCount,
     },
-    assign, IdParseError, OwnedRoomId, RoomId, UInt,
+    assign, IdParseError, OwnedRoomId, RoomId,
 };
 pub use matrix_sdk::{
     room::timeline::Timeline, ruma::api::client::sync::sync_events::v4::SyncRequestListFilters,
@@ -529,9 +529,9 @@ impl SlidingSyncListBuilder {
         Arc::new(builder)
     }
 
-    pub fn add_range(self: Arc<Self>, from: u32, to: u32) -> Arc<Self> {
+    pub fn add_range(self: Arc<Self>, from: u32, to_included: u32) -> Arc<Self> {
         let mut builder = unwrap_or_clone_arc(self);
-        builder.inner = builder.inner.add_range(from, to);
+        builder.inner = builder.inner.add_range(from..=to_included);
         Arc::new(builder)
     }
 
@@ -627,15 +627,15 @@ impl SlidingSyncList {
     /// Remember to cancel the existing stream and fetch a new one as this will
     /// only be applied on the next request.
     pub fn set_range(&self, start: u32, end: u32) -> Result<(), SlidingSyncError> {
-        self.inner.set_range(start, end).map_err(Into::into)
+        self.inner.set_range(start..=end).map_err(Into::into)
     }
 
     /// Set the ranges to fetch
     ///
     /// Remember to cancel the existing stream and fetch a new one as this will
     /// only be applied on the next request.
     pub fn add_range(&self, start: u32, end: u32) -> Result<(), SlidingSyncError> {
-        self.inner.add_range((start, end)).map_err(Into::into)
+        self.inner.add_range(start..=end).map_err(Into::into)
     }
 
     /// Reset the ranges
@@ -650,7 +650,7 @@ impl SlidingSyncList {
 
     /// The current timeline limit
     pub fn get_timeline_limit(&self) -> Option<u32> {
-        self.inner.timeline_limit().map(|limit| u32::try_from(limit).unwrap_or_default())
+        self.inner.timeline_limit()
     }
 
     /// The current timeline limit
@@ -660,7 +660,7 @@ impl SlidingSyncList {
 
     /// Unset the current timeline limit
     pub fn unset_timeline_limit(&self) {
-        self.inner.set_timeline_limit::<UInt>(None)
+        self.inner.set_timeline_limit(None)
     }
 }
 

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

@@ -11,7 +11,10 @@ use matrix_sdk::{
 use ruma::UInt;
 use tracing::warn;
 
-use crate::{error::TimelineError, helpers::unwrap_or_clone_arc};
+use crate::{
+    error::{ClientError, TimelineError},
+    helpers::unwrap_or_clone_arc,
+};
 
 #[uniffi::export]
 pub fn media_source_from_url(url: String) -> Arc<MediaSource> {
@@ -934,6 +937,15 @@ pub enum VirtualTimelineItem {
 
 #[extension_trait]
 pub impl MediaSourceExt for MediaSource {
+    fn from_json(json: String) -> Result<MediaSource, ClientError> {
+        let res = serde_json::from_str(&json)?;
+        Ok(res)
+    }
+
+    fn to_json(&self) -> String {
+        serde_json::to_string(self).expect("Media source should always be serializable ")
+    }
+
     fn url(&self) -> String {
         match self {
             MediaSource::Plain(url) => url.to_string(),

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

@@ -61,7 +61,7 @@ struct DebugNotification<'a>(&'a Notification);
 #[cfg(not(tarpaulin_include))]
 impl<'a> fmt::Debug for DebugNotification<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("DebugNotification")
+        f.debug_struct("Notification")
             .field("actions", &self.0.actions)
             .field("event", &DebugRawEvent(&self.0.event))
             .field("profile_tag", &self.0.profile_tag)