Struct ControlledMemoryStore 

pub struct ControlledMemoryStore { /* private fields */ }

Available on crate features testing only.

A MemoryStore whose linked chunk writes can be blocked.

This is meant for tests that need to control when, or whether, the event cache persists its data: for instance to check what the rest of the SDK does while the store is slow, or when it returns an error.

Only EventCacheStore::handle_linked_chunk_updates is affected. All the other methods are forwarded to the inner MemoryStore as is.

Implementations

impl ControlledMemoryStore

pub fn new() -> Self

Create a new store, which doesn’t block writes.

pub fn block_writes(&self)

Block linked chunk writes until Self::unblock_writes is called.

A blocked write still counts as started for Self::wait_for_write_to_start.

pub fn unblock_writes(&self)

Let the blocked linked chunk writes, and the next ones, go through.

pub async fn wait_for_write_to_start(&self)

Wait until a linked chunk write starts.

Returns at once if a write has started since the last call.

pub async fn wait_for_write_to_finish(&self)

Wait until a linked chunk write finishes.

Returns at once if a write has finished since the last call.

Trait Implementations

impl Clone for ControlledMemoryStore

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ControlledMemoryStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ControlledMemoryStore

fn default() -> Self

Returns the “default value” for a type.

impl EventCacheStore for ControlledMemoryStore

type Error = EventCacheStoreError

The error type used by this event cache store.

fn handle_linked_chunk_updates<'life0, 'life1, 'async_trait>( &'life0 self, linked_chunk_id: LinkedChunkId<'life1>, updates: Vec<Update<Event, Gap>>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

An Update reflects an operation that has happened inside a linked chunk. The linked chunk is used by the event cache to store the events in-memory. This method aims at forwarding this update inside this store.

fn close<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Close the store, releasing all held resources (database connections, file descriptors, file locks).

fn reopen<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reopen the store after a Self::close(), re-acquiring database connections.

fn try_take_leased_lock<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, lease_duration_ms: u32, key: &'life1 str, holder: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<CrossProcessLockGeneration>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Try to take a lock using the given store.

fn load_all_chunks_metadata<'life0, 'life1, 'async_trait>( &'life0 self, linked_chunk_id: LinkedChunkId<'life1>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ChunkMetadata>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load all of the chunks’ metadata for the given LinkedChunkId.

fn load_last_chunk<'life0, 'life1, 'async_trait>( &'life0 self, linked_chunk_id: LinkedChunkId<'life1>, ) -> Pin<Box<dyn Future<Output = Result<(Option<RawChunk<Event, Gap>>, ChunkIdentifierGenerator), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load the last chunk of the LinkedChunk holding all events of the room identified by room_id.

fn load_previous_chunk<'life0, 'life1, 'async_trait>( &'life0 self, linked_chunk_id: LinkedChunkId<'life1>, before_chunk_identifier: ChunkIdentifier, ) -> Pin<Box<dyn Future<Output = Result<Option<RawChunk<Event, Gap>>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load the chunk before the chunk identified by before_chunk_identifier of the LinkedChunk holding all events of the room identified by room_id

fn load_thread_info<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, thread_id: &'life2 EventId, insert_default_if_missing: bool, ) -> Pin<Box<dyn Future<Output = Result<Option<ThreadInfo>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load the ThreadInfo associated to room_id and thread_id.

fn update_thread_info<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, thread_id: &'life2 EventId, thread_info: &'life3 ThreadInfo, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Update the ThreadInfo associated to room_id and thread_id.

fn clear_all_events<'life0, 'life1, 'async_trait>( &'life0 self, room_id: Option<&'life1 RoomId>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Clear persisted events for all the rooms if room_id is None, or a single room otherwise.

fn filter_duplicated_events<'life0, 'life1, 'async_trait>( &'life0 self, linked_chunk_id: LinkedChunkId<'life1>, events: Vec<OwnedEventId>, ) -> Pin<Box<dyn Future<Output = Result<Vec<(OwnedEventId, Position)>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a set of event IDs, return the duplicated events along with their position if there are any.

fn find_event<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, event_id: &'life2 EventId, ) -> Pin<Box<dyn Future<Output = Result<Option<Event>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Find an event by its ID in a room.

fn find_event_relations<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, event_id: &'life2 EventId, filters: Option<&'life3 [RelationType]>, ) -> Pin<Box<dyn Future<Output = Result<Vec<(Event, Option<Position>)>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Find all the events (alongside their position in the room’s linked chunk, if available) that relate to a given event.

fn get_room_events<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, event_type: Option<&'life2 str>, session_id: Option<&'life3 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Event>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Get all events in this room.

fn save_event<'life0, 'life1, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, event: Event, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save an event, that might or might not be part of an existing linked chunk.

fn get_size<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<usize>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the size of the store in bytes, if known.