matrix-rust-sdk

public

Star0

Fork 0

Watch0

52 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `e88ebe7d5a58`

tarball

atagen <boss@atagen.co>2026-10-27 10:41 UTC

2 files changed+29-11

sliding-sync: keep the last saved pos while the event cache is behind

f05c1368 saved `pos` anyway once the event cache had not handled a response within 10s, which only made sense if the event cache always caught up. A soak on wasm then had it stall for good in cache creation, and every capped save skipped events for good. A lagging event cache now leaves the last saved `pos` in place, so a restart replays from it, or gets limited timelines with gaps if the server dropped it. Once known to be behind, a response waits at most 1s before checking again.

Modified file: crates/matrix-sdk/src/sliding_sync/builder.rs+2 additions−1 deletions@@ -1,7 +1,7 @@
 use std::{
     collections::BTreeMap,
     fmt::Debug,
-    sync::{Arc, RwLock as StdRwLock},
+    sync::{Arc, RwLock as StdRwLock, atomic::AtomicBool},
     time::Duration,
 };
 
@@ -301,6 +301,7 @@ impl SlidingSyncBuilder {
             extensions: self.extensions.unwrap_or_default(),
 
             internal_channel: internal_channel_sender,
+            event_cache_behind: AtomicBool::new(false),
 
             poll_timeout: self.poll_timeout,
             network_timeout: self.network_timeout,

Modified file: crates/matrix-sdk/src/sliding_sync/mod.rs+27 additions−10 deletions@@ -26,7 +26,10 @@ use std::{
     collections::{BTreeMap, btree_map::Entry},
     fmt::Debug,
     future::Future,
-    sync::{Arc, RwLock as StdRwLock, RwLockWriteGuard as StdRwLockWriteGuard},
+    sync::{
+        Arc, RwLock as StdRwLock, RwLockWriteGuard as StdRwLockWriteGuard,
+        atomic::{AtomicBool, Ordering},
+    },
     time::Duration,
 };
 
@@ -53,10 +56,14 @@ pub use self::{builder::*, client::VersionBuilderError, error::*, list::*};
 use self::{cache::restore_sliding_sync_state, client::SlidingSyncResponseProcessor};
 use crate::{Client, Result, config::RequestConfig};
 
-/// How long a rooms response waits for the event cache before its `pos` is
-/// saved anyway.
+/// How long a rooms response waits for the event cache before it gives up on
+/// saving its `pos`.
 const ROOM_UPDATES_WAIT: Duration = Duration::from_secs(10);
 
+/// The same wait once the event cache is known to be behind, long enough for a
+/// recovered one to handle the latest response.
+const ROOM_UPDATES_RECHECK: Duration = Duration::from_secs(1);
+
 /// The Sliding Sync instance.
 ///
 /// It is OK to clone this type as much as you need: cloning it is cheap.
@@ -123,6 +130,10 @@ pub(super) struct SlidingSyncInner {
     /// Internal channel used to pass messages between Sliding Sync and other
     /// types.
     internal_channel: Sender<SlidingSyncInternalMessage>,
+
+    /// Whether the event cache had not handled every response when the last
+    /// one was handled, in which case `pos` was not saved.
+    event_cache_behind: AtomicBool,
 }
 
 impl SlidingSync {
@@ -654,15 +665,21 @@ impl SlidingSync {
                 .await?;
 
             // A `pos` saved before the event cache stores this response's events
-            // resumes past them after a kill, and no gap is left to fetch them.
-            if this.must_process_rooms_response().await
-                && !this.inner.client.event_cache().wait_for_room_updates(ROOM_UPDATES_WAIT).await
-            {
-                warn!("Saving the position before the event cache handled the response");
+            // resumes past them after a kill, and no gap is left to fetch them. The
+            // event cache can stall for good, so a lagging one leaves the last saved
+            // `pos` in place, and a restart replays from there instead.
+            let stored = !this.must_process_rooms_response().await || {
+                let behind = this.inner.event_cache_behind.load(Ordering::SeqCst);
+                let wait = if behind { ROOM_UPDATES_RECHECK } else { ROOM_UPDATES_WAIT };
+                this.inner.client.event_cache().wait_for_room_updates(wait).await
+            };
+            this.inner.event_cache_behind.store(!stored, Ordering::SeqCst);
+            if stored {
+                this.cache_to_storage(&position_guard).await?;
+            } else {
+                warn!("Not saving the position, the event cache hasn't handled every response");
             }
 
-            this.cache_to_storage(&position_guard).await?;
-
             // Release the position guard lock.
             // It means that other responses can be generated and then handled later.
             drop(position_guard);

matrix-rust-sdk

Commit e88ebe7d5a58

Commit `e88ebe7d5a58`