Struct Service 

pub struct Service {
    db: Data,
    creating: Creating,
    services: Arc<OnceServices>,
}

Allocates and resolves compact identifiers used by room storage.

Per-identity locks serialize first allocation, and database transactions keep new forward and reverse mappings consistent where both are stored.

Fields

db: Data

creating: Creating

services: Arc<OnceServices>

Implementations

impl Service

pub async fn get_or_create_shorteventid( &self, event_id: &EventId, ) -> ShortEventId

Resolves an event ID to its compact identifier, allocating after an unsuccessful lookup.

New allocations publish the forward and reverse mappings in one transaction. Concurrent callers for the same event converge on one identifier.

Panics

Panics when identifier dispatch or the paired mapping transaction fails.

impl Service

pub fn multi_get_or_create_shorteventid<'a, I>( &'a self, event_ids: I, ) -> impl Stream<Item = ShortEventId> + Send + '_

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

Resolves each event ID to its short ID, allocating after unsuccessful lookups.

Allocation runs ahead of consumer demand, so a caller that stops early still allocates for the events already buffered. Today’s callers drain the stream in full.

Panics

Panics when an existing mapping is malformed, identifier dispatch fails, or a paired mapping transaction fails.

impl Service

async fn create_shorteventid(&self, event_id: &EventId) -> ShortEventId

impl Service

pub async fn get_shorteventid(&self, event_id: &EventId) -> Result<ShortEventId>

Resolves an event ID to its existing compact identifier.

Missing or malformed mappings are returned as database errors.

impl Service

pub async fn get_or_create_shortstatekey( &self, event_type: &StateEventType, state_key: &str, ) -> ShortStateKey

Resolves a state event type and key, allocating an identifier after an unsuccessful lookup.

New allocations publish the forward and reverse mappings in one transaction. Concurrent callers for the same pair converge on one identifier.

Panics

Panics when identifier dispatch or the paired mapping transaction fails.

impl Service

async fn create_shortstatekey( &self, event_type: &StateEventType, state_key: &str, ) -> ShortStateKey

impl Service

pub async fn get_shortstatekey( &self, event_type: &StateEventType, state_key: &str, ) -> Result<ShortStateKey>

Resolves a state event type and key to its existing compact identifier.

The event type and state key together form the forward lookup key. Missing or malformed mappings are returned as database errors.

impl Service

pub async fn get_eventid_from_short<Id>( &self, shorteventid: ShortEventId, ) -> Result<Id>

where Id: for<'de> Deserialize<'de> + Send + Sized + ToOwned, <Id as ToOwned>::Owned: Borrow<EventId>,

Resolves a compact event identifier through the reverse mapping.

The caller selects a deserializable event-ID representation whose owned form can be borrowed as [EventId]. Missing or malformed rows are reported with the compact identifier.

impl Service

pub fn multi_get_eventid_from_short<'a, Id, S>( &'a self, shorteventid: S, ) -> impl Stream<Item = Result<Id>> + Send + 'a

where S: Stream<Item = ShortEventId> + Send + 'a, Id: for<'de> Deserialize<'de> + Send + Sized + ToOwned + 'a, <Id as ToOwned>::Owned: Borrow<EventId>,

Resolves a stream of compact event identifiers through the reverse mapping.

Input order is preserved. Each output carries its own lookup or deserialization result.

impl Service

pub async fn get_statekey_from_short( &self, shortstatekey: ShortStateKey, ) -> Result<(StateEventType, StateKey)>

Resolves a compact state-key identifier to its event type and state key.

Missing or malformed reverse mappings are returned as database errors that identify the compact value.

impl Service

pub fn multi_get_statekey_from_short<'a, S>( &'a self, shortstatekey: S, ) -> impl Stream<Item = Result<(StateEventType, StateKey)>> + Send + 'a

where S: Stream<Item = ShortStateKey> + Send + 'a,

Resolves a stream of compact state-key identifiers through the reverse mapping.

Input order is preserved. Each output carries its own lookup or deserialization result.

impl Service

pub async fn get_or_create_shortstatehash<F>( &self, state_hash: &Digest, write_statediff: F, ) -> Result<(ShortStateHash, bool)>

where F: FnOnce(&mut Txn, ShortStateHash) -> Result,

Resolves a state hash, allocating a compact identifier after an unsuccessful lookup.

The returned boolean is true when the mapping already existed, in which case the callback is skipped. For a new identifier, write_statediff stages its associated state diff in the same transaction as the mapping.

Errors

Returns an error when write_statediff rejects the new state diff. Neither row is committed.

Panics

Panics when identifier dispatch or the mapping and state-diff transaction fails.

impl Service

async fn create_shortstatehash<F>( &self, state_hash: &Digest, write_statediff: F, ) -> Result<(ShortStateHash, bool)>

where F: FnOnce(&mut Txn, ShortStateHash) -> Result,

impl Service

pub async fn get_shortstatehash( &self, state_hash: &Digest, ) -> Result<ShortStateHash>

Resolves a state hash to its existing compact identifier.

Missing or malformed mappings are returned as database errors.

impl Service

pub async fn get_shortroomid(&self, room_id: &RoomId) -> Result<ShortRoomId>

Resolves a room ID to its existing compact identifier.

Missing or malformed mappings are returned as database errors.

impl Service

pub async fn get_roomid_from_short( &self, shortroomid_: ShortRoomId, ) -> Result<OwnedRoomId>

Resolves a compact room identifier by scanning the forward mapping.

Room identifiers have no dedicated reverse map, so the first matching value is returned. Unreadable rows are skipped during the scan.

impl Service

pub fn iter_shortroomids( &self, ) -> impl Stream<Item = (&RoomId, ShortRoomId)> + Send + '_

Streams every room ID with its compact identifier.

This scan is the only way back from a compact room identifier, so resolve several in one pass. Each borrowed ID is valid only until the next poll, and unreadable rows are skipped.

impl Service

pub async fn get_or_create_shortroomid(&self, room_id: &RoomId) -> ShortRoomId

Resolves a room ID to its compact identifier, allocating after an unsuccessful lookup.

Room mappings are stored only in the forward direction. Concurrent callers for the same room converge on one identifier.

Panics

Panics when identifier dispatch or storing the forward mapping fails.

impl Service

async fn create_shortroomid(&self, room_id: &RoomId) -> ShortRoomId

impl Service

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

Deletes the compact identifier mapping for a room.

Only the forward room mapping is removed. Any unsuccessful existence check is returned as a not-found database error.

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.