Struct axum_starter::ServerPrepare

pub struct ServerPrepare<C, Effect, Log = LogInit, State = StateNotReady, Graceful = NoGraceful, Decorator = EmptyDecorator> { /* private fields */ }

type for prepare starting

Implementations

impl<C: 'static, Log, State, Graceful, R: 'static, L: 'static, Decorator> ServerPrepare<C, Result<EffectContainer<R, L>, PrepareError>, Log, State, Graceful, Decorator>

where Decorator: PrepareDecorator,

pub fn layer<M: 'static>( self, middleware: M ) -> ServerPrepare<C, Result<EffectContainer<R, Stack<M, L>>, PrepareError>, Log, State, Graceful, Decorator>

adding middleware without previously Prepare action

impl<C: 'static, Log, State, Graceful, Ri: 'static, Li: 'static, Decorator> ServerPrepare<C, Result<EffectContainer<Ri, Li>, PrepareError>, Log, State, Graceful, Decorator>

where Decorator: PrepareDecorator,

pub fn prepare_concurrent<F>( self, concurrent: F ) -> ServerPrepare<C, Result<EffectContainer<Ri, Li>, PrepareError>, Log, State, Graceful, Decorator>

where F: FnOnce(ConcurrentPrepareSet<'_, C, Decorator>) -> ConcurrentPrepareSet<'_, C, Decorator> + 'static,

adding a set of Prepare executing concurrently

Note

Prepare set added by different Self::prepare_concurrent will be executed serially

pub fn prepare_route<P, S>( self, prepare: P ) -> ServerPrepare<C, Result<EffectContainer<(<P as Prepare<C>>::Effect, Ri), Li>, PrepareError>, Log, State, Graceful, Decorator>

where P: Prepare<C> + 'static, P::Effect: PrepareRouteEffect<S>, Ri: PrepareRouteEffect<S>, S: Clone + Send + 'static + Sync,

adding a Prepare apply effect on Router

Note

the Prepare task will be executed one by one.

DO NOT block any task for a long time, neither sync nor async

pub fn prepare_state<P>( self, prepare: P ) -> ServerPrepare<C, Result<EffectContainer<Ri, Li>, PrepareError>, Log, State, Graceful, Decorator>

where P: Prepare<C> + 'static, P::Effect: PrepareStateEffect,

adding a Prepare adding effect on State

Note

the Prepare task will be executed one by one.

DO NOT block any task for a long time, neither sync nor async

pub fn prepare_middleware<S, P>( self, prepare: P ) -> ServerPrepare<C, Result<EffectContainer<Ri, Stack<<<P as Prepare<C>>::Effect as PrepareMiddlewareEffect<S>>::Middleware, Li>>, PrepareError>, Log, State, Graceful, Decorator>

where S: 'static, P: Prepare<C> + 'static, P::Effect: PrepareMiddlewareEffect<S>,

adding a Prepare apply effect on State and Middleware

Note

the Prepare task will be executed one by one.

DO NOT block any task for a long time, neither sync nor async

pub fn prepare<P>( self, prepare: P ) -> ServerPrepare<C, Result<EffectContainer<Ri, Li>, PrepareError>, Log, State, Graceful, Decorator>

where P: Prepare<C, Effect = ()> + 'static,

adding a Prepare without effect

impl<C, FutEffect, Log, State, Decorator> ServerPrepare<C, FutEffect, Log, State, NoGraceful, Decorator>

pub fn graceful_shutdown<Fut>( self, future: Fut ) -> ServerPrepare<C, FutEffect, Log, State, Graceful<Fut>, Decorator>

where Fut: Future<Output = ()>,

set the graceful shutdown signal

impl<C, FutEffect, Log, Graceful, Decorator> ServerPrepare<C, FutEffect, Log, StateNotReady, Graceful, Decorator>

pub fn convert_state<S: FromStateCollector>( self ) -> ServerPrepare<C, FutEffect, Log, StateReady<S>, Graceful, Decorator>

convert internal StateCollector to special State

pub fn no_state( self ) -> ServerPrepare<C, FutEffect, Log, StateReady<()>, Graceful, Decorator>

convenient function for ServerPrepare::convert_state::<()>

impl<C, Effect, Log, State, Graceful, Decorator> ServerPrepare<C, Effect, Log, State, Graceful, Decorator>

pub fn set_decorator<D>( self, decorator: D ) -> ServerPrepare<C, Effect, Log, State, Graceful, D>

where D: PrepareDecorator,

Add Decorator apply on every prepare Future

This PrepareDecorator result will affect all following prepares

this will overwrite old PrepareDecorator, combine multiply PrepareDecorator is Not support. Manual writing combining code instead

see also prepare_decorator

pub fn prepare_decorator<D, P>( self, prepare: P ) -> ServerPrepare<C, Effect, Log, State, Graceful, D>

where P: Prepare<C, Effect = D, Error = Infallible, Future = Ready<Result<D, Infallible>>>, C: 'static, D: PrepareDecorator,

Add Decorator generated by a Prepare task,

NOTE

the Prepare task must be a sync task, in another word, the Prepare::Future should to be Ready

This PrepareDecorator result will affect all following prepares

If you using prepare, you can mark the Prepare task as sync.

use axum_starter::prepare;

// using `sync` make macro generate prepare return Ready
#[prepare(sync Decorator)]
fn foo_decorator(foo:i32)->FooDecorator{
    FooDecorator(foo)
}

struct FooDecorator(i32);

If your [Decorator] do not need any information from the C, you’d better using set_decorator

impl<C, Effect, Log, State, Graceful, Decorator> ServerPrepare<C, Effect, Log, StateReady<State>, Graceful, Decorator>

pub fn post_prepare<Args, T>(self, post_prepare: T) -> Self

where T: PostPrepare<State, Args> + Send + 'static, State: Send + 'static + Sync, Args: Send + 'static,

execute a task after all prepare task done before service start

the task can be a FnOnce which has the following features

1. the arg list all impl Arg: From
2. is an Async Function
3. the function return ()

Note

those tasks will run in a spawn tokio task, do not assume the service has been started

impl<C, FutEffect, State, Graceful, Decorator> ServerPrepare<C, FutEffect, NoLog, State, Graceful, Decorator>

where C: LoggerInitialization,

pub fn init_logger( self ) -> Result<ServerPrepare<C, FutEffect, LogInit, State, Graceful, Decorator>, <C as LoggerInitialization>::Error>

init the (logger) of this ServerPrepare ,require C impl LoggerInitialization

impl<C: 'static> ServerPrepare<C, Result<EffectContainer<(), Identity>, PrepareError>, NoLog, StateNotReady, NoGraceful, EmptyDecorator>

pub fn with_config(config: C) -> Self

prepare staring the service with config

impl<C: 'static, Log, State, Graceful, R, L, Decorator> ServerPrepare<C, Result<EffectContainer<R, L>, PrepareError>, Log, StateReady<State>, Graceful, Decorator>

pub async fn preparing<NewResBody>( self ) -> Result<ServerReady<impl Future<Output = Result<(), Error>>, impl Future<Output = Result<(), Error>>>, PrepareStartError>

where C: BindServe, L: Send + 'static, ServiceBuilder<L>: Layer<Route> + Clone, <ServiceBuilder<L> as Layer<Route>>::Service: Send + Clone + Service<Request<Body>, Response = Response<NewResBody>, Error = Infallible> + 'static, <<ServiceBuilder<L> as Layer<Route>>::Service as Service<Request<Body>>>::Future: Send, NewResBody: Body<Data = Bytes> + Send + 'static, NewResBody::Error: Into<BoxError>, R: PrepareRouteEffect<State>, State: FromStateCollector + Clone + Send + 'static + Sync, Graceful: FetchGraceful,

prepare to start this server

this will consume Self then return ServerReady