Struct Service 

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

Fields

services: Arc<OnceServices>

db: Data

Implementations

impl Service

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

Replaces the previous read receipt when the incoming one advances.

Returns whether the receipt was stored. A re-posted marker allocates no stream position, so appservice and federation delivery are both skipped.

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

Gets every stored private read receipt for (room, user). Returns one ephemeral event per stored row (legacy unthreaded plus per-thread rows). An empty result means no marker is set.

pub async fn private_read_get_fallible( &self, room_id: &RoomId, user_id: &UserId, update: u64, ) -> Result<PrivateReadEvents>

Gets the complete announced private read snapshot for update without suppressing malformed rows.

A snapshot older than the gate predates this durable mirror, so those rows fall back to the tolerant active-state read they always published rather than withholding the whole room after an upgrade. A newer snapshot means a concurrent announce; that fails the bounded room range so its cursor remains pinned. A marker naming an event that no longer resolves is skipped rather than failing the range, which would otherwise repeat on every request and withhold the room indefinitely.

async fn build_private_read_event_skippable( &self, shortroomid: u64, count: u64, ts: Option<u64>, user_id: &UserId, thread_kind: &str, ) -> Result<Option<Raw<AnySyncEphemeralRoomEvent>>>

Builds one announced private read row, skipping a marker whose event no longer resolves.

The absent case returns Ok(None) so the bounded range assembles without it. Decode failures and invalid timestamps still fail the range as real inconsistencies.

async fn build_private_read_event( &self, shortroomid: u64, count: u64, ts: Option<u64>, user_id: &UserId, thread_kind: &str, ) -> Option<Raw<AnySyncEphemeralRoomEvent>>

async fn build_private_read_event_fallible( &self, shortroomid: u64, count: u64, ts: Option<u64>, user_id: &UserId, thread_kind: &str, ) -> Result<Raw<AnySyncEphemeralRoomEvent>>

async fn build_private_read_event_from( &self, shortroomid: u64, count: u64, ts: Option<MilliSecondsSinceUnixEpoch>, user_id: &UserId, thread: ReceiptThread, ) -> Result<Raw<AnySyncEphemeralRoomEvent>>

pub fn readreceipts_since<'a>( &'a self, room_id: &'a RoomId, since: u64, to: Option<u64>, ) -> impl Stream<Item = (&'_ UserId, u64, Raw<AnySyncEphemeralRoomEvent>)> + Send + 'a

Returns an iterator over the most recent read_receipts in a room that happened after the event with id since.

pub fn readreceipts_since_fallible<'a>( &'a self, room_id: &'a RoomId, since: u64, to: Option<u64>, ) -> impl Stream<Item = Result<(&'_ UserId, u64, Raw<AnySyncEphemeralRoomEvent>)>> + Send + 'a

Returns read receipts in a bounded room range without suppressing failures.

The lower bound is exclusive and the optional upper bound is inclusive. Cursor, decode, and serialization failures remain in the stream for an atomic caller to handle.

pub async fn private_read_set(&self, private_read: PrivateRead<'_>) -> bool

Sets a private read marker at PDU count for the given thread.

Unthreaded writes supersede prior per-thread rows so the room-wide receipt subsumes thread state. Returns whether the marker advanced; a position at or behind the stored one writes nothing.

pub async fn private_read_get_count( &self, room_id: &RoomId, user_id: &UserId, ) -> Result<(u64, Option<u64>)>

Returns the private read marker PDU count.

pub async fn private_read_sync_get_count( &self, room_id: &RoomId, user_id: &UserId, ) -> Result<(u64, Option<u64>)>

Returns the announced unthreaded private read marker PDU count.

pub async fn last_privateread_update( &self, user_id: &UserId, room_id: &RoomId, ) -> u64

Returns the PDU count of the last private read update in this room.

Missing or unreadable update rows return zero for legacy callers. Bounded sync callers use the fallible variant below so failures retain the room cursor.

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

Returns the bounded-sync token for the last private read update.

A missing token is returned as zero. Database and decode failures are preserved so a caller can retain its room cursor and retry the complete range.

pub async fn delete_all_read_receipts(&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 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.