Struct gotcha::HttpServer

pub struct HttpServer<F, I, S, B>where
    F: Fn() -> I + Send + Clone + 'static,
    I: IntoServiceFactory<S, Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>,
    S: ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Config = AppConfig>,
    <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Error: Into<Error>,
    <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::InitError: Debug,
    <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Response: Into<Response<B>>,
    B: MessageBody,{ /* private fields */ }

An HTTP Server.

Create new HTTP server with application factory.

HTTP/2

Currently, HTTP/2 is only supported when using TLS (HTTPS). See bind_rustls or bind_openssl.

Examples

use actix_web::{web, App, HttpResponse, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(web::resource("/").to(|| async { "hello world" }))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Implementations

impl<F, I, S, B> HttpServer<F, I, S, B>where F: Fn() -> I + Send + Clone + 'static, I: IntoServiceFactory<S, Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>, S: ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Config = AppConfig> + 'static, <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Error: Into<Error> + 'static, <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::InitError: Debug, <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Response: Into<Response<B>> + 'static, <<S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Service as Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Future: 'static, <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Service: 'static, B: MessageBody + 'static,

pub fn new(factory: F) -> HttpServer<F, I, S, B>

Create new HTTP server with application factory

pub fn workers(self, num: usize) -> HttpServer<F, I, S, B>

Sets number of workers to start (per bind address).

By default, the number of available physical CPUs is used as the worker count.

pub fn keep_alive<T>(self, val: T) -> HttpServer<F, I, S, B>where T: Into<KeepAlive>,

Sets server keep-alive preference.

By default keep-alive is set to 5 seconds.

pub fn backlog(self, backlog: u32) -> HttpServer<F, I, S, B>

Sets the maximum number of pending connections.

This refers to the number of clients that can be waiting to be served. Exceeding this number results in the client getting an error when attempting to connect. It should only affect servers under significant load.

Generally set in the 64–2048 range. Default value is 2048.

This method will have no effect if called after a bind().

pub fn max_connections(self, num: usize) -> HttpServer<F, I, S, B>

Sets the per-worker maximum number of concurrent connections.

All socket listeners will stop accepting connections when this limit is reached for each worker.

By default max connections is set to a 25k.

pub fn max_connection_rate(self, num: usize) -> HttpServer<F, I, S, B>

Sets the per-worker maximum concurrent TLS connection limit.

All listeners will stop accepting connections when this limit is reached. It can be used to limit the global TLS CPU usage.

By default max connections is set to a 256.

pub fn worker_max_blocking_threads(self, num: usize) -> HttpServer<F, I, S, B>

Sets max number of threads for each worker’s blocking task thread pool.

One thread pool is set up per worker; not shared across workers.

By default set to 512 divided by the number of workers.

pub fn client_request_timeout(self, dur: Duration) -> HttpServer<F, I, S, B>

Sets server client timeout for first request.

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

To disable timeout set value to 0.

By default client timeout is set to 5000 milliseconds.

pub fn client_disconnect_timeout(self, dur: Duration) -> HttpServer<F, I, S, B>

Sets server connection shutdown timeout.

Defines a timeout for connection shutdown. If a shutdown procedure does not complete within this time, the request is dropped.

To disable timeout set value to 0.

By default client timeout is set to 5000 milliseconds.

pub fn on_connect<CB>(self, f: CB) -> HttpServer<F, I, S, B>where CB: Fn(&(dyn Any + 'static), &mut Extensions) + Send + Sync + 'static,

Sets function that will be called once before each connection is handled.

It will receive a &std::any::Any, which contains underlying connection type and an [Extensions] container so that connection data can be accessed in middleware and handlers.

Connection Types

• actix_tls::accept::openssl::TlsStream<actix_web::rt::net::TcpStream> when using OpenSSL.
• actix_tls::accept::rustls::TlsStream<actix_web::rt::net::TcpStream> when using Rustls.
• actix_web::rt::net::TcpStream when no encryption is used.

See the on_connect example for additional details.

pub fn server_hostname<T>(self, val: T) -> HttpServer<F, I, S, B>where T: AsRef<str>,

Sets server host name.

Host name is used by application router as a hostname for url generation. Check ConnectionInfo docs for more info.

By default, hostname is set to “localhost”.

pub fn system_exit(self) -> HttpServer<F, I, S, B>

Flags the System to exit after server shutdown.

Does nothing when running under #[tokio::main] runtime.

pub fn disable_signals(self) -> HttpServer<F, I, S, B>

Disables signal handling.

pub fn shutdown_timeout(self, sec: u64) -> HttpServer<F, I, S, B>

Sets timeout for graceful worker shutdown of workers.

After receiving a stop signal, workers have this much time to finish serving requests. Workers still alive after the timeout are force dropped.

By default shutdown timeout sets to 30 seconds.

pub fn addrs(&self) -> Vec<SocketAddr, Global>

Returns addresses of bound sockets.

pub fn addrs_with_scheme(&self) -> Vec<(SocketAddr, &str), Global>

Returns addresses of bound sockets and the scheme for it.

This is useful when the server is bound from different sources with some sockets listening on HTTP and some listening on HTTPS and the user should be presented with an enumeration of which socket requires which protocol.

pub fn bind<A>(self, addrs: A) -> Result<HttpServer<F, I, S, B>, Error>where A: ToSocketAddrs,

Resolves socket address(es) and binds server to created listener(s).

Hostname Resolution

When addr includes a hostname, it is possible for this method to bind to both the IPv4 and IPv6 addresses that result from a DNS lookup. You can test this by passing localhost:8080 and noting that the server binds to 127.0.0.1:8080 and [::1]:8080. To bind additional addresses, call this method multiple times.

Note that, if a DNS lookup is required, resolving hostnames is a blocking operation.

Typical Usage

In general, use 127.0.0.1:<port> when testing locally and 0.0.0.0:<port> when deploying (with or without a reverse proxy or load balancer) so that the server is accessible.

Errors

Returns an io::Error if:

• addrs cannot be resolved into one or more socket addresses;
• all the resolved socket addresses are already bound.

Example

HttpServer::new(|| App::new())
    .bind(("127.0.0.1", 8080))?
    .bind("[::1]:9000")?

pub fn listen(self, lst: TcpListener) -> Result<HttpServer<F, I, S, B>, Error>

Binds to existing listener for accepting incoming connection requests.

No changes are made to lst’s configuration. Ensure it is configured properly before passing ownership to listen().

pub fn bind_uds<A>(self, uds_path: A) -> Result<HttpServer<F, I, S, B>, Error>where A: AsRef<Path>,

Opens Unix Domain Socket (UDS) from uds path and binds server to created listener.

pub fn listen_uds( self, lst: UnixListener ) -> Result<HttpServer<F, I, S, B>, Error>

Binds to existing Unix Domain Socket (UDS) listener.

impl<F, I, S, B> HttpServer<F, I, S, B>where F: Fn() -> I + Send + Clone + 'static, I: IntoServiceFactory<S, Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>, S: ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Config = AppConfig>, <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Error: Into<Error>, <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::InitError: Debug, <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Response: Into<Response<B>>, <S as ServiceFactory<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Service: 'static, B: MessageBody,

pub fn run(self) -> Server

Start listening for incoming connections.

Workers

This method starts a number of HTTP workers in separate threads. The number of workers in a set is defined by workers() or, by default, the number of the machine’s physical cores. One worker set is created for each socket address to be bound. For example, if workers is set to 4, and there are 2 addresses to bind, then 8 worker threads will be spawned.

Panics

This methods panics if no socket addresses were successfully bound or if no Tokio runtime is set up.