Struct Service 

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

Fields

services: Arc<OnceServices>

db: Data

Implementations

impl Service

pub fn add_relation(&self, from: PduCount, to: PduCount)

impl Service

pub async fn add_typed_relation<E: Event>( &self, shortroomid: ShortRoomId, child_count: PduCount, parent: &EventId, child: &E, rel_type: RelationType, )

Maintain the rel_type-aware relation index for an m.replace or m.reference child of parent. The row is keyed by the parent so a serve of parent seeks its newest edit (or its references) without loading non-matching children. Indexed unconditionally; only the read fold is gated.

impl Service

pub async fn event_has_relation( &self, event_id: &EventId, user_id: Option<&UserId>, rel_type: Option<&RelationType>, key: Option<&str>, ) -> bool

Query relations of an event to determine if matching any of the trailing arguments. When all criteria are None the mere presence of a relation causes this function to return true.

impl Service

pub async fn has_relation( &self, target: PduId, user_id: Option<&UserId>, rel_type: Option<&RelationType>, key: Option<&str>, ) -> bool

Query relations of an event by PduId to determine if matching any of the trailing arguments. When all criteria are None the mere presence of a relation causes this function to return true.

impl Service

pub fn get_relations<'a>( &'a self, shortroomid: ShortRoomId, target: PduCount, from: Option<PduCount>, dir: Direction, user_id: Option<&'a UserId>, ) -> impl Stream<Item = (PduCount, Pdu)> + Send + '_

impl Service

pub async fn bundle_aggregations(&self, sender_user: &UserId, pdu: Pdu) -> Pdu

Fold read-time bundled aggregations into a served event’s unsigned, per-requester. MSC3816: the stored m.thread bundle carries a shared current_user_participated, recomputed here for sender_user. MSC3925: when bundle_edit_relations is enabled, the newest m.replace edit is folded in as the full replacement event. MSC3267: when bundle_reference_relations is enabled, the m.reference children are folded in as a { chunk: [{ event_id }] } summary. The thread presence gate keeps the common no-bundle case to a substring scan; the edit and reference folds are skipped unless enabled.

impl Service

async fn newest_replacement(&self, parent: &Pdu) -> Option<Pdu>

MSC3925: the newest m.replace edit of parent as a full event, or None when parent is redacted or has no valid edit. An edit counts only when it shares the parent’s sender and type and is not itself redacted; newest is by origin_server_ts, which the typed index sorts on.

impl Service

fn replacement_children<'a>( &'a self, parent: &'a Pdu, parent_id: PduId, ) -> impl Stream<Item = Pdu> + Send + 'a

Stream parent’s valid m.replace children, newest origin_server_ts first, from the typed index. A child counts only when it shares the parent’s sender and type and is not itself redacted.

impl Service

async fn references(&self, parent: &Pdu) -> Vec<OwnedEventId>

MSC2675/MSC3267: the event ids of parent’s m.reference children, oldest first, from the typed index, capped at REFERENCE_BUNDLE_MAX. Empty when parent is redacted or unreferenced. The ids come from the index value (the child shorteventid) without loading the children, so the chunk is filtered for neither ignored users nor history visibility. The ignored-user posture matches the /relations endpoint, which also does not filter relation children by ignored sender; the history-visibility posture matches the thread and edit bundles and is less strict than /relations, which does filter children by visibility.

impl Service

fn referenced_children<'a>( &'a self, parent_id: PduId, ) -> impl Stream<Item = OwnedEventId> + Send + 'a

Stream the event ids of parent_id’s m.reference children, oldest first, from the typed index, resolving each row value (the child shorteventid) to an event id with no PDU load.

impl Service

pub fn mark_as_referenced<'a, I>(&self, room_id: &RoomId, event_ids: I)

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

impl Service

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

impl Service

pub fn mark_event_soft_failed(&self, event_id: &EventId)

impl Service

pub async fn is_event_soft_failed(&self, event_id: &EventId) -> bool

impl Service

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

impl Service

pub async fn delete_typed_relation( &self, child_id: &RawPduId, child: &CanonicalJsonObject, )

Remove the relatesto_typed row for a redacted m.replace or m.reference child. Storage hygiene for edits; correctness-critical for references, whose read emits from the index value without loading the child. Call before the child’s content is stripped, while its relation fields are still readable.

impl Service

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

impl Service

pub async fn rebuild_typed_relations(&self) -> Result

Rebuild relatesto_typed from every stored PDU. Run once at startup behind a global marker, and on demand from the admin command. Clears first so a partial or stale index is replaced wholesale.

impl Service

async fn index_pdu_relations(&self, pdu_id: RawPduId, pdu: &Pdu)

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.