From 752695c6ff9c61334e31931a5030ec45ffaba635 Mon Sep 17 00:00:00 2001 From: Benjamin Bouvier Date: Mon, 30 Mar 2026 11:27:28 +0200 Subject: [PATCH] chore: rename background request to automatic pagination request And associated vocabulary and fields. --- .../src/event_cache/automatic_pagination.rs | 32 ++++++------- .../matrix-sdk/src/event_cache/caches/mod.rs | 9 ++-- .../src/event_cache/caches/read_receipts.rs | 12 ++--- .../src/event_cache/caches/room/state.rs | 17 ++++--- crates/matrix-sdk/src/event_cache/mod.rs | 45 ++++++++++--------- .../tests/integration/event_cache/mod.rs | 2 +- 6 files changed, 63 insertions(+), 54 deletions(-) diff --git a/crates/matrix-sdk/src/event_cache/automatic_pagination.rs b/crates/matrix-sdk/src/event_cache/automatic_pagination.rs index 51d7c482c..931dd65b8 100644 --- a/crates/matrix-sdk/src/event_cache/automatic_pagination.rs +++ b/crates/matrix-sdk/src/event_cache/automatic_pagination.rs @@ -21,23 +21,24 @@ use tracing::{info, instrument, trace, warn}; use crate::event_cache::EventCacheInner; #[derive(Clone, Debug)] -pub(crate) enum BackgroundRequest { +pub(crate) enum AutomaticPaginationRequest { PaginateRoomBackwards { room_id: OwnedRoomId }, } -/// Listen to background requests, and execute them in real-time. +/// Listen to background automatic pagination requests, and execute them in +/// real-time. #[instrument(skip_all)] -pub(super) async fn background_requests_task( +pub(super) async fn automatic_paginations_task( inner: Arc, - mut receiver: mpsc::UnboundedReceiver, + mut receiver: mpsc::UnboundedReceiver, ) { - trace!("Spawning the background request task"); + trace!("Spawning the automatic pagination task"); let mut room_pagination_credits = HashMap::new(); while let Some(request) = receiver.recv().await { match request { - BackgroundRequest::PaginateRoomBackwards { room_id } => { + AutomaticPaginationRequest::PaginateRoomBackwards { room_id } => { let config = *inner.config.read().unwrap(); let credits = room_pagination_credits @@ -61,12 +62,13 @@ pub(super) async fn background_requests_task( match pagination.run_backwards_once(config.room_pagination_batch_size).await { Ok(outcome) => { - // Background requests must be idempotent, so we only decrement credits if + // Pagination requests must be idempotent, so we only decrement credits if // we actually paginated something new. if !outcome.reached_start || !outcome.events.is_empty() { *credits -= 1; } } + Err(err) => { warn!(for_room = %room_id, "Failed to run background pagination: {err}"); // Don't decrement credits in this case, to allow a @@ -78,7 +80,7 @@ pub(super) async fn background_requests_task( } // The sender has shut down, exit. - info!("Closing the background request task because receiver closed"); + info!("Closing the automatic pagination task because receiver closed"); } // MatrixMockServer et al. aren't available on wasm. @@ -96,20 +98,20 @@ mod tests { assert_let_timeout, event_cache::{ EventsOrigin, RoomEventCacheUpdate, - automatic_pagination::BackgroundRequest::PaginateRoomBackwards, + automatic_pagination::AutomaticPaginationRequest::PaginateRoomBackwards, }, test_utils::mocks::{MatrixMockServer, RoomMessagesResponseTemplate}, }; impl super::super::EventCache { - fn background_requests_sender( + fn pagination_requests_sender( &self, - ) -> Option> { - self.inner.background_requests_sender.get().cloned() + ) -> Option> { + self.inner.automatic_pagination_requests_sender.get().cloned() } } - /// Test that we can send background requests and trigger room paginations. + /// Test that we can send automatic pagination requests. #[async_test] async fn test_background_room_paginations() { let server = MatrixMockServer::new().await; @@ -150,7 +152,7 @@ mod tests { .await; // Send a request for a background pagination, - let sender = event_cache.background_requests_sender().unwrap(); + let sender = event_cache.pagination_requests_sender().unwrap(); sender.send(PaginateRoomBackwards { room_id: room_id.to_owned() }).unwrap(); // The room pagination happens in the background. @@ -227,7 +229,7 @@ mod tests { .await; // Send a request for a background pagination, - let sender = event_cache.background_requests_sender().unwrap(); + let sender = event_cache.pagination_requests_sender().unwrap(); sender.send(PaginateRoomBackwards { room_id: room_id.to_owned() }).unwrap(); // The room pagination happens in the background. diff --git a/crates/matrix-sdk/src/event_cache/caches/mod.rs b/crates/matrix-sdk/src/event_cache/caches/mod.rs index c642feac6..56c5e9a97 100644 --- a/crates/matrix-sdk/src/event_cache/caches/mod.rs +++ b/crates/matrix-sdk/src/event_cache/caches/mod.rs @@ -25,7 +25,8 @@ use tokio::sync::{broadcast::Sender, mpsc}; use super::{EventCacheError, EventsOrigin, Result}; use crate::{ - client::WeakClient, event_cache::automatic_pagination::BackgroundRequest, room::WeakRoom, + client::WeakClient, event_cache::automatic_pagination::AutomaticPaginationRequest, + room::WeakRoom, }; pub mod event_focused; @@ -52,7 +53,9 @@ impl Caches { linked_chunk_update_sender: Sender, auto_shrink_sender: mpsc::Sender, store: EventCacheStoreLock, - background_request_sender: Option>, + automatic_pagination_requests_sender: Option< + mpsc::UnboundedSender, + >, ) -> Result { let Some(client) = weak_client.get() else { return Err(EventCacheError::ClientDropped); @@ -87,7 +90,7 @@ impl Caches { linked_chunk_update_sender, store, pagination_status.clone(), - background_request_sender, + automatic_pagination_requests_sender, ) .await?; diff --git a/crates/matrix-sdk/src/event_cache/caches/read_receipts.rs b/crates/matrix-sdk/src/event_cache/caches/read_receipts.rs index 5b3806db9..f839a8118 100644 --- a/crates/matrix-sdk/src/event_cache/caches/read_receipts.rs +++ b/crates/matrix-sdk/src/event_cache/caches/read_receipts.rs @@ -112,7 +112,7 @@ use tokio::sync::mpsc::UnboundedSender; use tracing::{debug, instrument, trace, warn}; use crate::event_cache::{ - automatic_pagination::BackgroundRequest, caches::event_linked_chunk::EventLinkedChunk, + automatic_pagination::AutomaticPaginationRequest, caches::event_linked_chunk::EventLinkedChunk, }; trait RoomReadReceiptsExt { @@ -366,7 +366,7 @@ pub(crate) fn compute_unread_counts( linked_chunk: &EventLinkedChunk, read_receipts: &mut RoomReadReceipts, with_threading_support: bool, - background_request_sender: Option<&UnboundedSender>, + automatic_pagination_request_sender: Option<&UnboundedSender>, ) { debug!(?read_receipts, "Starting"); @@ -381,11 +381,11 @@ pub(crate) fn compute_unread_counts( if select_best_receipt_result.request_pagination { trace!("Requesting pagination to find a better receipt"); - // Note: we use `try_send` here to keep the method sync, as computing the - // perfect receipt is best effort. - if let Some(sender) = background_request_sender + if let Some(sender) = automatic_pagination_request_sender && sender - .send(BackgroundRequest::PaginateRoomBackwards { room_id: room_id.to_owned() }) + .send(AutomaticPaginationRequest::PaginateRoomBackwards { + room_id: room_id.to_owned(), + }) .is_err() { warn!("Failed to request pagination to find a better receipt"); diff --git a/crates/matrix-sdk/src/event_cache/caches/room/state.rs b/crates/matrix-sdk/src/event_cache/caches/room/state.rs index 39dffe183..8678c92f5 100644 --- a/crates/matrix-sdk/src/event_cache/caches/room/state.rs +++ b/crates/matrix-sdk/src/event_cache/caches/room/state.rs @@ -77,7 +77,8 @@ use super::{ use crate::{ Room, event_cache::{ - automatic_pagination::BackgroundRequest, caches::pagination::SharedPaginationStatus, + automatic_pagination::AutomaticPaginationRequest, + caches::pagination::SharedPaginationStatus, }, room::WeakRoom, }; @@ -151,9 +152,9 @@ pub struct RoomEventCacheState { /// [`super::RoomEventCache`]. subscriber_count: Arc, - /// A notifier to trigger backpagination under certain predefined - /// conditions. - background_request_sender: Option>, + /// A sender to trigger automatic pagination requests under certain + /// predefined conditions. + automatic_pagination_request_sender: Option>, } impl RoomEventCacheState { @@ -314,7 +315,9 @@ impl LockedRoomEventCacheState { linked_chunk_update_sender: Sender, store: EventCacheStoreLock, pagination_status: SharedObservable, - background_request_sender: Option>, + automatic_pagination_request_sender: Option< + mpsc::UnboundedSender, + >, ) -> Result { let store_guard = match store.lock().await? { // Lock is clean: all good! @@ -397,7 +400,7 @@ impl LockedRoomEventCacheState { waited_for_initial_prev_token: false, subscriber_count: Default::default(), pinned_event_cache: OnceLock::new(), - background_request_sender, + automatic_pagination_request_sender, })) } } @@ -1061,7 +1064,7 @@ impl<'a> RoomEventCacheStateLockWriteGuard<'a> { &self.state.room_linked_chunk, &mut read_receipts, self.state.enabled_thread_support, - self.state.background_request_sender.as_ref(), + self.state.automatic_pagination_request_sender.as_ref(), ); if prev_read_receipts != read_receipts { diff --git a/crates/matrix-sdk/src/event_cache/mod.rs b/crates/matrix-sdk/src/event_cache/mod.rs index 2dbd80850..7d97d639f 100644 --- a/crates/matrix-sdk/src/event_cache/mod.rs +++ b/crates/matrix-sdk/src/event_cache/mod.rs @@ -53,7 +53,7 @@ use tracing::{error, instrument, trace}; use crate::{ Client, client::{ClientInner, WeakClient}, - event_cache::automatic_pagination::{BackgroundRequest, background_requests_task}, + event_cache::automatic_pagination::{AutomaticPaginationRequest, automatic_paginations_task}, paginators::PaginatorError, }; @@ -154,9 +154,8 @@ pub struct EventCacheDropHandles { /// The task used to automatically shrink the linked chunks. auto_shrink_linked_chunk_task: BackgroundTaskHandle, - /// The task used to automatically handle background requests (like - /// paginations). - background_requests_task: Option, + /// The task used to handle automatic pagination requests. + automatic_paginations_task: Option, /// The task used to automatically redecrypt UTDs. #[cfg(feature = "e2e-encryption")] @@ -174,7 +173,7 @@ impl Drop for EventCacheDropHandles { self.listen_updates_task.abort(); self.ignore_user_list_update_task.abort(); self.auto_shrink_linked_chunk_task.abort(); - if let Some(task) = self.background_requests_task.take() { + if let Some(task) = self.automatic_paginations_task.take() { task.abort(); } } @@ -242,7 +241,7 @@ impl EventCache { by_room: Default::default(), drop_handles: Default::default(), auto_shrink_sender: Default::default(), - background_requests_sender: Default::default(), + automatic_pagination_requests_sender: Default::default(), generic_update_sender, linked_chunk_update_sender, _thread_subscriber_task: thread_subscriber_task, @@ -321,19 +320,19 @@ impl EventCache { redecryptor::Redecryptor::new(&client, Arc::downgrade(&self.inner), receiver, &self.inner.linked_chunk_update_sender) }; - let background_requests_task = if self.config().experimental_auto_backpagination { + let automatic_paginations_task = if self.config().experimental_auto_backpagination { let (sender, receiver) = mpsc::unbounded_channel(); - // Run the deferred initialization of the background request sender, that is shared - // with every room. - self.inner.background_requests_sender.get_or_init(|| sender); + // Run the deferred initialization of the automatic pagination request sender, that + // is shared with every room. + self.inner.automatic_pagination_requests_sender.get_or_init(|| sender); - trace!("spawning the backgrounds requests task"); - Some(task_monitor.spawn_background_task("event_cache::background_requests_task", background_requests_task( + trace!("spawning the automatic paginations task"); + Some(task_monitor.spawn_background_task("event_cache::automatic_paginations_task", automatic_paginations_task( self.inner.clone(), receiver ))) } else { - trace!("backgrounds requests task is disabled"); + trace!("automatic paginations task is disabled"); None }; @@ -343,7 +342,7 @@ impl EventCache { auto_shrink_linked_chunk_task, #[cfg(feature = "e2e-encryption")] _redecryptor: redecryptor, - background_requests_task + automatic_paginations_task }) }); @@ -411,7 +410,7 @@ pub struct EventCacheConfig { pub experimental_auto_backpagination: bool, /// The maximum number of allowed room paginations, for a given room, that - /// can be executed in the background request task. + /// can be executed in the automatic paginations task. /// /// After that number of paginations, the task will stop executing /// paginations for that room *in the background* (user-requested @@ -420,8 +419,8 @@ pub struct EventCacheConfig { /// Defaults to [`EventCacheConfig::DEFAULT_ROOM_PAGINATION_CREDITS`]. pub room_pagination_per_room_credit: usize, - /// The number of messages to paginate in a single batch, when executing a - /// background pagination request. + /// The number of messages to paginate in a single batch, when executing an + /// automatic pagination request. /// /// Defaults to [`EventCacheConfig::DEFAULT_ROOM_PAGINATION_BATCH_SIZE`]. pub room_pagination_batch_size: u16, @@ -435,13 +434,13 @@ impl EventCacheConfig { /// loading the pinned events. pub const DEFAULT_MAX_CONCURRENT_REQUESTS: usize = 8; - /// The default number of credits to give to a room for background + /// The default number of credits to give to a room for automatic /// paginations (see also /// [`EventCacheConfig::room_pagination_per_room_credit`]). pub const DEFAULT_ROOM_PAGINATION_CREDITS: usize = 20; /// The default number of messages to paginate in a single batch, when - /// executing a background pagination request (see also + /// executing an automatic pagination request (see also /// [`EventCacheConfig::room_pagination_batch_size`]). pub const DEFAULT_ROOM_PAGINATION_BATCH_SIZE: u16 = 30; } @@ -498,11 +497,13 @@ struct EventCacheInner { /// See doc comment of [`EventCache::auto_shrink_linked_chunk_task`]. auto_shrink_sender: OnceLock>, - /// A sender for background requests, that is shared with every room. + /// A sender for automatic pagination requests, that is shared with every + /// room. /// /// It's a `OnceLock` because its initialization is deferred to /// [`EventCache::subscribe`]. - background_requests_sender: OnceLock>, + automatic_pagination_requests_sender: + OnceLock>, /// A sender for room generic update. /// @@ -705,7 +706,7 @@ impl EventCacheInner { "we must have called `EventCache::subscribe()` before calling here.", ), self.store.clone(), - self.background_requests_sender.get().cloned(), + self.automatic_pagination_requests_sender.get().cloned(), ) .await?; diff --git a/crates/matrix-sdk/tests/integration/event_cache/mod.rs b/crates/matrix-sdk/tests/integration/event_cache/mod.rs index 7660d3cb9..0fa5e1bf5 100644 --- a/crates/matrix-sdk/tests/integration/event_cache/mod.rs +++ b/crates/matrix-sdk/tests/integration/event_cache/mod.rs @@ -602,7 +602,7 @@ async fn test_reset_while_backpaginating() { wait_for_initial_events(events, &mut room_stream).await; // We're going to cause a small race: - // - a background request to sync will be sent, + // - a pagination request to sync will be sent, // - a backpagination will be sent concurrently. // // So events have to happen in this order: