Struct Service 

pub struct Service {
    server: Arc<Server>,
    account: Mutex<Table>,
    failed: Mutex<Table>,
}

Per-account login throttles.

The tables live here rather than on crate::users::Service so that the interior mutability they need stays out of a type whose &self methods are linted as taking nothing mutable.

Fields

server: Arc<Server>

account: Mutex<Table>

failed: Mutex<Table>

Implementations

impl Service

pub fn reserve_login_attempt(&self, user_id: &UserId) -> Result<Reservation>

Reserve one failed-attempt token for a password about to be checked.

The debit is atomic, so concurrent guesses cannot all pass on one remaining token, and an account with none left is refused with M_LIMIT_EXCEEDED. Only a wrong password keeps the reservation: every other outcome hands it back through record_login or refund_login_attempt.

impl Service

pub fn record_login(&self, reservation: Reservation) -> Result

Record a sign-in by a verified password.

The reservation is handed back first, because the password was right whatever the account bucket decides. The account bucket is then debited, refusing with M_LIMIT_EXCEEDED an account that has signed in too often.

impl Service

pub fn refund_login_attempt(&self, reservation: Reservation) -> Result

Hand back a reservation whose attempt found no wrong password.

That covers a password re-entered for UIAA, which opens no session, and every refusal made without checking a password at all.

impl Service

fn failed_limit(&self) -> Limit

impl Service

fn account_limit(&self) -> Limit

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.