From e5ca44bb04bccbc64472fab22a3549b98d471244 Mon Sep 17 00:00:00 2001 From: Ivan Enderlin Date: Tue, 19 Nov 2024 10:24:29 +0100 Subject: [PATCH] feat(base): Add `EventCacheStore::handle_linked_chunk_updates`. This patch adds the `handle_linked_chunk_updates` method on the `EventCacheStore` trait. Part of https://github.com/matrix-org/matrix-rust-sdk/issues/3280. --- .../src/event_cache/store/memory_store.rs | 15 +++++++++++-- .../src/event_cache/store/traits.rs | 22 +++++++++++++++++-- .../matrix-sdk-common/src/linked_chunk/mod.rs | 4 ++-- .../src/linked_chunk/updates.rs | 5 +++++ .../src/event_cache_store.rs | 10 ++++++++- 5 files changed, 49 insertions(+), 7 deletions(-) diff --git a/crates/matrix-sdk-base/src/event_cache/store/memory_store.rs b/crates/matrix-sdk-base/src/event_cache/store/memory_store.rs index 1b5debbccee..bd764cad0db 100644 --- a/crates/matrix-sdk-base/src/event_cache/store/memory_store.rs +++ b/crates/matrix-sdk-base/src/event_cache/store/memory_store.rs @@ -16,12 +16,16 @@ use std::{collections::HashMap, num::NonZeroUsize, sync::RwLock as StdRwLock, ti use async_trait::async_trait; use matrix_sdk_common::{ - ring_buffer::RingBuffer, store_locks::memory_store_helper::try_take_leased_lock, + linked_chunk::Update, ring_buffer::RingBuffer, + store_locks::memory_store_helper::try_take_leased_lock, }; use ruma::{MxcUri, OwnedMxcUri}; use super::{EventCacheStore, EventCacheStoreError, Result}; -use crate::media::{MediaRequestParameters, UniqueKey as _}; +use crate::{ + event_cache::{Event, Gap}, + media::{MediaRequestParameters, UniqueKey as _}, +}; /// In-memory, non-persistent implementation of the `EventCacheStore`. /// @@ -66,6 +70,13 @@ impl EventCacheStore for MemoryStore { Ok(try_take_leased_lock(&self.leases, lease_duration_ms, key, holder)) } + async fn handle_linked_chunk_updates( + &self, + _updates: &[Update], + ) -> Result<(), Self::Error> { + todo!() + } + async fn add_media_content( &self, request: &MediaRequestParameters, diff --git a/crates/matrix-sdk-base/src/event_cache/store/traits.rs b/crates/matrix-sdk-base/src/event_cache/store/traits.rs index e52ad8b8b2e..dde80830973 100644 --- a/crates/matrix-sdk-base/src/event_cache/store/traits.rs +++ b/crates/matrix-sdk-base/src/event_cache/store/traits.rs @@ -15,11 +15,14 @@ use std::{fmt, sync::Arc}; use async_trait::async_trait; -use matrix_sdk_common::AsyncTraitDeps; +use matrix_sdk_common::{linked_chunk::Update, AsyncTraitDeps}; use ruma::MxcUri; use super::EventCacheStoreError; -use crate::media::MediaRequestParameters; +use crate::{ + event_cache::{Event, Gap}, + media::MediaRequestParameters, +}; /// An abstract trait that can be used to implement different store backends /// for the event cache of the SDK. @@ -37,6 +40,14 @@ pub trait EventCacheStore: AsyncTraitDeps { holder: &str, ) -> Result; + /// An [`Update`] reflects an operation that has happened inside a linked + /// chunk. The linked chunk is used by the event cache to store the events + /// in-memory. This method aims at forwarding this update inside this store. + async fn handle_linked_chunk_updates( + &self, + updates: &[Update], + ) -> Result<(), Self::Error>; + /// Add a media file's content in the media store. /// /// # Arguments @@ -131,6 +142,13 @@ impl EventCacheStore for EraseEventCacheStoreError { self.0.try_take_leased_lock(lease_duration_ms, key, holder).await.map_err(Into::into) } + async fn handle_linked_chunk_updates( + &self, + updates: &[Update], + ) -> Result<(), Self::Error> { + self.0.handle_linked_chunk_updates(updates).await.map_err(Into::into) + } + async fn add_media_content( &self, request: &MediaRequestParameters, diff --git a/crates/matrix-sdk-common/src/linked_chunk/mod.rs b/crates/matrix-sdk-common/src/linked_chunk/mod.rs index b2894f86469..eeba29be302 100644 --- a/crates/matrix-sdk-common/src/linked_chunk/mod.rs +++ b/crates/matrix-sdk-common/src/linked_chunk/mod.rs @@ -103,8 +103,8 @@ use std::{ sync::atomic::{AtomicU64, Ordering}, }; -use as_vector::*; -use updates::*; +pub use as_vector::*; +pub use updates::*; /// Errors of [`LinkedChunk`]. #[derive(thiserror::Error, Debug)] diff --git a/crates/matrix-sdk-common/src/linked_chunk/updates.rs b/crates/matrix-sdk-common/src/linked_chunk/updates.rs index 5a143b94486..97d21231ed1 100644 --- a/crates/matrix-sdk-common/src/linked_chunk/updates.rs +++ b/crates/matrix-sdk-common/src/linked_chunk/updates.rs @@ -29,6 +29,9 @@ use super::{ChunkIdentifier, Position}; /// /// These updates are useful to store a `LinkedChunk` in another form of /// storage, like a database or something similar. +/// +/// [`LinkedChunk`]: super::LinkedChunk +/// [`LinkedChunk::updates`]: super::LinkedChunk::updates #[derive(Debug, Clone, PartialEq)] pub enum Update { /// A new chunk of kind Items has been created. @@ -101,6 +104,8 @@ pub enum Update { /// A collection of [`Update`]s that can be observed. /// /// Get a value for this type with [`LinkedChunk::updates`]. +/// +/// [`LinkedChunk::updates`]: super::LinkedChunk::updates #[derive(Debug)] pub struct ObservableUpdates { pub(super) inner: Arc>>, diff --git a/crates/matrix-sdk-sqlite/src/event_cache_store.rs b/crates/matrix-sdk-sqlite/src/event_cache_store.rs index c5a21fb0a6b..dc74999e227 100644 --- a/crates/matrix-sdk-sqlite/src/event_cache_store.rs +++ b/crates/matrix-sdk-sqlite/src/event_cache_store.rs @@ -3,7 +3,8 @@ use std::{borrow::Cow, fmt, path::Path, sync::Arc}; use async_trait::async_trait; use deadpool_sqlite::{Object as SqliteAsyncConn, Pool as SqlitePool, Runtime}; use matrix_sdk_base::{ - event_cache::store::EventCacheStore, + event_cache::{store::EventCacheStore, Event, Gap}, + linked_chunk::Update, media::{MediaRequestParameters, UniqueKey}, }; use matrix_sdk_store_encryption::StoreCipher; @@ -182,6 +183,13 @@ impl EventCacheStore for SqliteEventCacheStore { Ok(num_touched == 1) } + async fn handle_linked_chunk_updates( + &self, + _updates: &[Update], + ) -> Result<(), Self::Error> { + todo!() + } + async fn add_media_content( &self, request: &MediaRequestParameters,