Struct actix_http::HttpService

pub struct HttpService<T, P, S, B, X = ExpectHandler> { /* fields omitted */ }

NewService HTTP1.1/HTTP2 transport implementation

Methods

impl<T, S, B> HttpService<T, (), S, B> where
    S: NewService<SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: Debug,
    S::Response: Into<Response<B>>,
    <S::Service as Service>::Future: 'static,
    B: MessageBody + 'static, 

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

Create builder for HttpService instance.

impl<T, P, S, B> HttpService<T, P, S, B> where
    S: NewService<SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: Debug,
    S::Response: Into<Response<B>>,
    <S::Service as Service>::Future: 'static,
    B: MessageBody + 'static, 

pub fn new<F: IntoNewService<S, SrvConfig>>(service: F) -> Self

Create new HttpService instance.

impl<T, P, S, B, X> HttpService<T, P, S, B, X> where
    S: NewService<SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: Debug,
    S::Response: Into<Response<B>>,
    B: MessageBody, 

pub fn expect<U>(self, expect: U) -> HttpService<T, P, S, B, U> where
    U: NewService<Request = Request, Response = Request>,
    U::Error: Into<Error>,
    U::InitError: Debug, 

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.

Trait Implementations

impl<T, P, S, B, X> NewService<ServerConfig> for HttpService<T, P, S, B, X> where
    T: AsyncRead + AsyncWrite,
    S: NewService<SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::InitError: Debug,
    S::Response: Into<Response<B>>,
    <S::Service as Service>::Future: 'static,
    B: MessageBody + 'static,
    X: NewService<Request = Request, Response = Request>,
    X::Error: Into<Error>,
    X::InitError: Debug, 

type Request = ServerIo<T, P>

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, P, S::Service, B, X::Service>

The Service value created by this factory

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

The future of the Service instance.

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

Create and return a new service value asynchronously.

default fn apply<T, T1, B, B1>(
    self,
    transform: T1,
    service: B1
) -> AndThenTransform<T, Self, B, Config> where
    B: NewService<Config, InitError = Self::InitError>,
    B1: IntoNewService<B, Config>,
    T: Transform<<B as NewService<Config>>::Service, Request = Self::Response, InitError = Self::InitError>,
    T1: IntoTransform<T, <B as NewService<Config>>::Service>,
    <T as Transform<<B as NewService<Config>>::Service>>::Error: From<Self::Error>, 

Apply transform service to specified service and use it as a next service in chain.

default fn apply_fn<B, I, F, Out>(
    self,
    service: I,
    f: F
) -> AndThenApplyNewService<Self, B, F, Out, Config> where
    B: NewService<Config, Error = Self::Error, InitError = Self::InitError>,
    F: FnMut(Self::Response, &mut <B as NewService<Config>>::Service) -> Out,
    I: IntoNewService<B, Config>,
    Out: IntoFuture,
    <Out as IntoFuture>::Error: Into<Self::Error>, 

Apply function to specified service and use it as a next service in chain.

default fn apply_cfg<F, C, S, U>(
    self,
    service: U,
    f: F
) -> AndThenNewService<Self, ApplyConfig<F, S, Config, C>, Config> where
    F: Fn(&Config) -> C,
    S: NewService<C, Request = Self::Response, Error = Self::Error, InitError = Self::InitError>,
    U: IntoNewService<S, C>, 

Map this service's config type to a different config, and use for nested service

default fn and_then<F, B>(
    self,
    new_service: F
) -> AndThenNewService<Self, B, Config> where
    B: NewService<Config, Request = Self::Response, Error = Self::Error, InitError = Self::InitError>,
    F: IntoNewService<B, Config>, 

Call another service after call to this one has resolved successfully.

default fn from_err<E>(self) -> FromErrNewService<Self, E, Config> where
    E: From<Self::Error>, 

NewService that create service to map this service's error and new service's init error to any error implementing From for this servicesError`.

default fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B, Config> where
    B: NewService<Config, Request = Result<Self::Response, Self::Error>, Error = Self::Error, InitError = Self::InitError>,
    F: IntoNewService<B, Config>, 

Create NewService to chain on a computation for when a call to the service finished, passing the result of the call to the next service B.

default fn map<F, R>(self, f: F) -> MapNewService<Self, F, R, Config> where
    F: FnMut(Self::Response) -> R, 

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

default fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E, Config> where
    F: Fn(Self::Error) -> E + Clone, 

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

default fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E, Config> where
    F: Fn(Self::InitError) -> E, 

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