Struct Service 

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

Manages configured and database-backed registration tokens.

Configured tokens are read from the active configuration and optional token file on demand. Database tokens retain use counts and expiration limits in persistent storage.

Fields

db: Data

services: Arc<OnceServices>

Implementations

impl Service

pub async fn create_token( &self, token: Option<&str>, length: Option<usize>, expires: TokenExpires, ) -> Result<(String, DatabaseTokenInfo)>

Creates a database-backed registration token.

A supplied token is stored verbatim; otherwise a random token of length characters is generated, defaulting to the service length. Existing database tokens are rejected.

pub async fn get_token_info(&self, token: &str) -> Result<TokenInfo>

Returns a token’s origin and stored metadata.

Configured tokens return TokenInfo::Config. Database metadata is returned without a validity check, while unknown tokens produce a not-found request error.

pub async fn update_token( &self, token: &str, expires: TokenExpires, ) -> Result<DatabaseTokenInfo>

Replaces a database token’s expiration policy.

The existing use counter is preserved. Configured tokens cannot be updated, and unknown database tokens produce a not-found request error.

pub async fn is_enabled(&self) -> bool

Reports whether at least one valid registration token is available.

The check stops at the first configured or valid stored token. Invalid database entries encountered before that result are removed as the stream advances.

pub async fn get_config_tokens(&self) -> HashSet<String>

Loads every registration token supplied by configuration.

Whitespace-delimited tokens are read from the optional token file and combined with the inline token. Failure to read the file is logged and leaves only other configured tokens.

pub async fn is_token_valid(&self, token: &str) -> Result

Validates a registration token without consuming a use.

Configuration tokens are always valid. Invalid database tokens are removed and reported as a forbidden request.

pub async fn try_consume(&self, token: &str) -> Result

Validates a registration token and consumes one permitted use.

Configuration tokens are accepted without mutation. A database token is removed when its updated count reaches the stored threshold. Concurrent consumers are not serialized and can share a prior count. Invalid tokens are reported as forbidden.

async fn check(&self, token: &str, consume: bool) -> Result

pub async fn revoke_token(&self, token: &str) -> Result

Revokes a database-backed registration token.

Configuration tokens cannot be revoked through this service. An unknown database token produces a not-found request error.

pub async fn iterate_tokens(&self) -> impl Stream<Item = ValidToken> + Send + '_

Streams every currently valid registration token.

Configuration tokens are yielded first, followed by valid database tokens. Invalid stored tokens are removed while the database stream is consumed.

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.