Struct Service 

pub struct Service {
    services: Arc<OnceServices>,
}

Resolves room state and answers state-based authorization questions.

Accessors share the state, timeline, short-ID, and membership services so callers use one interpretation of current and historical room state.

Fields

services: Arc<OnceServices>

Implementations

impl Service

pub async fn erased_for_server( &self, origin: &ServerName, pdu: CanonicalJsonObject, ) -> CanonicalJsonObject

Applies MSC4025 pruning to an event served over federation.

The event is pruned when its sender is erased and origin had no joined user at the event. This check composes with history visibility rather than replacing it, and unresolved redaction inputs leave the event intact.

impl Service

pub async fn erased_view(&self, user_id: &UserId, pdu: &Pdu) -> Option<Pdu>

MSC4025: the pruned clone of pdu for recipient user_id, or None to serve the original.

A prune that cannot read the room version’s redaction rules also yields None, so an unprunable event is served intact rather than withheld.

impl Service

pub async fn erased_for(&self, user_id: &UserId, pdu: &Pdu) -> bool

MSC4025: whether pdu serves pruned to user_id: its sender is erased and the recipient was not joined in the room state at the event.

The erasure check runs first and alone: it is a point get that is almost always false, while the membership read is a state lookup that only an erased sender needs.

impl Service

async fn pruned(&self, pdu: &Pdu) -> Option<Pdu>

Prune per the room version’s redaction rules. The pruned form carries no redacted_because; no redaction event exists for a serve-time erasure.

impl Service

pub async fn room_state_get_content<T>( &self, room_id: &RoomId, event_type: &StateEventType, state_key: &str, ) -> Result<T>

where T: for<'de> Deserialize<'de> + Send,

Deserializes one current state event’s content.

The event is selected by (event_type, state_key). Snapshot lookup, timeline lookup, and content errors are returned to the caller.

impl Service

pub fn room_state_type_pdus<'a>( &'a self, room_id: &'a RoomId, event_type: &'a StateEventType, ) -> impl Stream<Item = Result<impl Event>> + Send + 'a

Streams current state events of one type.

Failure to resolve the room’s current snapshot is yielded as an error. Missing reverse mappings and unavailable PDUs are skipped by the delegated best-effort stream.

impl Service

pub fn room_state_full<'a>( &'a self, room_id: &'a RoomId, ) -> impl Stream<Item = Result<((StateEventType, StateKey), impl Event)>> + Send + 'a

Streams the room’s full current state with type and state keys.

Failure to resolve the current snapshot is yielded as an error. Entries whose IDs, PDUs, or state keys cannot be resolved are skipped.

impl Service

pub fn room_state_full_pdus<'a>( &'a self, room_id: &'a RoomId, ) -> impl Stream<Item = Result<impl Event>> + Send + 'a

Streams every resolvable PDU in the room’s current state.

Failure to resolve the current snapshot is yielded as an error. Individual state entries with missing reverse mappings or PDUs are skipped.

impl Service

pub async fn room_state_get_id( &self, room_id: &RoomId, event_type: &StateEventType, state_key: &str, ) -> Result<OwnedEventId>

Returns the event ID for one current state tuple.

The room’s current snapshot must exist, and both short-ID mappings must resolve for (event_type, state_key).

impl Service

pub fn room_state_keys_with_ids<'a>( &'a self, room_id: &'a RoomId, event_type: &'a StateEventType, ) -> impl Stream<Item = Result<(StateKey, OwnedEventId)>> + Send + 'a

Streams state keys and event IDs for one current state event type.

Failure to resolve the current snapshot is yielded as an error. Individual short-ID mapping failures are omitted by the best-effort inner stream.

impl Service

pub fn room_state_keys<'a>( &'a self, room_id: &'a RoomId, event_type: &'a StateEventType, ) -> impl Stream<Item = Result<StateKey>> + Send + 'a

Streams state keys for one current state event type.

Failure to resolve the current snapshot is yielded as an error. Individual state-key mapping failures are omitted by the best-effort inner stream.

impl Service

pub async fn room_state_get( &self, room_id: &RoomId, event_type: &StateEventType, state_key: &str, ) -> Result<Pdu>

Returns one current state PDU.

The event is selected by (event_type, state_key). Snapshot, short-ID, and timeline lookup failures are returned to the caller.

impl Service

pub async fn server_can_see_event( &self, origin: &ServerName, room_id: &RoomId, event_id: &EventId, ) -> bool

Reports whether a server may see an event over federation.

Missing event state is allowed, and missing or invalid history visibility defaults to shared. For invited and joined, a currently joined user from the origin must also hold the required membership at the event.

impl Service

pub async fn server_joined_at_pdu( &self, origin: &ServerName, event_id: &EventId, ) -> bool

Reports whether any user from an origin was joined at an event.

This MSC4025 helper scans membership state at the event and denies when the snapshot cannot be resolved. Invalid user state keys are skipped.

impl Service

pub async fn user_was_joined( &self, shortstatehash: ShortStateHash, user_id: &UserId, ) -> bool

Reports whether a user was joined in a selected state snapshot.

Missing or invalid membership state is treated as leave, so lookup errors return false.

impl Service

pub async fn user_was_invited( &self, shortstatehash: ShortStateHash, user_id: &UserId, ) -> bool

Reports whether a user was invited or joined in a selected state snapshot.

Missing or invalid membership state is treated as leave, so lookup errors return false.

impl Service

pub async fn user_membership( &self, shortstatehash: ShortStateHash, user_id: &UserId, ) -> MembershipState

Returns a user’s membership in a selected state snapshot.

Missing state, unavailable events, and invalid membership content all fall back to [MembershipState::Leave].

impl Service

pub async fn user_membership_at_pdu( &self, user_id: &UserId, pdu: &Pdu, ) -> MembershipState

MSC4115: the user’s room membership “just after” the given PDU landed.

pdu_shortstatehash returns state-before-the-event, so a member event targeting user_id overrides that lookup with its own content. Missing or invalid state falls back to [MembershipState::Leave].

impl Service

pub async fn state_get_content<T>( &self, shortstatehash: ShortStateHash, event_type: &StateEventType, state_key: &str, ) -> Result<T>

where T: for<'de> Deserialize<'de> + Send,

Deserializes one event’s content from a selected state snapshot.

The event is selected by (event_type, state_key). State, short-ID, timeline, and content errors are returned to the caller.

impl Service

pub async fn state_contains( &self, shortstatehash: ShortStateHash, event_type: &StateEventType, state_key: &str, ) -> bool

Reports whether a state snapshot contains one state tuple.

Failure to resolve the tuple’s short state key or load the snapshot is treated as absence.

impl Service

pub async fn state_contains_type( &self, shortstatehash: ShortStateHash, event_type: &StateEventType, ) -> bool

Reports whether a state snapshot contains any event of one type.

Snapshot and state-key mapping errors are omitted by the underlying best-effort stream and can therefore produce false.

impl Service

pub async fn state_contains_shortstatekey( &self, shortstatehash: ShortStateHash, shortstatekey: ShortStateKey, ) -> bool

Reports whether a snapshot contains a short state key.

The compressed snapshot is searched across every short event ID for the key. Failure to load the snapshot is treated as absence.

impl Service

pub async fn state_get( &self, shortstatehash: ShortStateHash, event_type: &StateEventType, state_key: &str, ) -> Result<Pdu>

Returns one PDU from a selected state snapshot.

The event is selected by (event_type, state_key). Short-ID and timeline lookup failures are returned to the caller.

impl Service

pub async fn state_get_id( &self, shortstatehash: ShortStateHash, event_type: &StateEventType, state_key: &str, ) -> Result<OwnedEventId>

Returns one event ID from a selected state snapshot.

Both the state tuple’s short key and its short event ID must resolve.

impl Service

pub async fn state_get_shortid( &self, shortstatehash: ShortStateHash, event_type: &StateEventType, state_key: &str, ) -> Result<ShortEventId>

Returns one short event ID from a selected state snapshot.

The method resolves (event_type, state_key) to a short state key and searches the compressed snapshot. An absent tuple is returned as not found.

impl Service

pub fn state_type_pdus<'a>( &'a self, shortstatehash: ShortStateHash, event_type: &'a StateEventType, ) -> impl Stream<Item = impl Event> + Send + 'a

Streams resolvable events of one type from a state snapshot.

Snapshot, short-ID, and timeline lookup failures are skipped, so this is a best-effort view rather than a completeness guarantee.

impl Service

pub fn state_keys_with_ids<'a>( &'a self, shortstatehash: ShortStateHash, event_type: &'a StateEventType, ) -> impl Stream<Item = (StateKey, OwnedEventId)> + Send + 'a

Streams state keys and event IDs for one type in a snapshot.

Snapshot and reverse-mapping failures are skipped. The stream buffers the selected short IDs before resolving event IDs in a batch.

impl Service

pub fn state_keys_with_shortids<'a>( &'a self, shortstatehash: ShortStateHash, event_type: &'a StateEventType, ) -> impl Stream<Item = (StateKey, ShortEventId)> + Send + 'a

Streams state keys and short event IDs for one type in a snapshot.

Snapshot and short-state-key mapping failures are skipped. The full compressed snapshot is buffered before filtering by event type.

impl Service

pub fn state_keys<'a>( &'a self, shortstatehash: ShortStateHash, event_type: &'a StateEventType, ) -> impl Stream<Item = StateKey> + Send + 'a

Streams state keys for one event type in a snapshot.

Snapshot and short-state-key mapping failures are skipped, so the stream is best effort.

impl Service

pub fn state_removed( &self, shortstatehash: (ShortStateHash, ShortStateHash), ) -> impl Stream<Item = (ShortStateKey, ShortEventId)> + Send + '_

Streams state entries removed between two snapshots.

Entries present in the first hash and absent from the second are returned. Failure to load either snapshot produces an empty stream.

impl Service

pub fn state_added( &self, shortstatehash: (ShortStateHash, ShortStateHash), ) -> impl Stream<Item = (ShortStateKey, ShortEventId)> + Send + '_

Streams state entries added between two snapshots.

Entries absent from the first hash and present in the second are returned. Failure to load either snapshot produces an empty stream.

impl Service

pub fn state_full( &self, shortstatehash: ShortStateHash, ) -> impl Stream<Item = ((StateEventType, StateKey), impl Event)> + Send + '_

Streams resolvable keyed events from a state snapshot.

Events without a state key and entries with failed short-ID or timeline lookups are omitted by the underlying best-effort PDU stream.

impl Service

pub fn state_full_pdus( &self, shortstatehash: ShortStateHash, ) -> impl Stream<Item = impl Event> + Send + '_

Streams every resolvable PDU from a state snapshot.

Snapshot, reverse-mapping, and timeline failures are silently skipped. Use Self::state_full_pdus_strict when completeness is required.

impl Service

pub fn state_full_pdus_strict( &self, shortstatehash: ShortStateHash, ) -> impl Stream<Item = Result<impl Event>> + Send + '_

Streams every PDU in a state snapshot while preserving errors.

Snapshot and reverse-mapping failures are emitted before any partial ID map. Timeline lookup failures are yielded for their individual entries.

impl Service

pub fn state_full_ids( &self, shortstatehash: ShortStateHash, ) -> impl Stream<Item = (ShortStateKey, OwnedEventId)> + Send + '_

Streams short state keys and resolvable event IDs from a snapshot.

Snapshot and reverse-mapping failures are skipped, so this best-effort stream can be partial. Use Self::state_full_ids_strict for completeness.

impl Service

pub fn state_full_ids_strict( &self, shortstatehash: ShortStateHash, ) -> impl Stream<Item = Result<(ShortStateKey, OwnedEventId)>> + Send + '_

Streams a complete short-state-key to event-ID map for a snapshot.

Snapshot and reverse-mapping failures are returned without yielding a partial map.

impl Service

pub fn state_full_shortids( &self, shortstatehash: ShortStateHash, ) -> impl Stream<Item = Result<(ShortStateKey, ShortEventId)>> + Send + '_

Streams every compressed (short state key, short event ID) pair.

A snapshot-load failure is yielded as an error. Once loaded, the immutable compressed state is copied into the stream without further lookups.

impl Service

async fn load_full_state( &self, shortstatehash: ShortStateHash, ) -> Result<Arc<CompressedState>>

impl Service

pub async fn user_can_redact( &self, redacts: &EventId, sender: &UserId, room_id: &RoomId, federation: bool, ) -> Result<bool>

Reports whether a user may redact an event in a room.

Cross-room targets are denied, while create and server-ACL targets return a forbidden error. Federation permits the own-event rule for any sender on the target sender’s server; power-level failures fall back to create-event ownership and exact sender equality.

impl Service

pub async fn user_can_see_event<Pdu>(&self, user_id: &UserId, pdu: &Pdu) -> bool

where Pdu: Event,

Reports whether a user may see an event under its historical visibility.

Missing event state is allowed, and missing or invalid history visibility defaults to shared. The shared decision also accounts for the user’s membership intervals around the event. Under joined and invited, the user’s own membership event is visible when the membership it sets qualifies, per the spec’s before-or-after rule.

impl Service

async fn history_visibility_at( &self, event_id: &EventId, ) -> Option<(ShortStateHash, HistoryVisibility)>

The room state an event was sent in and the history visibility it carried.

Missing or invalid history visibility reads as shared, and None means the event has no recorded state.

impl Service

async fn user_shared_history( &self, shortstatehash: ShortStateHash, room_id: &RoomId, event_id: &EventId, user_id: &UserId, ) -> bool

Whether a user may see an event under shared history visibility.

A current member sees the whole room, which the first check answers without touching room state. A former member keeps events through their latest leave, and lookup failures deny access.

impl Service

pub async fn user_can_see_state_events( &self, user_id: &UserId, room_id: &RoomId, ) -> bool

Reports whether a user may read the room’s current state events.

Current membership grants immediate access. Otherwise world-readable history grants access; invited and shared visibility consult current invitation or retained once-joined metadata. Missing visibility defaults to shared.

impl Service

pub async fn user_can_see_room( &self, user_id: &UserId, room_id: &RoomId, ) -> bool

Reports whether a user may discover or inspect a room.

Current join, invite, retained left membership, or world-readable history grants access. Forgetting a room clears the retained left membership and can therefore remove this visibility.

impl Service

pub async fn user_can_peek(&self, user_id: &UserId, room_id: &RoomId) -> bool

Reports whether a user may peek into a room, as a room preview does.

A member always may, and anyone else only while the room’s history is world-readable. Unlike user_can_see_room, a pending invite or a retained left membership grants nothing here.

impl Service

pub async fn is_world_readable_at<Pdu>(&self, pdu: &Pdu) -> bool

where Pdu: Event,

Reports whether the room’s history was world-readable at an event.

A peek may show only such events, so an event without recorded state, or with missing or invalid history visibility, does not qualify. The event that makes the room world-readable counts as well, as the spec requires.

impl Service

pub async fn user_can_invite( &self, room_id: &RoomId, sender: &UserId, target_user: &UserId, state_lock: &RoomMutexGuard, ) -> bool

Probes whether a sender may invite a target user.

The normal event-build, authorization, and signing path runs under the caller’s room-state lock, but the synthetic membership event is not stored. Any build error denies the invite, while build-time ID allocations may remain.

impl Service

pub async fn user_can_tombstone( &self, room_id: &RoomId, user_id: &UserId, state_lock: &RoomMutexGuard, ) -> bool

Probes whether a user may send a room tombstone.

The user must currently be joined. The normal event-build, authorization, and signing path evaluates a synthetic tombstone without storing it; any build error denies permission, while build-time ID allocations may remain.

impl Service

pub async fn get_power_levels( &self, room_id: &RoomId, ) -> Result<RoomPowerLevels>

Returns the effective power levels for a room.

A missing or invalid m.room.power_levels event falls back to the room version’s defaults. The create event and its room-version rules are required.

pub async fn get_create(&self, room_id: &RoomId) -> Result<RoomCreateEvent<Pdu>>

Returns the room’s current create event wrapper.

The lookup uses the empty state key and returns an error when the event or its state snapshot cannot be resolved.

pub async fn get_name(&self, room_id: &RoomId) -> Result<String>

Returns the room’s current non-empty name.

Missing, invalid, and empty m.room.name content is reported as an error.

pub async fn get_avatar( &self, room_id: &RoomId, ) -> Result<RoomAvatarEventContent>

Returns the room’s current avatar content.

Missing or invalid m.room.avatar state is returned as an error.

pub async fn get_member( &self, room_id: &RoomId, user_id: &UserId, ) -> Result<RoomMemberEventContent>

Returns a user’s current membership event content in a room.

The user ID is used as the membership state key. Missing or invalid state is returned as an error.

pub async fn is_world_readable(&self, room_id: &RoomId) -> bool

Reports whether the room is world-readable.

Missing, unreadable, or invalid history-visibility state is treated as not world-readable.

pub async fn guest_can_join(&self, room_id: &RoomId) -> bool

Reports whether guest users may join the room.

Missing, unreadable, or invalid guest-access state is treated as denying guest joins.

pub async fn get_canonical_alias( &self, room_id: &RoomId, ) -> Result<OwnedRoomAliasId>

Returns the room’s current primary canonical alias.

Alternate aliases are not considered. Missing state, invalid content, or an absent primary alias is returned as an error.

pub async fn get_room_topic(&self, room_id: &RoomId) -> Result<String>

Returns the room’s current plain-text topic.

Rich-topic plain text takes precedence over the legacy field. Missing, invalid, or empty topic content is returned as an error.

pub async fn get_join_rules(&self, room_id: &RoomId) -> JoinRule

Returns the room’s current join rule.

Any missing, unreadable, or invalid join-rules state falls back to [JoinRule::Invite].

pub async fn get_room_type(&self, room_id: &RoomId) -> Result<RoomType>

Returns the room type declared by the current create event.

A missing create event, invalid content, or absent room type is returned as an error; ordinary rooms therefore do not yield a synthetic type.

pub async fn get_room_encryption( &self, room_id: &RoomId, ) -> Result<EventEncryptionAlgorithm>

Returns the room’s configured encryption algorithm.

Missing or invalid m.room.encryption state is returned as an error.

pub async fn is_encrypted_room(&self, room_id: &RoomId) -> bool

Reports whether an encryption state event is present.

This checks that the event can be loaded, but does not deserialize its content or validate an encryption algorithm.

impl Service

pub async fn is_federating(&self, room_id: &RoomId) -> bool

Checks whether the room federates, per m.federate in its create event.

An absent m.federate means the room federates, which is the spec default. A missing or unparsable create event reports the same, so a failed read never reports a room as non-federating.

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