Expand description
Http server module
The module contains everything necessary to setup HTTP server.
In order to start HTTP server, first you need to create and configure it using factory that can be supplied to new.
Factory
Factory is a function that returns Application, describing how to serve incoming HTTP requests.
As the server uses worker pool, the factory function is restricted to trait bounds
Send + Clone + 'static
so that each worker would be able to accept Application
without a need for synchronization.
If you wish to share part of state among all workers you should
wrap it in Arc
and potentially synchronization primitive like
RwLock
If the wrapped type is not thread safe.
Note though that locking is not advisable for asynchronous programming and you should minimize all locks in your request handlers
HTTPS Support
Actix-web provides support for major crates that provides TLS. Each TLS implementation is provided with AcceptorService that describes how HTTP Server accepts connections.
For bind
and listen
there are corresponding bind_ssl|tls|rustls
and listen_ssl|tls|rustls
that accepts
these services.
NOTE: native-tls
doesn’t support HTTP2
yet
Signal handling and shutdown
By default HTTP Server listens for system signals and, gracefully shuts down at most after 30 seconds.
Both signal handling and shutdown timeout can be controlled using corresponding methods.
If worker, for some reason, unable to shut down within timeout it is forcibly dropped.
Example
extern crate actix;
extern crate actix_web;
extern crate rustls;
use actix_web::{http, middleware, server, App, Error, HttpRequest, HttpResponse, Responder};
use std::io::BufReader;
use rustls::internal::pemfile::{certs, rsa_private_keys};
use rustls::{NoClientAuth, ServerConfig};
fn index(req: &HttpRequest) -> Result<HttpResponse, Error> {
Ok(HttpResponse::Ok().content_type("text/plain").body("Welcome!"))
}
fn load_ssl() -> ServerConfig {
use std::io::BufReader;
const CERT: &'static [u8] = include_bytes!("../cert.pem");
const KEY: &'static [u8] = include_bytes!("../key.pem");
let mut cert = BufReader::new(CERT);
let mut key = BufReader::new(KEY);
let mut config = ServerConfig::new(NoClientAuth::new());
let cert_chain = certs(&mut cert).unwrap();
let mut keys = rsa_private_keys(&mut key).unwrap();
config.set_single_cert(cert_chain, keys.remove(0)).unwrap();
config
}
fn main() {
let sys = actix::System::new("http-server");
// load ssl keys
let config = load_ssl();
// create and start server at once
server::new(|| {
App::new()
// register simple handler, handle all methods
.resource("/index.html", |r| r.f(index))
}))
}).bind_rustls("127.0.0.1:8443", config)
.unwrap()
.start();
println!("Started http server: 127.0.0.1:8080");
//Run system so that server would start accepting connections
let _ = sys.run();
}
Structs
SSL
connections via openssl packageSSL
connections via rustls packageEnums
AcceptorError
service.Traits
Functions
SslAcceptorBuilder
with custom server flags.