matrix-rust-sdk

public

Star0

Fork 0

Watch0

39 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `a88b3d82b396`

tarball

atagen <boss@atagen.co>2026-10-26 08:53 UTC

2 files changed+59-35

event-cache: read a linked chunk once more before wiping it

Every IndexedDB DomException maps to InvalidData, so one aborted transaction while loading a room ('The transaction has finished') cleared that room's whole stored history. The fork's room Clear then scans and decrypts every chunk in the store under the global by_room lock, stalling every room's cache. A failed metadata, last-chunk or previous-chunk read now gets one retry before the reset.

Modified file: crates/matrix-sdk/src/event_cache/caches/room/pagination.rs+10 additions−5 deletions@@ -184,11 +184,16 @@ impl PaginatedCache for Arc<RoomEventCacheInner> {
 
         // The first chunk is not a gap, we can load its previous chunk.
         let linked_chunk_id = LinkedChunkId::Room(&state.state.room_id);
-        let new_first_chunk = match state
-            .store
-            .load_previous_chunk(linked_chunk_id, prev_first_chunk.identifier())
-            .await
-        {
+        let first_chunk = prev_first_chunk.identifier();
+        let loaded = match state.store.load_previous_chunk(linked_chunk_id, first_chunk).await {
+            // a failed read resets the room, so a transient IndexedDB error gets a second read
+            Err(err) => {
+                tracing::warn!("retrying the previous chunk after a storage error: {err}");
+                state.store.load_previous_chunk(linked_chunk_id, first_chunk).await
+            }
+            loaded => loaded,
+        };
+        let new_first_chunk = match loaded {
             Ok(Some(new_first_chunk)) => {
                 // All good, let's continue with this chunk.
                 new_first_chunk

Modified file: crates/matrix-sdk/src/event_cache/caches/room/state.rs+49 additions−30 deletions@@ -333,30 +333,43 @@ impl LockedRoomEventCacheState {
         //
         // If loading the full linked chunk failed, we'll clear the event cache, as it
         // indicates that at some point, there's some malformed data.
-        let full_linked_chunk_metadata =
-            match load_linked_chunk_metadata(&store_guard, linked_chunk_id).await {
-                Ok(metas) => metas,
-                Err(err) => {
-                    error!("error when loading a linked chunk's metadata from the store: {err}");
-
-                    // Try to clear storage for this room.
-                    store_guard
-                        .handle_linked_chunk_updates(linked_chunk_id, vec![Update::Clear])
-                        .await?;
-
-                    // Restart with an empty linked chunk.
-                    None
-                }
-            };
+        // a storage error can be transient (an IndexedDB transaction aborted under us), and the
+        // clear below throws away the room's whole history, so read once more before trusting it
+        let metadata = match load_linked_chunk_metadata(&store_guard, linked_chunk_id).await {
+            Err(EventCacheError::Storage(err)) => {
+                warn!("retrying a linked chunk's metadata after a storage error: {err}");
+                load_linked_chunk_metadata(&store_guard, linked_chunk_id).await
+            }
+            other => other,
+        };
+        let full_linked_chunk_metadata = match metadata {
+            Ok(metas) => metas,
+            Err(err) => {
+                error!("error when loading a linked chunk's metadata from the store: {err}");
+
+                // Try to clear storage for this room.
+                store_guard
+                    .handle_linked_chunk_updates(linked_chunk_id, vec![Update::Clear])
+                    .await?;
+
+                // Restart with an empty linked chunk.
+                None
+            }
+        };
 
-        let linked_chunk = match store_guard
-            .load_last_chunk(linked_chunk_id)
-            .await
-            .map_err(EventCacheError::from)
-            .and_then(|(last_chunk, chunk_identifier_generator)| {
+        let last_chunk = match store_guard.load_last_chunk(linked_chunk_id).await {
+            Err(err) => {
+                warn!("retrying a linked chunk's latest chunk after a storage error: {err}");
+                store_guard.load_last_chunk(linked_chunk_id).await
+            }
+            loaded => loaded,
+        };
+        let linked_chunk = match last_chunk.map_err(EventCacheError::from).and_then(
+            |(last_chunk, chunk_identifier_generator)| {
                 lazy_loader::from_last_chunk(last_chunk, chunk_identifier_generator)
                     .map_err(EventCacheError::from)
-            }) {
+            },
+        ) {
             Ok(linked_chunk) => linked_chunk,
             Err(err) => {
                 error!("error when loading a linked chunk's latest chunk from the store: {err}");
@@ -622,17 +635,23 @@ impl<'a> RoomEventCacheStateLockWriteGuard<'a> {
     pub async fn shrink_to_last_chunk(&mut self) -> Result<(), EventCacheError> {
         // Attempt to load the last chunk.
         let linked_chunk_id = LinkedChunkId::Room(&self.state.room_id);
-        let (last_chunk, chunk_identifier_generator) =
-            match self.store.load_last_chunk(linked_chunk_id).await {
-                Ok(pair) => pair,
+        let loaded = match self.store.load_last_chunk(linked_chunk_id).await {
+            Err(err) => {
+                warn!("retrying a linked chunk's latest chunk after a storage error: {err}");
+                self.store.load_last_chunk(linked_chunk_id).await
+            }
+            loaded => loaded,
+        };
+        let (last_chunk, chunk_identifier_generator) = match loaded {
+            Ok(pair) => pair,
 
-                Err(err) => {
-                    // If loading the last chunk failed, clear the entire linked chunk.
-                    error!("error when reloading a linked chunk from memory: {err}");
+            Err(err) => {
+                // If loading the last chunk failed, clear the entire linked chunk.
+                error!("error when reloading a linked chunk from memory: {err}");
 
-                    return self.reset_internal().await;
-                }
-            };
+                return self.reset_internal().await;
+            }
+        };
 
         debug!("unloading the linked chunk, and resetting it to its last chunk");

matrix-rust-sdk

Commit a88b3d82b396

Commit `a88b3d82b396`