Struct H1Service 

pub struct H1Service<F, S, B, C> { /* private fields */ }

ServiceFactory implementation for HTTP1 transport

Implementations

impl<F, S, B, C> H1Service<Layer<SslFilter, F>, S, B, C>

where F: Filter, S: ServiceFactory<Request, SharedCfg> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, C: ServiceFactory<Control<Layer<SslFilter, F>, S::Error>, SharedCfg, Response = ControlAck<Layer<SslFilter, F>>> + 'static, C::Error: Error, C::InitError: Debug,

pub fn openssl( self, acceptor: SslAcceptor, ) -> impl ServiceFactory<Io<F>, SharedCfg, Response = (), Error = SslError<DispatchError>, InitError = ()>

Create openssl based service

impl<F, S, B, C> H1Service<Layer<TlsServerFilter, F>, S, B, C>

where F: Filter, S: ServiceFactory<Request, SharedCfg> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, C: ServiceFactory<Control<Layer<TlsServerFilter, F>, S::Error>, SharedCfg, Response = ControlAck<Layer<TlsServerFilter, F>>> + 'static, C::Error: Error, C::InitError: Debug,

pub fn rustls( self, config: ServerConfig, ) -> impl ServiceFactory<Io<F>, SharedCfg, Response = (), Error = SslError<DispatchError>, InitError = ()>

Create rustls based service

impl<F, S, B, C> H1Service<F, S, B, C>

where F: Filter, S: ServiceFactory<Request, SharedCfg>, S::Error: ResponseError, S::Response: Into<Response<B>>, S::InitError: Debug, B: MessageBody, C: ServiceFactory<Control<F, S::Error>, SharedCfg, Response = ControlAck<F>>, C::Error: Error, C::InitError: Debug,

pub fn control<C1, U>(self, ctl: U) -> H1Service<F, S, B, C1>

where U: IntoServiceFactory<C1, Control<F, S::Error>, SharedCfg>, C1: ServiceFactory<Control<F, S::Error>, SharedCfg, Response = ControlAck<F>>, C1::Error: Error, C1::InitError: Debug,

Provide http/1 control service

Trait Implementations

impl<F, S, B, C> ServiceFactory<Io<F>, SharedCfg> for H1Service<F, S, B, C>

where F: Filter, S: ServiceFactory<Request, SharedCfg> + 'static, S::Error: ResponseError, S::Response: Into<Response<B>>, S::InitError: Debug, B: MessageBody, C: ServiceFactory<Control<F, S::Error>, SharedCfg, Response = ControlAck<F>> + 'static, C::Error: Error, C::InitError: Debug,

type Response = ()

Responses given by the created services.

type Error = DispatchError

Errors produced by the created services.

type InitError = ()

Errors potentially raised while building a service.

type Service = H1ServiceHandler<F, <S as ServiceFactory<Request, SharedCfg>>::Service, B, <C as ServiceFactory<Control<F, <S as ServiceFactory<Request, SharedCfg>>::Error>, SharedCfg>>::Service>

The kind of Service created by this factory.

async fn create(&self, cfg: SharedCfg) -> Result<Self::Service, Self::InitError>

Create and return a new service value asynchronously.

async fn pipeline( &self, cfg: Cfg, ) -> Result<Pipeline<Self::Service>, Self::InitError>

where Self: Sized,

Create and return a new service value asynchronously and wrap into a container

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

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

Map this service’s output to a different type, returning a new service of the resulting type.

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

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

Map this service’s error to a different error, returning a new service.

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

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

Map this factory’s init error to a different error, returning a new service.