warp

warp is a composable web server framework built on top of hyper. Its core building block is the Filter system, which allows you to combine and compose requirements for HTTP requests.

Key features provided out of the box include:

• Path routing and parameter extraction
• Header requirements and extraction
• Query string deserialization
• JSON and Form bodies
• Multipart form data
• Static Files and Directories
• Websockets
• Access logging
• Compression (Gzip, Deflate, and Brotli)

Because it uses hyper, it supports HTTP/1, HTTP/2, and is fully asynchronous.

To use warp, add both warp (with the server feature enabled) and tokio to your Cargo.toml dependencies.

tokio = { version = "1", features = ["full"] }
warp = { version = "0.4", features = ["server"] }

The core concept of warp is the Filter trait. You build web services by composing different filters together using the .and() method. Filters can handle path routing, parameter extraction, header requirements, query string deserialization, and more. If a request does not meet the requirements of a filter, it will be rejected.

use warp::Filter;

let hi = warp::path("hello")
    .and(warp::path::param())
    .and(warp::header("user-agent"))
    .map(|param: String, agent: String| {
        format!("Hello {}, whose agent is {}", param, agent)
    });

You can define routes using the Filter trait. Use warp::path! for path routing and parameter extraction, and warp::serve().run() to start the server on a specific address and port.

use warp::Filter;

#[tokio::main]
async fn main() {
    // GET /hello/warp => 200 OK with body "Hello, warp!"
    let hello = warp::path!("hello" / String)
        .map(|name| format!("Hello, {}!", name));

    warp::serve(hello)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

Use warp::header::exact(name, value) to create a filter that requires a header to match a specific string value exactly. If the header is missing or the value does not match, the request is rejected.

// Require `dnt: 1` header to be set.
let must_dnt = warp::header::exact("dnt", "1");

Add graceful shutdown support using the graceful(shutdown_signal) method. You provide a Future that resolves when the server should stop accepting new connections and begin shutting down existing ones.

# async fn ex(addr: std::net::SocketAddr) {
# use warp::Filter;
# let filter = warp::any().map(|| "ok");
warp::serve(filter)
    .bind(addr).await
    .graceful(async {
        // some signal in here, such as ctrl_c
    })
    .run().await;
# }

Use warp::header::exact_ignore_case(name, value) to create a filter that requires a header to match a specific value, ignoring ASCII case (e.g., Keep-Alive matches keep-alive). If the header is missing or the value does not match, the request is rejected.

// Require `connection: keep-alive` header to be set.
let keep_alive = warp::header::exact_ignore_case("connection", "keep-alive");

Use warp::method() to extract the http::Method from an incoming request. Unlike the specific method filters (like warp::get()), this filter never rejects a request; it simply passes the method type into your filter chain for inspection or logging.

use warp::Filter;

let route = warp::method()
    .map(|method| {
        format!("You sent a {} request!", method)
    });

Use serve(filter) to create a new Server instance with the provided Filter. The filter defines how requests are processed and what they return.

let filter = warp::any().map(|| "ok");
warp::serve(filter)
    .run()
    .await;