Struct KeepAlive 

pub struct KeepAlive<F, E>
where
    F: Fn() -> E + Clone,
{ /* private fields */ }

Middleware that fails readiness once the service has been idle too long.

Every call records the current time and passes the request through unchanged. When no call has been made for the keep-alive duration, ready fails with the error produced by f.

Implementations

impl<F, E> KeepAlive<F, E>

where F: Fn() -> E + Clone,

pub fn new(ka: Millis, f: F) -> KeepAlive<F, E>

Creates keep-alive middleware.

ka is the maximum idle time between calls, and f creates the error returned once it is exceeded.

Trait Implementations

impl<F, E> Clone for KeepAlive<F, E>

where F: Fn() -> E + Clone,

fn clone(&self) -> KeepAlive<F, E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F, E> Debug for KeepAlive<F, E>

where F: Fn() -> E + Clone,

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

Formats the value using the given formatter.

impl<F, E, St, Req> ServiceFactory<St, Req> for KeepAlive<F, E>

where F: Fn() -> E + Clone,

type Res = Req

Response produced by the created services.

type Error = E

Error produced by the created services.

type Service = KeepAliveService<F, E>

The type of Service produced by this factory.

type InitError = Infallible

Error that can occur while constructing a service.

async fn create( &self, _: &St, ) -> Result<<KeepAlive<F, E> as ServiceFactory<St, Req>>::Service, <KeepAlive<F, E> as ServiceFactory<St, Req>>::InitError>

Asynchronously creates a service using the supplied state.

async fn pipeline( &self, st: St, ) -> Result<Pipeline<Req, Self::Res, Self::Error>, Self::InitError>

where Self: 'static, St: 'static, Req: 'static,

Creates a service and wraps it with its state in a Pipeline.

fn map<F, Res>( self, f: F, ) -> ServiceChainFactory<MapFactory<F, Self, Res>, St, Req>

where Self: Sized, F: Fn(Self::Res) -> Res + Clone,

Returns a factory whose services map responses to a different type.

fn map_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapErrFactory<F, Self, E>, St, Req>

where Self: Sized, F: Fn(Self::Error) -> E + Clone,

Returns a factory whose services map errors to a different type.

fn map_init_err<F, E>( self, f: F, ) -> ServiceChainFactory<MapInitErr<F, Self, E>, St, Req>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Maps this factory’s initialization error to a different error, returning a new service factory.

fn and_then<U, F>( self, f: F, ) -> ServiceChainFactory<AndThenFactory<Self, U>, St, Req>

where Self: Sized, U: ServiceFactory<St, Self::Res, Error = Self::Error, InitError = Self::InitError>, F: IntoServiceFactory<U, St, Self::Res>,

Chains another factory after this factory’s services.

fn boxed( self, ) -> BoxServiceFactory<St, Req, Self::Res, Self::Error, Self::InitError>

where St: 'static, Req: 'static, Self: Sized + 'static,

Creates a boxed service factory.