Struct Service 

pub struct Service {
    pub mutex: MutexMap<OwnedRoomId, ()>,
    services: Arc<OnceServices>,
    db: Data,
}

Manages current room state, event state snapshots, and forward extremities.

State mutations are serialized per room and delegated to the compressor for persistent delta encoding. The service also coordinates cache updates that follow forced state changes.

Fields

mutex: MutexMap<OwnedRoomId, ()>

Serializes room state as the middle per-room operation.

Acquire it after federation and before timeline insertion when those mutexes share a room. Never acquire the federation mutex while holding this guard.

services: Arc<OnceServices>

db: Data

Implementations

impl Service

pub async fn prune_forward_extremities( &self, room_id: &RoomId, extremities: &mut Vec<OwnedEventId>, goal: usize, trigger: Trigger, ) -> PruneSummary

Prunes the least useful leaves from a room’s forward-extremity candidates.

Dangling leaves and, for an administrative pass, referenced leaves are removed before the requested goal is charged. The selection never removes a local-server leaf and never empties a nonempty supplied vector; persistence remains the caller’s responsibility.

impl Service

async fn classify_extremities( &self, room_id: &RoomId, extremities: &[OwnedEventId], trigger: Trigger, ) -> Vec<Candidate<OwnedEventId>>

impl Service

async fn classify_leaf( &self, room_id: &RoomId, event_id: &EventId, trigger: Trigger, ) -> Partial

impl Service

pub async fn force_state( &self, room_id: &RoomId, shortstatehash: u64, statediffnew: Arc<CompressedState>, _statediffremoved: Arc<CompressedState>, state_lock: &RoomMutexGuard, ) -> Result

Forces a room to use an existing state snapshot.

Resolvable membership additions replay their cache effects before the current state hash is installed. Reverse-ID and PDU lookup failures are skipped, while a membership-effect error returns before the state hash changes. Joined counts are refreshed and the cached space summary is invalidated while the caller retains the room state guard.

impl Service

async fn force_member_effects(&self, room_id: &RoomId, pdu: &PduEvent) -> Result

Record the membership transition a replayed m.room.member event carries.

A replayed invite is judged by the sender named in its stripped state, so a local invitee’s row has to carry one. An event whose state key or content does not parse is skipped rather than failing the whole replay.

impl Service

async fn replayed_invite_state( &self, room_id: &RoomId, user_id: &UserId, pdu: &PduEvent, ) -> Result<StrippedRoomState>

Computes stripped state for a replayed invite, unless the row has some.

A reset reaches this before the new state is installed, so the summary built here is thinner than what the invite itself stored. Returning nothing leaves the stored row for mark_as_invited to keep. A probe that fails to read the row is an error, not an absence.

impl Service

pub async fn set_event_state( &self, event_id: &EventId, room_id: &RoomId, state_ids_compressed: Arc<CompressedState>, ) -> Result<ShortStateHash>

Associates an event with a complete compressed state snapshot.

The snapshot hash is reused when known; otherwise a short state hash and a delta from the room’s current snapshot are stored together. This records the event’s state without advancing the room’s current state.

impl Service

pub async fn append_to_state(&self, new_pdu: &PduEvent) -> Result<u64>

Derives the state snapshot produced by appending a local PDU.

The event is associated with the preceding snapshot before a state event creates a one-entry delta and a new short state hash. A non-state event retains the preceding hash, and an unchanged state event reuses it. The event’s short ID is allocated here if absent, which is the only allocation of it on the local append path.

Panics

Panics if a room’s first event is not state-bearing or if an unchanged state entry is found without a preceding room snapshot.

impl Service

pub fn set_room_state( &self, room_id: &RoomId, shortstatehash: u64, _mutex_lock: &RoomMutexGuard, )

Sets the room’s current state hash without updating derived state caches.

The guard proves that the caller owns the room state mutation path. Callers that change effective state must update the relevant caches separately.

impl Service

pub async fn get_auth_events( &self, room_id: &RoomId, kind: &TimelineEventType, sender: &UserId, state_key: Option<&str>, content: &RawValue, auth_rules: &AuthorizationRules, include_create: bool, ) -> Result<StateMap<PduEvent>>

where StateEventType: Send + Sync, StateKey: Send + Sync,

Fetches the auth events required from a room’s current state.

The required state keys are derived from the proposed event and room authorization rules. A room without current state yields an empty map, and missing short-key mappings or stored PDUs are omitted.

impl Service

pub async fn summary_stripped<Pdu: Event>( &self, event: &Pdu, ) -> Vec<Raw<AnyStrippedStateEvent>>

Builds stripped invite-state context for a membership event.

Recommended room state cells are fetched on a best-effort basis, then the supplied membership event is appended last. Failed state lookups are omitted from the summary.

impl Service

pub async fn summary_pdus<Pdu: Event>( &self, event: &Pdu, event_json: &CanonicalJsonObject, room_version: &RoomVersionId, ) -> Vec<Box<RawJsonValue>>

Builds full-PDU invite-state context for a membership event.

Recommended stored state and the supplied event are formatted for the given room version as required by MSC4311. Failed state or JSON lookups are omitted, and the supplied membership event is appended last.

impl Service

pub async fn get_room_version_rules( &self, room_id: &RoomId, ) -> Result<RoomVersionRules>

Returns the authorization and event-format rules for a room.

The rules are selected from the room version declared by its create event.

impl Service

pub async fn get_room_version(&self, room_id: &RoomId) -> Result<RoomVersionId>

Returns the room version declared by the room’s create event.

Missing or malformed create-event content is reported to the caller.

impl Service

pub async fn get_room_shortstatehash( &self, room_id: &RoomId, ) -> Result<ShortStateHash>

Returns the short hash of a room’s current state snapshot.

The lookup reads only the current room-to-state mapping and does not reconstruct the snapshot.

impl Service

pub async fn pdu_shortstatehash( &self, event_id: &EventId, ) -> Result<ShortStateHash>

Returns the state hash recorded for an event.

The event ID is first resolved to its short event ID before the snapshot association is read.

impl Service

pub async fn get_shortstatehash( &self, shorteventid: ShortEventId, ) -> Result<ShortStateHash>

Returns the state hash recorded for a short event ID.

This is the direct lookup used after an event ID has already been shortened.

impl Service

pub(super) fn delete_room_shortstatehash( &self, room_id: &RoomId, _mutex_lock: &Guard<OwnedRoomId, ()>, ) -> Result

Deletes a room’s current state-hash mapping.

The supplied guard proves exclusive access to the room state mutation path; compressed snapshots and event associations remain stored.

impl Service

pub async fn collapse_forward_extremities( &self, room_id: &RoomId, state_lock: &RoomMutexGuard, ) -> usize

Collapses a room to the resolvable forward extremity latest in stream order.

Rooms with at most one leaf, or with no leaf that resolves to a timeline count, are left unchanged. The return value is the number of leaves removed.

impl Service

pub fn get_forward_extremities<'a>( &'a self, room_id: &'a RoomId, ) -> impl Stream<Item = &EventId> + Send + '_

Streams the event IDs currently stored as a room’s forward extremities.

Invalid rows and cursor errors are omitted. Returned references borrow the database cursor and must be owned before they are retained across another poll.

impl Service

pub async fn set_forward_extremities<'a, I>( &'a self, room_id: &'a RoomId, event_ids: I, _state_lock: &'a RoomMutexGuard, )

where I: Iterator<Item = &'a EventId> + Send + 'a,

Replaces all stored forward extremities for a room.

Existing rows are removed before the supplied IDs are inserted while the caller holds the state guard. The wipe and reinsertion are not transactional, and errors encountered while scanning old rows are ignored.

impl Service

pub(super) async fn delete_all_rooms_forward_extremities( &self, room_id: &RoomId, ) -> Result

Deletes every stored forward extremity for a room.

Cursor errors are ignored, so this best-effort cleanup always returns success after removing every row it can read.

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 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 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 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.