refactor(indexeddb): add IndexedDB-backed impl of EventCacheStore::try_take_leased_lock

Signed-off-by: Michael Goldenberg <[email protected]>

Author: mgoldenberg

crates/matrix-sdk-indexeddb/src/event_cache_store/mod.rs

@@ -14,6 +14,8 @@
 
 #![allow(unused)]
 
+use std::time::Duration;
+
 use indexed_db_futures::IdbDatabase;
 use matrix_sdk_base::{
     event_cache::{
@@ -30,15 +32,18 @@ use matrix_sdk_base::{
     media::MediaRequestParameters,
     timer,
 };
-use ruma::{events::relation::RelationType, EventId, MxcUri, OwnedEventId, RoomId};
+use ruma::{
+    events::relation::RelationType, EventId, MilliSecondsSinceUnixEpoch, MxcUri, OwnedEventId,
+    RoomId,
+};
 use tracing::{error, instrument, trace};
 use web_sys::IdbTransactionMode;
 
 use crate::event_cache_store::{
     migrations::current::keys,
-    serializer::IndexeddbEventCacheStoreSerializer,
+    serializer::{traits::Indexed, IndexeddbEventCacheStoreSerializer},
     transaction::{IndexeddbEventCacheStoreTransaction, IndexeddbEventCacheStoreTransactionError},
-    types::{ChunkType, InBandEvent, OutOfBandEvent},
+    types::{ChunkType, InBandEvent, Lease, OutOfBandEvent},
 };
 
 mod builder;
@@ -132,10 +137,27 @@ impl_event_cache_store! {
         holder: &str,
     ) -> Result<bool, IndexeddbEventCacheStoreError> {
         let _timer = timer!("method");
-        self.memory_store
-            .try_take_leased_lock(lease_duration_ms, key, holder)
-            .await
-            .map_err(IndexeddbEventCacheStoreError::MemoryStore)
+
+        let now = Duration::from_millis(MilliSecondsSinceUnixEpoch::now().get().into());
+
+        let transaction =
+            self.transaction(&[Lease::OBJECT_STORE], IdbTransactionMode::Readwrite)?;
+
+        if let Some(lease) = transaction.get_lease_by_id(key).await? {
+            if lease.holder != holder && !lease.has_expired(now) {
+                return Ok(false);
+            }
+        }
+
+        transaction
+            .put_lease(&Lease {
+                key: key.to_owned(),
+                holder: holder.to_owned(),
+                expiration: now + Duration::from_millis(lease_duration_ms.into()),
+            })
+            .await?;
+
+        Ok(true)
     }
 
     #[instrument(skip(self, updates))]

crates/matrix-sdk-indexeddb/src/event_cache_store/transaction.rs

@@ -34,11 +34,11 @@ use crate::event_cache_store::{
         },
         types::{
             IndexedChunkIdKey, IndexedEventIdKey, IndexedEventPositionKey, IndexedEventRelationKey,
-            IndexedGapIdKey, IndexedKeyRange, IndexedNextChunkIdKey,
+            IndexedGapIdKey, IndexedKeyRange, IndexedLeaseIdKey, IndexedNextChunkIdKey,
         },
         IndexeddbEventCacheStoreSerializer,
     },
-    types::{Chunk, ChunkType, Event, Gap, Position},
+    types::{Chunk, ChunkType, Event, Gap, Lease, Position},
 };
 
 #[derive(Debug, Error)]
@@ -410,6 +410,24 @@ impl<'a> IndexeddbEventCacheStoreTransaction<'a> {
         self.transaction.object_store(T::OBJECT_STORE)?.clear()?.await.map_err(Into::into)
     }
 
+    /// Query IndexedDB for the lease that matches the given key `id`. If more
+    /// than one lease is found, an error is returned.
+    pub async fn get_lease_by_id(
+        &self,
+        id: &str,
+    ) -> Result<Option<Lease>, IndexeddbEventCacheStoreTransactionError> {
+        self.get_item_by_key_components::<Lease, IndexedLeaseIdKey>(id).await
+    }
+
+    /// Puts a lease into IndexedDB. If an event with the same key already
+    /// exists, it will be overwritten.
+    pub async fn put_lease(
+        &self,
+        lease: &Lease,
+    ) -> Result<(), IndexeddbEventCacheStoreTransactionError> {
+        self.put_item(lease).await
+    }
+
     /// Query IndexedDB for chunks that match the given chunk identifier in the
     /// given room. If more than one item is found, an error is returned.
     pub async fn get_chunk_by_id(

crates/matrix-sdk-indexeddb/src/event_cache_store/types.rs

@@ -32,7 +32,7 @@ pub struct Lease {
 
 impl Lease {
     /// Determines whether the lease is expired at a given time `t`
-    pub fn expired_at(&self, t: Duration) -> bool {
+    pub fn has_expired(&self, t: Duration) -> bool {
         self.expiration < t
     }
 }