Split SqliteMediaStore from SqliteEventCacheStore.

Split `MemoryMediaStore` from `MemoryStore`.
Split `IndexeddbMediaStore` from `IndexxeddbEventCacheStore`.

Author: Shrey Patel

crates/matrix-sdk-base/src/event_cache/store/memory_store.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! The event cache stores holds events and downloaded media when the cache was
+//! The event cache stores holds events when the cache was
 //! activated to save bandwidth at the cost of increased storage space usage.
 //!
 //! Implementing the `EventCacheStore` trait, you can plug any storage backend

crates/matrix-sdk-base/src/event_cache/store/mod.rs

@@ -972,24 +972,24 @@ where
 /// recommended to run those in encrypted stores because the size of the
 /// encrypted content may vary compared to what the tests expect.
 ///
-/// You need to provide an `async fn get_event_cache_store() ->
-/// event_cache::store::Result<Store>` that provides a fresh event cache store
+/// You need to provide an `async fn get_media_store() ->
+/// media::store::Result<Store>` that provides a fresh media store
 /// that implements `MediaStoreInner` on the same level you invoke the
 /// macro.
 ///
 /// ## Usage Example:
 /// ```no_run
-/// # use matrix_sdk_base::event_cache::store::{
-/// #    EventCacheStore,
+/// # use matrix_sdk_base::media::store::{
+/// #    MediaStore,
 /// #    MemoryStore as MyStore,
-/// #    Result as EventCacheStoreResult,
+/// #    Result as MediaStoreResult,
 /// # };
 ///
 /// #[cfg(test)]
 /// mod tests {
-///     use super::{EventCacheStoreResult, MyStore};
+///     use super::{MediaStoreResult, MyStore};
 ///
-///     async fn get_event_cache_store() -> EventCacheStoreResult<MyStore> {
+///     async fn get_media_store() -> MediaStoreResult<MyStore> {
 ///         Ok(MyStore::new())
 ///     }
 ///
@@ -1005,19 +1005,19 @@ macro_rules! media_store_inner_integration_tests {
 
             #[async_test]
             async fn test_media_max_file_size() {
-                let media_store_inner = get_event_cache_store().await.unwrap();
+                let media_store_inner = get_media_store().await.unwrap();
                 media_store_inner.test_media_max_file_size().await;
             }
 
             #[async_test]
             async fn test_media_max_cache_size() {
-                let media_store_inner = get_event_cache_store().await.unwrap();
+                let media_store_inner = get_media_store().await.unwrap();
                 media_store_inner.test_media_max_cache_size().await;
             }
 
             #[async_test]
             async fn test_media_ignore_max_size() {
-                let media_store_inner = get_event_cache_store().await.unwrap();
+                let media_store_inner = get_media_store().await.unwrap();
                 media_store_inner.test_media_ignore_max_size().await;
             }
         }
@@ -1033,29 +1033,29 @@ macro_rules! media_store_inner_integration_tests {
         use matrix_sdk_test::async_test;
         use $crate::media::store::MediaStoreInnerIntegrationTests;
 
-        use super::get_event_cache_store;
+        use super::get_media_store;
 
         #[async_test]
         async fn test_store_media_retention_policy() {
-            let media_store_inner = get_event_cache_store().await.unwrap();
+            let media_store_inner = get_media_store().await.unwrap();
             media_store_inner.test_store_media_retention_policy().await;
         }
 
         #[async_test]
         async fn test_media_expiry() {
-            let media_store_inner = get_event_cache_store().await.unwrap();
+            let media_store_inner = get_media_store().await.unwrap();
             media_store_inner.test_media_expiry().await;
         }
 
         #[async_test]
         async fn test_media_ignore_expiry() {
-            let media_store_inner = get_event_cache_store().await.unwrap();
+            let media_store_inner = get_media_store().await.unwrap();
             media_store_inner.test_media_ignore_expiry().await;
         }
 
         #[async_test]
         async fn test_store_last_media_cleanup_time() {
-            let media_store_inner = get_event_cache_store().await.unwrap();
+            let media_store_inner = get_media_store().await.unwrap();
             media_store_inner.test_store_last_media_cleanup_time().await;
         }
     };
@@ -1267,13 +1267,13 @@ where
 /// the entire tests suite locally.
 ///
 /// You need to provide an `async fn get_media_store() ->
-/// event_cache::store::media::Result<Store>` that provides a fresh media store
+/// media::store::Result<Store>` that provides a fresh media store
 /// that implements `MediaStoreInner` on the same level you invoke the
 /// macro.
 ///
 /// ## Usage Example:
 /// ```no_run
-/// # use matrix_sdk_base::event_cache::store::media{
+/// # use matrix_sdk_base::media::store::{
 /// #    MediaStore,
 /// #    MemoryStore as MyStore,
 /// #    Result as MediaStoreResult,
@@ -1296,19 +1296,99 @@ macro_rules! media_store_integration_tests {
     () => {
         mod media_store_integration_tests {
             use matrix_sdk_test::async_test;
+            use $crate::media::store::integration_tests::MediaStoreIntegrationTests;
 
             use super::get_media_store;
 
             #[async_test]
             async fn test_media_content() {
-                let event_cache_store = get_media_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_media_content().await;
+                let media_store = get_media_store().await.unwrap();
+                media_store.test_media_content().await;
             }
 
             #[async_test]
             async fn test_replace_media_key() {
-                let event_cache_store = get_media_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_replace_media_key().await;
+                let media_store = get_media_store().await.unwrap();
+                media_store.test_replace_media_key().await;
+            }
+        }
+    };
+}
+
+/// Macro generating tests for the media store, related to time (mostly
+/// for the cross-process lock).
+#[allow(unused_macros)]
+#[macro_export]
+macro_rules! media_store_integration_tests_time {
+    () => {
+        mod media_store_integration_tests_time {
+            use std::time::Duration;
+
+            #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+            use gloo_timers::future::sleep;
+            use matrix_sdk_test::async_test;
+            #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+            use tokio::time::sleep;
+            use $crate::media::store::MediaStore;
+
+            use super::get_media_store;
+
+            #[async_test]
+            async fn test_lease_locks() {
+                let store = get_media_store().await.unwrap();
+
+                let acquired0 = store.try_take_leased_lock(0, "key", "alice").await.unwrap();
+                assert!(acquired0);
+
+                // Should extend the lease automatically (same holder).
+                let acquired2 = store.try_take_leased_lock(300, "key", "alice").await.unwrap();
+                assert!(acquired2);
+
+                // Should extend the lease automatically (same holder + time is ok).
+                let acquired3 = store.try_take_leased_lock(300, "key", "alice").await.unwrap();
+                assert!(acquired3);
+
+                // Another attempt at taking the lock should fail, because it's taken.
+                let acquired4 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
+                assert!(!acquired4);
+
+                // Even if we insist.
+                let acquired5 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
+                assert!(!acquired5);
+
+                // That's a nice test we got here, go take a little nap.
+                sleep(Duration::from_millis(50)).await;
+
+                // Still too early.
+                let acquired55 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
+                assert!(!acquired55);
+
+                // Ok you can take another nap then.
+                sleep(Duration::from_millis(250)).await;
+
+                // At some point, we do get the lock.
+                let acquired6 = store.try_take_leased_lock(0, "key", "bob").await.unwrap();
+                assert!(acquired6);
+
+                sleep(Duration::from_millis(1)).await;
+
+                // The other gets it almost immediately too.
+                let acquired7 = store.try_take_leased_lock(0, "key", "alice").await.unwrap();
+                assert!(acquired7);
+
+                sleep(Duration::from_millis(1)).await;
+
+                // But when we take a longer lease...
+                let acquired8 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
+                assert!(acquired8);
+
+                // It blocks the other user.
+                let acquired9 = store.try_take_leased_lock(300, "key", "alice").await.unwrap();
+                assert!(!acquired9);
+
+                // We can hold onto our lease.
+                let acquired10 = store.try_take_leased_lock(300, "key", "bob").await.unwrap();
+                assert!(acquired10);
             }
         }
     };

crates/matrix-sdk-base/src/media/store/integration_tests.rs

@@ -25,12 +25,12 @@ use tokio::sync::Mutex as AsyncMutex;
 use tracing::error;
 
 use super::{MediaRetentionPolicy, MediaStoreError};
-use crate::{event_cache::store::EventCacheStoreError, media::MediaRequestParameters};
+use crate::media::MediaRequestParameters;
 
-/// API for implementors of [`EventCacheStore`] to manage their media through
+/// API for implementors of [`MediaStore`] to manage their media through
 /// their implementation of [`MediaStoreInner`].
 ///
-/// [`EventCacheStore`]: crate::event_cache::store::EventCacheStore
+/// [`MediaStore`]: crate::media::store::MediaStore
 #[derive(Debug)]
 pub struct MediaService<Time: TimeProvider = DefaultTimeProvider> {
     inner: Arc<MediaServiceInner<Time>>,
@@ -350,11 +350,11 @@ where
 }
 
 /// An abstract trait that can be used to implement different store backends
-/// for the event cache of the SDK.
+/// for the media store of the SDK.
 #[cfg_attr(target_family = "wasm", async_trait(?Send))]
 #[cfg_attr(not(target_family = "wasm"), async_trait)]
 pub trait MediaStore: AsyncTraitDeps {
-    /// The error type used by this event cache store.
+    /// The error type used by this media store.
     type Error: fmt::Debug + Into<MediaStoreError>;
 
     /// Try to take a lock using the given store.
@@ -500,7 +500,7 @@ pub trait MediaStore: AsyncTraitDeps {
 #[cfg_attr(not(target_family = "wasm"), async_trait)]
 pub trait MediaStoreInner: AsyncTraitDeps + Clone {
     /// The error type used by this media cache store.
-    type Error: fmt::Debug + fmt::Display + Into<EventCacheStoreError>;
+    type Error: fmt::Debug + fmt::Display + Into<MediaStoreError>;
 
     /// The persisted media retention policy in the media cache.
     async fn media_retention_policy_inner(
@@ -685,13 +685,10 @@ mod tests {
     };
 
     use super::{
-        IgnoreMediaRetentionPolicy, MediaRetentionPolicy, MediaService, MediaStoreInner,
-        TimeProvider,
-    };
-    use crate::{
-        event_cache::store::EventCacheStoreError,
-        media::{MediaFormat, MediaRequestParameters, UniqueKey},
+        IgnoreMediaRetentionPolicy, MediaRetentionPolicy, MediaService, MediaStoreError,
+        MediaStoreInner, TimeProvider,
     };
+    use crate::media::{MediaFormat, MediaRequestParameters, UniqueKey};
 
     #[derive(Debug, Default, Clone)]
     struct MockMediaStoreInner {
@@ -767,7 +764,7 @@ mod tests {
 
     impl std::error::Error for MockMediaStoreInnerError {}
 
-    impl From<MockMediaStoreInnerError> for EventCacheStoreError {
+    impl From<MockMediaStoreInnerError> for MediaStoreError {
         fn from(value: MockMediaStoreInnerError) -> Self {
             Self::backend(value)
         }