matrix-rust-sdk

public

Star0

Fork 0

Watch0

16 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `090dac278176`

tarball

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

2 files changed+85-8

event-cache: take the limited sync boundary from the store

handle_sync read older_boundary from memory only, so a room shrunk to a trailing gap recorded a limited sync as an ordinary gap without a HistoryGap and the retained and new events rendered as continuous. The non-limited prev_batch drop now also counts stored events as known history.

Modified file: crates/matrix-sdk/src/event_cache/caches/room/mod.rs+61 additions@@ -2003,6 +2003,67 @@ mod timed_tests {
     }
 
     #[async_test]
+    async fn test_limited_sync_after_shrink_to_a_gap_keeps_its_discontinuity() {
+        let room_id = room_id!("!shrunk-history:saucisse.bzh");
+        let client = MockClientBuilder::new(None).build().await;
+        let event_cache = client.event_cache();
+        event_cache.subscribe().unwrap();
+        client.base_client().get_or_create_room(room_id, RoomState::Joined);
+        let room = client.get_room(room_id).unwrap();
+        let (room_event_cache, _drop_handles) = room.event_cache().await.unwrap();
+        let f = EventFactory::new().room(room_id).sender(*ALICE);
+        let old_id = event_id!("$shrunk-old");
+        let new_id = event_id!("$shrunk-new");
+
+        room_event_cache
+            .handle_joined_room_update(JoinedRoomUpdate {
+                timeline: Timeline {
+                    events: vec![f.text_msg("old").event_id(old_id).into_event()],
+                    ..Default::default()
+                },
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+        room_event_cache
+            .handle_joined_room_update(JoinedRoomUpdate {
+                timeline: Timeline {
+                    limited: true,
+                    prev_batch: Some("empty".to_owned()),
+                    events: Vec::new(),
+                },
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+        assert!(room_event_cache.events().await.unwrap().is_empty());
+        room_event_cache
+            .handle_joined_room_update(JoinedRoomUpdate {
+                timeline: Timeline {
+                    limited: true,
+                    prev_batch: Some("new".to_owned()),
+                    events: vec![f.text_msg("new").event_id(new_id).into_event()],
+                },
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+
+        let state = room_event_cache.inner.state.write().await.unwrap();
+        let candidate = state.history_candidate().await.unwrap();
+        let gaps: Vec<_> = candidate
+            .chunks()
+            .filter_map(|chunk| match chunk.content() {
+                ChunkContent::Gap(gap) => gap.history.clone(),
+                ChunkContent::Items(_) => None,
+            })
+            .collect();
+        assert_eq!(gaps.len(), 1);
+        assert_eq!(gaps[0].older_boundary.as_deref(), Some(old_id));
+        assert_eq!(gaps[0].newer_boundary.as_deref(), Some(new_id));
+    }
+
+    #[async_test]
     async fn test_auto_shrink_after_all_subscribers_are_gone() {
         let room_id = room_id!("!galette:saucisse.bzh");
 

Modified file: crates/matrix-sdk/src/event_cache/caches/room/state.rs+24 additions−8 deletions@@ -30,7 +30,8 @@ use matrix_sdk_base::{
         store::{EventCacheStoreLock, EventCacheStoreLockGuard, EventCacheStoreLockState},
     },
     linked_chunk::{
-        ChunkIdentifierGenerator, ChunkMetadata, LinkedChunkId, OwnedLinkedChunkId, Position,
+        ChunkContent, ChunkIdentifierGenerator, ChunkMetadata, LinkedChunkId, OwnedLinkedChunkId,
+        Position,
         Update, lazy_loader,
     },
     serde_helpers::{extract_edit_target, extract_thread_root},
@@ -828,6 +829,25 @@ impl<'a> RoomEventCacheStateLockWriteGuard<'a> {
         super::history::gap_positions(&self.state.room_linked_chunk)
     }
 
+    /// Memory can hold no events at all, after a shrink to a trailing gap.
+    async fn newest_retained_event_id(&self) -> Result<Option<OwnedEventId>, EventCacheError> {
+        let chunk = &self.state.room_linked_chunk;
+        if let Some(id) = chunk.revents().find_map(|(_, event)| event.event_id()) {
+            return Ok(Some(id));
+        }
+        let linked_chunk_id = LinkedChunkId::Room(&self.state.room_id);
+        let mut first = chunk.chunks().next().expect("a linked chunk is never empty").identifier();
+        while let Some(previous) = self.store.load_previous_chunk(linked_chunk_id, first).await? {
+            if let ChunkContent::Items(events) = &previous.content
+                && let Some(id) = events.iter().rev().find_map(Event::event_id)
+            {
+                return Ok(Some(id));
+            }
+            first = previous.identifier;
+        }
+        Ok(None)
+    }
+
     pub(super) async fn commit_history_candidate(
         &mut self,
         mut candidate: EventLinkedChunk,
@@ -940,16 +960,12 @@ impl<'a> RoomEventCacheStateLockWriteGuard<'a> {
         // previous-batch token would only result in fetching other events we
         // knew about. This is slightly incorrect in the presence of
         // network splits, but this has shown to be Good Enough™.
-        if !timeline.limited && self.state.room_linked_chunk.events().next().is_some()
-            || all_duplicates
-        {
+        let newest_retained = self.newest_retained_event_id().await?;
+        if !timeline.limited && newest_retained.is_some() || all_duplicates {
             prev_batch = None;
         }
 
-        let older_boundary = timeline
-            .limited
-            .then(|| self.state.room_linked_chunk.revents().find_map(|(_, event)| event.event_id()))
-            .flatten();
+        let older_boundary = timeline.limited.then_some(newest_retained).flatten();
         let newer_boundary =
             timeline.limited.then(|| events.iter().find_map(Event::event_id)).flatten();
         if older_boundary.is_some() && events.iter().any(|event| event.event_id() == older_boundary)

matrix-rust-sdk

Commit 090dac278176

Commit `090dac278176`