Struct Service 

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

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

Scores the retained forward-extremity set and drops the least useful leaves in place until goal of them are gone, sweeping dangling leaves (and, under Trigger::Admin, already-referenced ones) for free first. Never drops an own-server leaf and always leaves at least one survivor.

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

Set the room to the given statehash and update caches.

impl Service

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

Generates a new StateHash and associates it with the incoming event.

This adds all current state events (not including the incoming event) to stateid_pduid and adds the incoming event to eventid_statehash.

impl Service

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

Generates a new StateHash and associates it with the incoming event.

This adds all current state events (not including the incoming event) to stateid_pduid and adds the incoming event to eventid_statehash. The event’s short id is allocated here if absent, which is the only allocation of it on the local append path.

impl Service

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

Set the state hash to a new version, but does not update state_cache.

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,

This fetches auth events from the current state.

impl Service

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

impl Service

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

Like summary_stripped, but formats each event as a full federation PDU per the room version’s event format (MSC4311). The membership event is formatted from its event_json; the recommended state cells are fetched from stored room state.

impl Service

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

Returns the room’s version rules

impl Service

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

Returns the room’s version.

impl Service

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

impl Service

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

Returns the state hash at this event.

impl Service

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

Returns the state hash at this event.

impl Service

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

impl Service

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

Collapses the room to a single forward extremity, keeping the one furthest along in stream order, and returns the number removed.

impl Service

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

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,

impl Service

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

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.