Struct ntex::http::h1::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> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, C: ServiceFactory<Control<Layer<SslFilter, F>, S::Error>, Response = ControlAck> + 'static, C::Error: Error, C::InitError: Debug,

pub fn openssl( self, acceptor: SslAcceptor ) -> impl ServiceFactory<Io<F>, 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> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, C: ServiceFactory<Control<Layer<TlsServerFilter, F>, S::Error>, Response = ControlAck> + 'static, C::Error: Error, C::InitError: Debug,

pub fn rustls( self, config: ServerConfig ) -> impl ServiceFactory<Io<F>, 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>, S::Error: ResponseError, S::Response: Into<Response<B>>, S::InitError: Debug, B: MessageBody, C: ServiceFactory<Control<F, S::Error>, Response = ControlAck>, C::Error: Error, C::InitError: Debug,

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

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

Provide http/1 control service

Trait Implementations

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

where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::Response: Into<Response<B>>, S::InitError: Debug, B: MessageBody, C: ServiceFactory<Control<F, S::Error>, Response = ControlAck> + '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>>::Service, B, <C as ServiceFactory<Control<F, <S as ServiceFactory<Request>>::Error>>>::Service>

The kind of Service created by this factory.

async fn create(&self, _: ()) -> 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.