Struct Service 

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

Fields

services: Arc<OnceServices>

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

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

db: Data

suppressed: SuppressedQueue

sent_badges: SentBadges

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 append_pdu_for_user(&self, user: &UserId, __arg2: Appended<'_>)

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(super) fn sent_badge(&self, user_id: &UserId, pushkey: &str) -> Option<UInt>

Return the unread total last accepted by this pusher’s gateway.

None means no delivery has been confirmed since startup, and the caller must send rather than assume agreement.

impl Service

pub(super) fn record_sent_badge( &self, user_id: &UserId, pushkey: &str, unread: UInt, )

Record the unread total a pusher’s gateway just accepted.

Call only after a successful delivery; recording an attempt would make a failed send look reconciled and suppress the retry’s refresh.

impl Service

pub(super) fn forget_sent_badge(&self, user_id: &UserId, pushkey: &str)

Forget the delivery record for one pusher.

A deleted or replaced pusher leaves the device state unknown, so the next refresh must send unconditionally.

impl Service

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

Reset the room’s main-timeline notification counts.

The last-read stamp gates sync output; callers dispatch the badge refresh after every reset.

impl Service

async fn reset_notification_count<K>( &self, room_id: &RoomId, user_id: &UserId, key: K, )

where K: Serialize + Debug + Send + Sync,

impl Service

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

Reset counts for a single thread within a room.

The last-read stamp gates sync output.

impl Service

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

Clear all per-thread notification state for this user and room.

The Interfix prefix excludes the main row. The notification-count sweep runs under the increment mutex so a concurrent read-modify-write cannot resurrect a cleared row.

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 global_notification_count(&self, user_id: &UserId) -> u64

Return the user’s account-wide unread notification count.

Joined main and thread rows contribute to a saturating total.

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

async fn handle_ok<T>( &self, dest: &str, response: Response, ) -> Result<T::IncomingResponse>

where T: OutgoingRequest,

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

pub async fn send_badge_notice( &self, user_id: &UserId, pusher: &Pusher, ) -> Result

Send an account-wide counts-only notification to a push gateway.

Enabled HTTP pushers emit the request, including an explicit zero. The delivery is skipped only when the gateway is known to hold the current total already; an unknown gateway is always sent to.

impl Service

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

impl Service

async fn send_http_event_notice<Pdu: Event>( &self, user_id: &UserId, pusher: &Pusher, http: &HttpPusherData, tweaks: Vec<Tweak>, event: &Pdu, ) -> Result

impl Service

fn prepare_http_pusher( &self, pusher: &Pusher, http: &HttpPusherData, ) -> Result<Device>

impl Service

async fn send_http_notice( &self, user_id: &UserId, pusher: &Pusher, http: &HttpPusherData, notify: Notification, unread: Option<UInt>, ) -> Result

Deliver one notification to the pusher’s gateway and honor its verdict.

A pushkey the gateway names in rejected has its pusher removed. unread names the counts value on the wire; it is recorded as delivered only after the gateway accepts, so a failed or rejected send leaves the next refresh unconditional.

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

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

impl Service

fn set_pusher_post( &self, sender: &UserId, sender_device: &DeviceId, action: &PusherAction, pusher: &Pusher, ) -> Result

impl Service

fn check_http_pusher_url(&self, url: &Url) -> 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, __arg1: Evaluate<'a, '_>) -> &'a [Action]

impl Service

pub async fn related_events<E: Event>( &self, event: &E, ) -> Option<Arc<BTreeMap<String, FlattenedJson>>>

Resolve the events an event relates to, for the MSC3664 push condition.

None while msc3664_related_event_match is disabled, which leaves every MSC3664 condition unable to match. The relations do not vary by recipient, so the append path resolves them once for the whole room; the push-notice path resolves them per notice, since it holds one event at a time.

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.