Struct Service 

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

Fields

db: Data

services: Arc<OnceServices>

Implementations

impl Service

pub async fn get_thread_id<E>(&self, event: &E) -> Option<OwnedEventId>

where E: Event,

Resolves the thread root for event by walking up m.relates_to links, bounded at MAX_THREAD_HOPS. Returns None for events that belong to the main timeline.

pub async fn get_thread_id_for_event( &self, event_id: &EventId, ) -> Option<OwnedEventId>

get_thread_id for an event referenced by id; events missing locally resolve to None (the main timeline).

pub async fn add_to_thread<E>( &self, root_event_id: &EventId, event: &E, ) -> Result

where E: Event,

pub fn threads_until<'a>( &'a self, user_id: &'a UserId, room_id: &'a RoomId, count: PduCount, _inc: &'a IncludeThreads, ) -> impl Stream<Item = Result<(PduCount, PduEvent)>> + Send

pub(super) fn update_participants( &self, root_id: &RawPduId, participants: &[OwnedUserId], ) -> Result

pub(super) async fn get_participants( &self, root_id: &RawPduId, ) -> Result<Vec<OwnedUserId>>

pub(super) async fn delete_all_rooms_threads(&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.