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, )

Replaces the previous read receipt.

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.

async fn build_private_read_event( &self, shortroomid: u64, count: u64, user_id: &UserId, thread_kind: &str, ) -> Option<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 async fn private_read_set( &self, room_id: &RoomId, user_id: &UserId, count: u64, thread: &ReceiptThread, )

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.

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

Returns the 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 typing update in this room.

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

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.