Struct Service 

pub struct Service {
    timer_channel: (Sender<(OwnedUserId, Duration, u64)>, Receiver<(OwnedUserId, Duration, u64)>),
    timeout_remote_users: bool,
    idle_timeout: u64,
    offline_timeout: u64,
    db: Data,
    services: Arc<OnceServices>,
    last_sync_seen: RwLock<HashMap<OwnedUserId, u64>>,
    device_presence: PresenceAggregator,
}

Fields

timer_channel: (Sender<(OwnedUserId, Duration, u64)>, Receiver<(OwnedUserId, Duration, u64)>)

timeout_remote_users: bool

idle_timeout: u64

offline_timeout: u64

db: Data

services: Arc<OnceServices>

last_sync_seen: RwLock<HashMap<OwnedUserId, u64>>

device_presence: PresenceAggregator

Implementations

impl Service

fn device_key(device_id: Option<&DeviceId>, is_remote: bool) -> DeviceKey

fn schedule_presence_timer( &self, user_id: &UserId, presence_state: &PresenceState, count: u64, ) -> Result

fn refresh_skip_decision( refresh_window_ms: Option<u64>, last_event: Option<&PresenceEvent>, last_count: Option<u64>, ) -> Option<(u64, u64)>

fn timer_is_stale(expected_count: u64, current_count: u64) -> bool

async fn apply_device_presence_update( &self, user_id: &UserId, device_key: DeviceKey, state: &PresenceState, currently_active: Option<bool>, last_active_ago: Option<UInt>, status_msg: StatusMsg, refresh_window_ms: Option<u64>, ) -> Result

pub async fn maybe_ping_presence( &self, user_id: &UserId, device_id: Option<&DeviceId>, client_ip: Option<IpAddr>, new_state: &PresenceState, ) -> Result

Pings the presence of the given user, setting the specified state. When device_id is supplied.

pub async fn set_presence_for_device( &self, user_id: &UserId, device_id: Option<&DeviceId>, state: &PresenceState, status_msg: Option<String>, ) -> Result

Applies an explicit presence update for a local device.

pub async fn set_presence_from_federation( &self, user_id: &UserId, state: &PresenceState, currently_active: bool, last_active_ago: UInt, status_msg: Option<String>, ) -> Result

Applies a presence update received over federation.

pub async fn set_presence( &self, user_id: &UserId, state: &PresenceState, currently_active: Option<bool>, last_active_ago: Option<UInt>, status_msg: Option<String>, ) -> Result

Adds a presence event which will be saved until a new event replaces it.

pub(super) async fn process_presence_timer( &self, user_id: &OwnedUserId, expected_count: u64, ) -> Result

impl Service

pub async fn note_sync(&self, user_id: &UserId)

record that a user has just successfully completed a /sync (or equivalent activity)

pub async fn last_sync_gap_ms(&self, user_id: &UserId) -> Option<u64>

Returns milliseconds since last observed sync for user (if any)

pub async fn get_presence(&self, user_id: &UserId) -> Result<PresenceEvent>

Returns the latest presence event for the given user.

pub async fn remove_presence(&self, user_id: &UserId)

Removes the presence record for the given user from the database.

TODO: Why is this not used?

async fn unset_all_presence(&self)

pub fn presence_since( &self, since: u64, to: Option<u64>, ) -> impl Stream<Item = (&UserId, u64, &[u8])> + Send + '_

Returns the most recent presence updates that happened after the event with id since.

pub async fn from_json_bytes_to_event( &self, bytes: &[u8], user_id: &UserId, ) -> Result<PresenceEvent>

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 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 name(&self) -> &str

Return the name of the service. i.e. crate::service::make_name(std::module_path!())

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.