Struct actix_http::HttpServiceBuilder

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

A HTTP service builder

This type can be used to construct an instance of HttpService through a builder-like pattern.

Implementations

impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler<T>> where
    S: ServiceFactory<Config = (), Request = Request>,
    S::Error: Into<Error> + 'static,
    S::InitError: Debug,
    <S::Service as Service>::Future: 'static, 

pub fn new() -> Self

Create instance of ServiceConfigBuilder

impl<T, S, X, U> HttpServiceBuilder<T, S, X, U> where
    S: ServiceFactory<Config = (), Request = Request>,
    S::Error: Into<Error> + 'static,
    S::InitError: Debug,
    <S::Service as Service>::Future: '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,
    U::InitError: Debug,
    <U::Service as Service>::Future: 'static, 

pub fn keep_alive<W: Into<KeepAlive>>(self, val: W) -> Self

Set server keep-alive setting.

By default keep alive is set to a 5 seconds.

pub fn secure(self) -> Self

Set connection secure state

pub fn local_addr(self, addr: SocketAddr) -> Self

Set the local address that this service is bound to.

pub fn client_timeout(self, val: u64) -> Self

Set server client timeout in milliseconds for first request.

Defines a timeout for reading client request header. If a client does not transmit the entire set headers within this time, the request is terminated with the 408 (Request Time-out) error.

To disable timeout set value to 0.

By default client timeout is set to 5000 milliseconds.

pub fn client_disconnect(self, val: u64) -> Self

Set server connection disconnect timeout in milliseconds.

Defines a timeout for disconnect connection. If a disconnect procedure does not complete within this time, the request get dropped. This timeout affects secure connections.

To disable timeout set value to 0.

By default disconnect timeout is set to 0.

pub fn expect<F, X1>(self, expect: F) -> HttpServiceBuilder<T, S, X1, U> where
    F: IntoServiceFactory<X1>,
    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<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1> where
    F: IntoServiceFactory<U1>,
    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.

pub fn on_connect<F, I>(self, f: F) -> Self where
    F: Fn(&T) -> I + 'static,
    I: Clone + 'static, 

Set on-connect callback.

Called once per connection. Return value of the call is stored in request extensions.

SOFT DEPRECATED: Prefer the on_connect_ext style callback.

pub fn on_connect_ext<F>(self, f: F) -> Self where
    F: Fn(&T, &mut Extensions) + 'static, 

Sets the callback to be run on connection establishment.

Has mutable access to a data container that will be merged into request extensions. This enables transport layer data (like client certificates) to be accessed in middleware and handlers.

pub fn h1<F, B>(self, service: F) -> H1Service<T, S, B, X, U> where
    B: MessageBody,
    F: IntoServiceFactory<S>,
    S::Error: Into<Error>,
    S::InitError: Debug,
    S::Response: Into<Response<B>>, 

Finish service configuration and create a HTTP Service for HTTP/1 protocol.

pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B> where
    B: MessageBody + 'static,
    F: IntoServiceFactory<S>,
    S::Error: Into<Error> + 'static,
    S::InitError: Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service>::Future: 'static, 

Finish service configuration and create a HTTP service for HTTP/2 protocol.

pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U> where
    B: MessageBody + 'static,
    F: IntoServiceFactory<S>,
    S::Error: Into<Error> + 'static,
    S::InitError: Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service>::Future: 'static, 

Finish service configuration and create HttpService instance.