Module actix_web::server

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();
}