Struct actix_web::HttpServer

pub struct HttpServer<F, I, S, B>
where
    F: Fn() -> I + Send + Clone + 'static,
    I: IntoServiceFactory<S, Request>,
    S: ServiceFactory<Request, Config = AppConfig>,
    S::Error: Into<Error>,
    S::InitError: Debug,
    S::Response: Into<Response<B>>,
    B: MessageBody,
{ /* private fields */ }

An HTTP Server.

Create new HTTP server with application factory.

Automatic HTTP Version Selection

There are two ways to select the HTTP version of an incoming connection:

• One is to rely on the ALPN information that is provided when using a TLS (HTTPS); both versions are supported automatically when using either of the .bind_rustls() or .bind_openssl() methods.
• The other is to read the first few bytes of the TCP stream. This is the only viable approach for supporting H2C, which allows the HTTP/2 protocol to work over plaintext connections. Use the .bind_auto_h2c() method to enable this behavior.

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>, S: ServiceFactory<Request, Config = AppConfig> + 'static, S::Error: Into<Error> + 'static, S::InitError: Debug, S::Response: Into<Response<B>> + 'static, <S::Service as Service<Request>>::Future: 'static, S::Service: 'static, B: MessageBody + 'static,

pub fn new(factory: F) -> Self

Create new HTTP server with application factory

Worker Count

The factory will be instantiated multiple times in most configurations. See bind() docs for more on how worker count and bind address resolution causes multiple server factory instantiations.

pub fn workers(self, num: usize) -> Self

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

The default worker count is the determined by std::thread::available_parallelism(). See its documentation to determine what behavior you should expect when server is run.

Note that the server factory passed to new will be instantiated at least once per worker. See bind() docs for more on how worker count and bind address resolution causes multiple server factory instantiations.

num must be greater than 0.

Panics

Panics if num is 0.

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

Sets server keep-alive preference.

By default keep-alive is set to 5 seconds.

pub fn backlog(self, backlog: u32) -> Self

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) -> Self

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) -> Self

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) -> Self

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) -> Self

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) -> Self

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, &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_0_20::TlsStream<actix_web::rt::net::TcpStream> when using Rustls v0.20.
• actix_tls::accept::rustls_0_21::TlsStream<actix_web::rt::net::TcpStream> when using Rustls v0.21.
• actix_tls::accept::rustls_0_22::TlsStream<actix_web::rt::net::TcpStream> when using Rustls v0.22.
• actix_tls::accept::rustls_0_23::TlsStream<actix_web::rt::net::TcpStream> when using Rustls v0.23.
• actix_web::rt::net::TcpStream when no encryption is used.

See the on_connect example for additional details.

pub fn server_hostname<T: AsRef<str>>(self, val: T) -> Self

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) -> Self

Flags the System to exit after server shutdown.

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

pub fn disable_signals(self) -> Self

Disables signal handling.

pub fn shutdown_timeout(self, sec: u64) -> Self

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>

Returns addresses of bound sockets.

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

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: ToSocketAddrs>(self, addrs: A) -> Result<Self>

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

Hostname Resolution

When addrs 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.

Worker Count

The factory will be instantiated multiple times in most scenarios. The number of instantiations is number of workers × number of sockets resolved by addrs.

For example, if you’ve manually set workers to 2, and use 127.0.0.1 as the bind addrs, then factory will be instantiated twice. However, using localhost as the bind addrs can often resolve to both 127.0.0.1 (IPv4) and ::1 (IPv6), causing the factory to be instantiated 4 times (2 workers × 2 bind addresses).

Using a bind address of 0.0.0.0, which signals to use all interfaces, may also multiple the number of instantiations in a similar way.

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 bind_auto_h2c<A: ToSocketAddrs>(self, addrs: A) -> Result<Self>

Resolves socket address(es) and binds server to created listener(s) for plaintext HTTP/1.x or HTTP/2 connections.

See bind() for more details on addrs argument.

pub fn listen(self, lst: TcpListener) -> Result<Self>

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 listen_auto_h2c(self, lst: TcpListener) -> Result<Self>

Binds to existing listener for accepting incoming plaintext HTTP/1.x or HTTP/2 connections.

pub fn bind_uds<A>(self, uds_path: A) -> Result<Self>

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<Self>

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>, S: ServiceFactory<Request, Config = AppConfig>, S::Error: Into<Error>, S::InitError: Debug, S::Response: Into<Response<B>>, S::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.