pulse_http 0.2.0

Async HTTP/1.1 framework on Tokio — raw TCP, routing, middleware, no Hyper
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

# PulseHTTP

Async HTTP/1.1 framework for Rust, built on [Tokio](https://tokio.rs) from raw TCP sockets

[![Crates.io](https://img.shields.io/crates/v/pulse_http.svg)](https://crates.io/crates/pulse_http)
[![Docs.rs](https://docs.rs/pulse_http/badge.svg)](https://docs.rs/pulse_http)

## Install

```toml
[dependencies]
pulse_http = "0.2"
tokio = { version = "1", features = ["full"] }
```

## Quick start

```rust
use pulse_http::{Request, Response, Router, Server};

#[tokio::main]
async fn main() {
    let router = Router::new()
        .get("/health", |_req: Request| async { Response::ok("ok") })
        .get("/hello/:name", |req: Request| async move {
            let name = req
                .params
                .get("name")
                .cloned()
                .unwrap_or_else(|| "world".into());
            Response::ok(format!("hello {name}"))
        });

    Server::bind("127.0.0.1:3000".into())
        .await
        .router(router)
        .serve()
        .await;
}
```

Ctrl+C triggers graceful shutdown (stop accept → drain connections → grace abort).

## Features

- Tokio TCP listener, task-per-connection, admission semaphore
- HTTP/1.1 keep-alive, `Content-Length` and chunked request bodies
- Streaming file responses (`Response::file`) without buffering the whole file
- Read and write timeouts (slow clients close the connection)
- Trie router (static + `:param`), query params
- Async middleware (request id, logging, CORS, security headers, panic catch)
- JSON + `application/x-www-form-urlencoded` + `multipart/form-data`
- Typed app `State`
- Per-route token-bucket rate limits
- Configurable max connections, max body size, read/write timeouts
- Graceful shutdown

## Examples

From this repo:

```bash
# routing, JSON, forms — no database
cargo run -p hello_world

# per-route rate limiting (429 after burst)
cargo run -p rate_limit

# typed State + Postgres (sqlx)
docker compose -f examples/docker-compose.yml up -d
cargo run -p sqlx_postgres
```

| Example         | Port | Focus        |
| --------------- | ---- | ------------ |
| `hello_world`   | 3000 | Basics       |
| `sqlx_postgres` | 3001 | `State` + DB |
| `rate_limit`    | 3002 | Route limits |

## Builder knobs

```rust
Server::bind("127.0.0.1:3000".into())
    .await
    .max_connects(256)
    .max_body_size(5 * 1024 * 1024)
    .read_timeout_sec(60)
    .write_timeout_sec(60)
    .router(router)
    .serve()
    .await;
```

## Benchmarks

Micro-benchmarks via [Criterion](https://github.com/bheisler/criterion.rs) (release mode). Numbers below are from one run on Apple Silicon (Aug 2026) — treat as relative, not absolute.

| Bench                | Median time |
| -------------------- | ----------- |
| `parse_headers`      | ~471 ns     |
| `parse_urlencoded`   | ~326 ns     |
| `parse_multipart`    | ~872 ns     |
| `router_match_param` | ~222 ns     |

Reproduce:

```bash
cargo bench -p pulse_http --bench micro
```

HTML reports (local): `pulse_http/target/criterion/*/report/index.html`

## License

MIT