Struct ntex::http::HttpService

pub struct HttpService<F, S, B, C1 = DefaultControlService, C2 = DefaultControlService> { /* private fields */ }

ServiceFactory HTTP1.1/HTTP2 transport implementation

Implementations

impl<F, S, B, C1, C2> HttpService<Layer<SslFilter, F>, S, B, C1, C2>

where F: Filter, S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody, C1: ServiceFactory<Control<Layer<SslFilter, F>, S::Error>, Response = ControlAck> + 'static, C1::Error: Error, C1::InitError: Debug, C2: ServiceFactory<Control<H2Error>, Response = ControlAck> + 'static, C2::Error: Error, C2::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, C1, C2> HttpService<Layer<TlsServerFilter, F>, S, B, C1, C2>

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

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

Create openssl based service

impl<F, S, B> HttpService<F, S, B>

where S: ServiceFactory<Request> + 'static, S::Error: ResponseError, S::InitError: Debug, S::Response: Into<Response<B>>, B: MessageBody,

pub fn build() -> HttpServiceBuilder<F, S>

Create builder for HttpService instance.

impl<F, S, B> HttpService<F, S, B>

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

pub fn new<U: IntoServiceFactory<S, Request>>(service: U) -> Self

Create new HttpService instance.

impl<F, S, B, C1, C2> HttpService<F, S, B, C1, C2>

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

pub fn h1_control<CT>(self, control: CT) -> HttpService<F, S, B, CT, C2>

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

Provide http/1 control service.

pub fn h2_control<CT>(self, control: CT) -> HttpService<F, S, B, C1, CT>

where CT: ServiceFactory<Control<H2Error>, Response = ControlAck>, CT::Error: Error, CT::InitError: Debug,

Provide http/1 control service.

Trait Implementations

impl<F, S, B, C1, C2> ServiceFactory<Io<F>> for HttpService<F, S, B, C1, C2>

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

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.