Struct actix_web::HttpServer
source · 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 */ }
Expand description
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§
source§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,
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,
sourcepub fn workers(self, num: usize) -> Self
pub fn workers(self, num: usize) -> Self
Sets number of workers to start (per bind address).
By default, the number of available physical CPUs is used as the worker count.
sourcepub fn keep_alive<T: Into<KeepAlive>>(self, val: T) -> Self
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.
sourcepub fn backlog(self, backlog: u32) -> Self
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()
.
sourcepub fn max_connections(self, num: usize) -> Self
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.
sourcepub fn max_connection_rate(self, num: usize) -> Self
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.
sourcepub fn worker_max_blocking_threads(self, num: usize) -> Self
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.
sourcepub fn client_request_timeout(self, dur: Duration) -> Self
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.
sourcepub fn client_disconnect_timeout(self, dur: Duration) -> Self
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.
sourcepub fn on_connect<CB>(self, f: CB) -> HttpServer<F, I, S, B>where
CB: Fn(&dyn Any, &mut Extensions) + Send + Sync + 'static,
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::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.
sourcepub fn server_hostname<T: AsRef<str>>(self, val: T) -> Self
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”.
sourcepub fn system_exit(self) -> Self
pub fn system_exit(self) -> Self
Flags the System
to exit after server shutdown.
Does nothing when running under #[tokio::main]
runtime.
sourcepub fn disable_signals(self) -> Self
pub fn disable_signals(self) -> Self
Disables signal handling.
sourcepub fn shutdown_timeout(self, sec: u64) -> Self
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.
sourcepub fn addrs(&self) -> Vec<SocketAddr>
pub fn addrs(&self) -> Vec<SocketAddr>
Returns addresses of bound sockets.
sourcepub fn addrs_with_scheme(&self) -> Vec<(SocketAddr, &str)>
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.
sourcepub fn bind<A: ToSocketAddrs>(self, addrs: A) -> Result<Self>
pub fn bind<A: ToSocketAddrs>(self, addrs: A) -> Result<Self>
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")?
sourcepub fn listen(self, lst: TcpListener) -> Result<Self>
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()
.
sourcepub fn bind_uds<A>(self, uds_path: A) -> Result<Self>where
A: AsRef<Path>,
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.
sourcepub fn listen_uds(self, lst: UnixListener) -> Result<Self>
pub fn listen_uds(self, lst: UnixListener) -> Result<Self>
Binds to existing Unix Domain Socket (UDS) listener.
source§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,
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,
sourcepub fn run(self) -> Server ⓘ
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.