Struct Service 

pub struct Service {
    services: Arc<OnceServices>,
    notification_increment_mutex: MutexMap<(OwnedRoomId, OwnedUserId), ()>,
    highlight_increment_mutex: MutexMap<(OwnedRoomId, OwnedUserId), ()>,
    db: Data,
    suppressed: SuppressedQueue,
}

Fields

services: Arc<OnceServices>

notification_increment_mutex: MutexMap<(OwnedRoomId, OwnedUserId), ()>

highlight_increment_mutex: MutexMap<(OwnedRoomId, OwnedUserId), ()>

db: Data

suppressed: SuppressedQueue

Implementations

impl Service

pub(crate) async fn append_pdu(&self, pdu_id: RawPduId, pdu: &Pdu) -> Result

Called by timeline append_pdu.

impl Service

async fn increment_notificationcount(&self, room_id: &RoomId, user_id: &UserId)

impl Service

async fn increment_highlightcount(&self, room_id: &RoomId, user_id: &UserId)

impl Service

async fn increment_thread_notificationcount( &self, room_id: &RoomId, user_id: &UserId, thread_root: &EventId, )

impl Service

async fn increment_thread_highlightcount( &self, room_id: &RoomId, user_id: &UserId, thread_root: &EventId, )

impl Service

pub fn reset_notification_counts(&self, user_id: &UserId, room_id: &RoomId)

impl Service

pub fn reset_thread_notification_counts( &self, user_id: &UserId, room_id: &RoomId, thread_root: &EventId, )

Reset counts for a single thread within a room. Per-thread rows live in the same CFs as the main (user, room) rows; the trailing event id keeps them disjoint. Stamps a per-thread last-read so sync v3 can gate emission of unread_thread_notifications to threads that advanced within the window.

impl Service

pub async fn clear_all_thread_notification_counts( &self, user_id: &UserId, room_id: &RoomId, )

Clear every per-thread notification, highlight, and last-read row for this user and room. The Interfix prefix forces a trailing separator into the scan key, so the legacy 2-tuple main row (which has no trailing separator) is excluded by construction; only 3-tuple thread rows match. Sweeps run sequentially: parallelizing them via join triggers a for<'a> FnMut(&[u8]) Send-not-general-enough cascade through the route handler. Per-thread last-reads use the inverse (room, user, ...) order to mirror the existing sync watch prefix.

impl Service

pub async fn reset_notification_counts_for_thread( &self, user_id: &UserId, room_id: &RoomId, thread: &ReceiptThread, )

Dispatcher: route a receipt’s ReceiptThread to the matching reset path. Unthreaded clears all room and thread counts; Main clears only the main-timeline counts; Thread(id) clears just that thread.

impl Service

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

impl Service

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

impl Service

pub async fn thread_notification_counts( &self, user_id: &UserId, room_id: &RoomId, ) -> BTreeMap<OwnedEventId, (u64, u64)>

Per-thread (notification, highlight) counts for one room and user. Interfix excludes the legacy 2-tuple main row from the scan; only 3-tuple (user, room, root) rows match.

impl Service

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

impl Service

pub async fn thread_last_notification_reads( &self, user_id: &UserId, room_id: &RoomId, ) -> BTreeMap<OwnedEventId, u64>

Per-thread last-read counts for one room and user. Interfix keeps the scan to 3-tuple (room, user, root) rows; the legacy 2-tuple main row is excluded by construction and lives behind last_notification_read.

impl Service

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

impl Service

pub(super) async fn send_request<T>( &self, dest: &str, request: T, ) -> Result<T::IncomingResponse>

where T: OutgoingRequest + Debug + Send, for<'a> T::Authentication: AuthScheme<Input<'a> = ()>, for<'a> T::PathBuilder: PathBuilder<Input<'a> = ()>,

impl Service

pub async fn send_push_notice<E>( &self, user_id: &UserId, pusher: &Pusher, ruleset: &Ruleset, event: &E, ) -> Result

where E: Event,

impl Service

async fn send_notice<Pdu: Event>( &self, unread: UInt, pusher: &Pusher, tweaks: Vec<Tweak>, event: &Pdu, ) -> Result

impl Service

pub fn queue_suppressed_push( &self, user_id: &UserId, pushkey: &str, room_id: &RoomId, pdu_id: RawPduId, ) -> bool

Enqueue a PDU for later push delivery when suppression is active.

impl Service

pub fn take_suppressed_for_pushkey( &self, user_id: &UserId, pushkey: &str, ) -> Vec<(OwnedRoomId, Vec<RawPduId>)>

Take and remove all suppressed PDUs for a given user + pushkey.

impl Service

pub fn take_suppressed_for_user( &self, user_id: &UserId, ) -> Vec<(String, Vec<(OwnedRoomId, Vec<RawPduId>)>)>

Take and remove all suppressed PDUs for a given user across all pushkeys.

impl Service

pub fn clear_suppressed_room(&self, user_id: &UserId, room_id: &RoomId) -> usize

Clear suppressed PDUs for a specific room (across all pushkeys).

impl Service

pub fn clear_suppressed_pushkey(&self, user_id: &UserId, pushkey: &str) -> usize

Clear suppressed PDUs for a specific pushkey.

impl Service

pub async fn set_pusher( &self, sender: &UserId, sender_device: &DeviceId, pusher: &PusherAction, ) -> Result

impl Service

pub async fn delete_pusher(&self, sender: &UserId, pushkey: &str)

impl Service

pub async fn get_device_pushkeys( &self, sender: &UserId, device_id: &DeviceId, ) -> Vec<String>

impl Service

pub async fn get_pusher_device(&self, pushkey: &str) -> Result<OwnedDeviceId>

impl Service

pub async fn get_pusher(&self, sender: &UserId, pushkey: &str) -> Result<Pusher>

impl Service

pub async fn get_pushers(&self, sender: &UserId) -> Vec<Pusher>

impl Service

pub fn get_pushkeys<'a>( &'a self, sender: &'a UserId, ) -> impl Stream<Item = &str> + Send + 'a

impl Service

pub fn get_notifications<'a>( &'a self, sender: &'a UserId, from: Option<u64>, ) -> impl Stream<Item = (u64, Notified)> + Send + 'a

impl Service

pub async fn get_actions<'a>( &self, user: &UserId, ruleset: &'a Ruleset, power_levels: Option<&RoomPowerLevels>, pdu: &Raw<AnySyncTimelineEvent>, room_id: &RoomId, ) -> &'a [Action]

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.