Struct actix_http::HttpService

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

A ServiceFactory for HTTP/1.1 or HTTP/2 protocol.

Implementations

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

pub fn openssl(
    self,
    acceptor: SslAcceptor
) -> impl ServiceFactory<TcpStream, Config = (), Response = (), Error = TlsError<SslError, DispatchError>, InitError = ()>

Create openssl based service

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

pub fn rustls(
    self,
    config: ServerConfig
) -> impl ServiceFactory<TcpStream, Config = (), Response = (), Error = TlsError<Error, DispatchError>, InitError = ()>

Create rustls based service

impl<T, S, B> HttpService<T, S, B> where
    S: ServiceFactory<Request, Config = ()>,
    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::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<Request, Config = ()>,
    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
    B: MessageBody + 'static,
    B::Error: Into<Box<dyn StdError>>, 

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

Create new HttpService instance.

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

pub fn expect<X1>(self, expect: X1) -> HttpService<T, S, B, X1, U> where
    X1: ServiceFactory<Request, Config = (), Response = Request>,
    X1::Error: Into<Response<AnyBody>>,
    X1::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.

pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<T, S, B, X, U1> where
    U1: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
    U1::Error: Display,
    U1::InitError: Debug, 

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<Request, Config = ()>,
    S::Future: 'static,
    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
    B: MessageBody + 'static,
    B::Error: Into<Box<dyn StdError>>,
    X: ServiceFactory<Request, Config = (), Response = Request>,
    X::Future: 'static,
    X::Error: Into<Response<AnyBody>>,
    X::InitError: Debug,
    U: ServiceFactory<(Request, Framed<TcpStream, Codec>), Config = (), Response = ()>,
    U::Future: 'static,
    U::Error: Display + Into<Response<AnyBody>>,
    U::InitError: Debug, 

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

Create simple tcp stream service

Trait Implementations

impl<T, S, B, X, U> ServiceFactory<(T, Protocol, Option<SocketAddr>)> for HttpService<T, S, B, X, U> where
    T: AsyncRead + AsyncWrite + Unpin + 'static,
    S: ServiceFactory<Request, Config = ()>,
    S::Future: 'static,
    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
    B: MessageBody + 'static,
    B::Error: Into<Box<dyn StdError>>,
    X: ServiceFactory<Request, Config = (), Response = Request>,
    X::Future: 'static,
    X::Error: Into<Response<AnyBody>>,
    X::InitError: Debug,
    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
    U::Future: 'static,
    U::Error: Display + Into<Response<AnyBody>>,
    U::InitError: Debug, 

type Response = ()

Responses given by the created services.

type Error = DispatchError

Errors produced by the created services.

type Config = ()

Service factory configuration.

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

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>

The future of the Service instance.g

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

Create and return a new service asynchronously.