Struct HttpService

pub struct HttpService<T, S, B, X = ExpectHandler, U = UpgradeHandler<T>> { /* private fields */ }

ServiceFactory HTTP1.1/HTTP2 transport implementation

Implementations

impl<T, S, B> HttpService<T, S, B>

where S: ServiceFactory<Config = (), Request = Request>, S::Error: Into<Error> + 'static, S::InitError: Debug, S::Response: Into<Response<B>> + 'static, <S::Service as Service>::Future: 'static, B: MessageBody + 'static,

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

Create builder for HttpService instance.

impl<T, S, B> HttpService<T, S, B>

where S: ServiceFactory<Config = (), Request = Request>, S::Error: Into<Error> + 'static, S::InitError: Debug, S::Response: Into<Response<B>> + 'static, <S::Service as Service>::Future: 'static, B: MessageBody + 'static,

pub fn new<F: IntoServiceFactory<S>>(service: F) -> Self

Create new HttpService instance.

impl<T, S, B, X, U> HttpService<T, S, B, X, U>

where S: ServiceFactory<Config = (), Request = Request>, S::Error: Into<Error> + 'static, S::InitError: Debug, S::Response: Into<Response<B>> + 'static, <S::Service as Service>::Future: 'static, B: MessageBody,

pub fn expect<X1>(self, expect: X1) -> HttpService<T, S, B, X1, U>

where X1: ServiceFactory<Config = (), Request = Request, Response = Request>, X1::Error: Into<Error>, X1::InitError: Debug, <X1::Service as Service>::Future: 'static,

Provide service for EXPECT: 100-Continue support.

Service get called with request that contains EXPECT header. Service must return request in case of success, in that case request will be forwarded to main service.

pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<T, S, B, X, U1>

where U1: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>, U1::Error: Display, U1::InitError: Debug, <U1::Service as Service>::Future: 'static,

Provide service for custom Connection: UPGRADE support.

If service is provided then normal requests handling get halted and this service get called with original request and framed object.

impl<S, B, X, U> HttpService<TcpStream, S, B, X, U>

where S: ServiceFactory<Config = (), Request = Request>, S::Error: Into<Error> + 'static, S::InitError: Debug, S::Response: Into<Response<B>> + 'static, <S::Service as Service>::Future: 'static, B: MessageBody + 'static, X: ServiceFactory<Config = (), Request = Request, Response = Request>, X::Error: Into<Error>, X::InitError: Debug, <X::Service as Service>::Future: 'static, U: ServiceFactory<Config = (), Request = (Request, Framed<TcpStream, Codec>), Response = ()>, U::Error: Display + Into<Error>, U::InitError: Debug, <U::Service as Service>::Future: 'static,

pub fn tcp( self, ) -> impl ServiceFactory<Config = (), Request = TcpStream, Response = (), Error = DispatchError, InitError = ()>

Create simple tcp stream service

Trait Implementations

impl<T, S, B, X, U> ServiceFactory for HttpService<T, S, B, X, U>

where T: AsyncRead + AsyncWrite + Unpin, S: ServiceFactory<Config = (), Request = Request>, S::Error: Into<Error> + 'static, S::InitError: Debug, S::Response: Into<Response<B>> + 'static, <S::Service as Service>::Future: 'static, B: MessageBody + 'static, X: ServiceFactory<Config = (), Request = Request, Response = Request>, X::Error: Into<Error>, X::InitError: Debug, <X::Service as Service>::Future: 'static, U: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>, U::Error: Display + Into<Error>, U::InitError: Debug, <U::Service as Service>::Future: 'static,

type Config = ()

Service factory configuration

type Request = (T, Protocol, Option<SocketAddr>)

Requests handled by the service.

type Response = ()

Responses given by the service

type Error = DispatchError

Errors produced by the service

type InitError = ()

Errors produced while building a service.

type Service = HttpServiceHandler<T, <S as ServiceFactory>::Service, B, <X as ServiceFactory>::Service, <U as ServiceFactory>::Service>

The Service value created by this factory

type Future = HttpServiceResponse<T, S, B, X, U>

The future of the Service instance.

fn new_service(&self, _: ()) -> Self::Future

Create and return a new service value asynchronously.

fn map<F, R>(self, f: F) -> MapServiceFactory<Self, F, R>

where Self: Sized, F: FnMut(Self::Response) -> R + 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) -> MapErrServiceFactory<Self, F, E>

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) -> MapInitErr<Self, F, E>

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

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