Struct Service 

pub struct Service {
    pub stateinfo_cache: Mutex<LruCache<ShortStateHash, Vec<ShortStateInfo>>>,
    db: Data,
    services: Arc<OnceServices>,
}

Persists, reconstructs, and caches compressed room state snapshots.

New snapshots are stored as bounded delta chains and flattened when their depth or relative size becomes inefficient. Cached chain entries include both each frame’s delta and its fully materialized state.

Fields

stateinfo_cache: Mutex<LruCache<ShortStateHash, Vec<ShortStateInfo>>>

Reconstructed state chains keyed by their requested short state hash.

db: Data

services: Arc<OnceServices>

Implementations

impl Service

pub async fn load_shortstatehash_info( &self, shortstatehash: ShortStateHash, ) -> Result<Vec<ShortStateInfo>>

Loads and materializes the parent chain for a short state hash.

The returned frames are ordered root-first and include each frame’s full state plus its added and removed entries. A previously reconstructed chain is returned from the LRU cache.

impl Service

async fn cache_shortstatehash_info( &self, shortstatehash: ShortStateHash, stack: Vec<ShortStateInfo>, ) -> Result

Caches a reconstructed state chain under its requested short hash.

Lock poisoning is reported without modifying the cache.

impl Service

async fn new_shortstatehash_info( &self, shortstatehash: ShortStateHash, ) -> Result<Vec<ShortStateInfo>>

impl Service

pub fn compress_state_events<'a, I>( &'a self, state: I, ) -> impl Stream<Item = CompressedStateEvent> + Send + 'a

where I: Iterator<Item = (&'a ShortStateKey, &'a EventId)> + Clone + Debug + Send + 'a,

Compresses a stream of state-key and event-ID pairs.

Missing short event IDs are allocated as the returned stream is polled, and each result packs both short IDs into the fixed-width representation.

impl Service

pub async fn compress_state_event( &self, shortstatekey: ShortStateKey, event_id: &EventId, ) -> CompressedStateEvent

Compresses one state key and event ID into its fixed-width representation.

A short event ID is allocated first when the event has not been seen.

impl Service

pub fn save_state_from_diff( &self, txn: &mut Txn, shortstatehash: ShortStateHash, statediffnew: Arc<CompressedState>, statediffremoved: Arc<CompressedState>, diff_to_sibling: usize, parent_states: Vec<ShortStateInfo>, ) -> Result

Stages a compressed state delta under a new short state hash.

The caller-owned transaction receives the row but is not executed here. Chains deeper than three parent frames, or deltas too large relative to their parent, are recursively flattened into an earlier layer.

impl Service

pub async fn save_state( &self, room_id: &RoomId, new_state_ids_compressed: Arc<CompressedState>, ) -> Result<HashSetCompressStateEvent>

Saves a complete compressed snapshot and reports its previous-state delta.

An existing content hash is reused; otherwise the short hash and delta row are created together. Failure to reconstruct the previous chain is treated as an absent parent, while an exactly unchanged snapshot returns empty sets.

impl Service

pub(crate) async fn get_statediff( &self, shortstatehash: ShortStateHash, ) -> Result<StateDiff>

Reads one state’s delta row into its typed form.

Rows round-trip through [save_statediff], the pair being the only codec for the statediff encoding.

Panics

Panics if a stored delta row is shorter than its eight-byte parent prefix.

impl Service

pub(crate) fn save_statediff( &self, txn: &mut Txn, shortstatehash: ShortStateHash, diff: &StateDiff, )

Serializes one state’s delta into the caller’s transaction.

Added and removed entries are emitted in sorted set order. The removed run follows an all-zero sentinel only when it is nonempty, and this method does not execute the transaction.

Trait Implementations

impl Service for Service

fn build(args: &Args<'_>) -> Result<Arc<Self>>

Implement the construction of the service instance. Services are generally singletons so expect this to only be called once for a service type. Note that it may be called again after a server reload, but the prior instance will have been dropped first. Failure will shutdown the server with an error.

fn memory_usage<'life0, 'life1, 'async_trait>( &'life0 self, out: &'life1 mut (dyn Write + Send), ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

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

Memory usage report in a markdown string.

fn clear_cache<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Clear any caches or similar runtime state.

fn name(&self) -> &str

Return the name of the service. i.e. crate::service::make_name(std::module_path!())

fn worker<'async_trait>( self: Arc<Self>, ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

where Self: 'async_trait,

Implement the service’s worker loop. The service manager spawns a task and calls this function after all services have been built.

fn interrupt<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Interrupt the service. This is sent to initiate a graceful shutdown. The service worker should return from its work loop.

fn unconstrained(&self) -> bool

Return true if the service worker opts out of the tokio cooperative budgeting. This can reduce tail latency at the risk of event loop starvation.