Struct Hooks 

pub struct Hooks { /* private fields */ }

The hook registry: before / after hooks per event type, plus lifecycle hooks.

Implementations

impl Hooks

pub fn before<E, F, Fut>(&mut self, hook: F)

where E: Event, F: Fn(HookCtx, E) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Decision<E>, AppError>> + Send + 'static,

Register a before hook for events of type E.

pub fn in_tx<E, F>(&mut self, hook: F)

where E: Event, F: for<'a> Fn(&'a mut DbTx, &'a HookCtx, &'a E) -> BoxFuture<'a, Result<(), AppError>> + Send + Sync + 'static,

Register an in_tx hook for events of type E: it runs inside the module’s transaction (after the module’s own write, before the commit) and may write with the transaction or refuse (the transaction rolls back, the client gets the error). It uses only tx and may run more than once (a transaction retried after a deadlock; see the module docs).

use net_backend_server::hooks::{Event, Hooks};

struct SaveWritten { user: i64 }
impl Event for SaveWritten { const NAME: &'static str = "game.save_written"; }

let mut hooks = Hooks::default();
hooks.in_tx::<SaveWritten, _>(|tx, _ctx, event| Box::pin(async move {
    let _ = (tx, event.user); // e.g. tx.execute(&update_inventory_statement).await?;
    Ok(())
}));

pub fn after<E, F, Fut>(&mut self, hook: F)

where E: Event, F: Fn(HookCtx, Arc<E>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), AppError>> + Send + 'static,

Register an after hook for events of type E.

pub fn on_start<F, Fut>(&mut self, hook: F)

where F: Fn(HookCtx) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), AppError>> + Send + 'static,

Register a start hook (runs after every module started; an error aborts the start).

pub fn on_shutdown<F, Fut>(&mut self, hook: F)

where F: Fn(HookCtx) -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

Register a shutdown hook (runs after in-flight requests drained, before the database closes).

pub fn before_count<E: Event>(&self) -> usize

How many before hooks are registered for E.

pub fn in_tx_count<E: Event>(&self) -> usize

How many in_tx hooks are registered for E.

pub async fn run_in_tx<E: Event>( &self, tx: &mut DbTx, ctx: &HookCtx, event: &E, ) -> Result<(), AppError>

Run the in_tx hooks of E in order inside tx. The first error stops the chain and is returned (roll the transaction back); a timeout is 503 hook_timeout, a panic 500 internal.

pub fn after_count<E: Event>(&self) -> usize

How many after hooks are registered for E.

pub async fn run_before<E: Event>( &self, ctx: &HookCtx, event: E, ) -> Result<E, AppError>

Run the before hooks of E in order. Returns the (possibly modified) event, or the error to answer: a rejection, a hook’s own error, hook_timeout (503) or internal (500, after a panic).

pub async fn run_after<E: Event>(&self, ctx: &HookCtx, event: Arc<E>)

Run the after hooks of E in order. Errors, timeouts and panics are logged; every hook runs.

Trait Implementations

impl Debug for Hooks

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Hooks

fn default() -> Self

Returns the “default value” for a type.