Struct Service 

pub struct Service {
    pub db: Data,
    server: Arc<Server>,
    pub server_user: OwnedUserId,
}

Provides process-wide server identity, secrets, and monotonic sequence numbers.

Sequence numbers are persisted when dispatched and become readable only after their permits retire. The service also centralizes locality checks against the configured server name.

Fields

db: Data

Persistent global counter and database version storage.

server: Arc<Server>

server_user: OwnedUserId

Local user ID reserved for homeserver administration.

Implementations

impl Service

pub async fn wait_pending(&self) -> Result<u64>

Waits until every sequence number dispatched at call time has retired.

The dispatched frontier is snapshotted before waiting. The returned value is the retirement frontier that reached the sampled value.

pub async fn wait_count(&self, count: &u64) -> Result<u64>

Waits for the retirement frontier to reach a sequence number.

Completion means all writes through count are globally visible to readers. The returned value may be greater when later writes retired while waiting.

pub fn next_count(&self) -> Permit<Box<dyn Fn(u64) -> Result + Send + Sync>>

Dispatches the next persistent sequence number.

The returned permit dereferences to the allocated number. Dropping it retires the associated write and may advance the reader-visible frontier.

Panics

Panics when the counter is exhausted or the dispatched value cannot be recorded.

pub fn current_count(&self) -> u64

Returns the highest sequence number whose writes have retired.

Readers can safely use this value as an upper bound for globally visible writes.

pub fn pending_count(&self) -> Range<u64>

Returns a snapshot of the retired and dispatched counter frontiers.

The range start is the highest reader-visible number and the range end is the latest number dispatched to a writer.

pub fn server_name(&self) -> &ServerName

Returns the configured local server name.

The returned name is borrowed from the server-wide configuration.

pub fn user_is_local(&self, user_id: &UserId) -> bool

Reports whether a user ID belongs to the local server.

Locality is determined solely by comparing the ID’s server name with Self::server_name.

pub fn alias_is_local(&self, alias: &RoomAliasId) -> bool

Reports whether a room alias belongs to the local server.

Locality is determined solely by comparing the alias server name with Self::server_name.

pub fn server_is_ours(&self, server_name: &ServerName) -> bool

Reports whether a server name identifies this homeserver.

The comparison uses the configured local server name without resolving aliases or delegated hosting.

pub fn is_read_only(&self) -> bool

Reports whether the database is open in read-only mode.

The value is delegated to the active database engine.

pub fn turn_secret(&self) -> Option<Secret>

Resolves the secret used to authenticate TURN credentials.

The configured secret file is read and trimmed on every call, allowing rotation without a restart. A successfully read file, including an empty file, takes precedence; read failures fall back to the inline secret.

pub fn init_rustls_provider(&self) -> Result

Installs the default rustls cryptography provider when none exists.

Existing process-wide providers are preserved. A failure to install the AWS-LC provider is returned to the caller.

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.