camber 0.4.1

Opinionated async Rust for IO-bound services on top of Tokio
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::runtime_support as common;

use std::io::{Read, Write};
use std::net::TcpStream;
use std::time::Duration;

fn send_request(stream: &mut TcpStream, path: &str, connection: Option<&str>) {
    let conn_header = match connection {
        Some(val) => format!("Connection: {val}\r\n"),
        None => String::new(),
    };
    let req = format!("GET {path} HTTP/1.1\r\nHost: localhost\r\n{conn_header}\r\n");
    stream.write_all(req.as_bytes()).expect("write request");
    stream.flush().expect("flush request");
}

fn assert_connection_eof(stream: &mut TcpStream, expected: &str) {
    let mut byte = [0_u8; 1];
    match stream.read(&mut byte) {
        Ok(0) => {}
        Ok(count) => panic!("expected {expected}, but read {count} byte(s): {byte:?}"),
        Err(error) => panic!("expected {expected}, but the EOF read failed: {error}"),
    }
}

#[test]
fn keepalive_serves_multiple_requests_on_one_connection() {
    common::test_runtime()
        .keepalive_timeout(Duration::from_millis(200))
        .run(|| {
            let mut router = camber::http::Router::new();
            router.get("/hello", |_req| async {
                camber::http::Response::text(200, "Hello, world!")
            });

            let listener = camber::net::listen("127.0.0.1:0").expect("bind");
            let addr = listener.local_addr().expect("addr").tcp().unwrap();

            camber::spawn(move || -> Result<(), camber::RuntimeError> {
                camber::http::serve_listener(listener, router)
            });
            let mut stream = crate::http::connect(addr).expect("connect");

            // First request — no Connection header (HTTP/1.1 defaults to keep-alive)
            send_request(&mut stream, "/hello", None);
            let response =
                crate::http::read_http_response_bounded(&mut stream).expect("first response");
            assert_eq!(response.status, 200);
            assert_eq!(response.body.as_ref(), b"Hello, world!");

            // Second request on the same connection
            send_request(&mut stream, "/hello", None);
            let response =
                crate::http::read_http_response_bounded(&mut stream).expect("second response");
            assert_eq!(response.status, 200);
            assert_eq!(response.body.as_ref(), b"Hello, world!");

            // Third request with Connection: close
            send_request(&mut stream, "/hello", Some("close"));
            let response =
                crate::http::read_http_response_bounded(&mut stream).expect("third response");
            assert_eq!(response.status, 200);
            assert_eq!(response.body.as_ref(), b"Hello, world!");

            // Server should have closed the connection
            assert_connection_eof(
                &mut stream,
                "server to close connection after Connection: close",
            );

            camber::runtime::request_shutdown();
        })
        .unwrap();
}

#[test]
fn keepalive_timeout_closes_idle_connection() {
    // Short keepalive timeout so the test completes quickly
    camber::runtime::builder()
        .keepalive_timeout(Duration::from_millis(200))
        .shutdown_timeout(Duration::from_secs(1))
        .run(|| {
            let mut router = camber::http::Router::new();
            router.get("/hello", |_req| async {
                camber::http::Response::text(200, "Hello")
            });

            let listener = camber::net::listen("127.0.0.1:0").expect("bind");
            let addr = listener.local_addr().expect("addr").tcp().unwrap();

            camber::spawn(move || -> Result<(), camber::RuntimeError> {
                camber::http::serve_listener(listener, router)
            });
            let mut stream = crate::http::connect(addr).expect("connect");

            // Send one request
            send_request(&mut stream, "/hello", None);
            let response = crate::http::read_http_response_bounded(&mut stream).expect("response");
            assert_eq!(response.status, 200);

            // Wait longer than the keepalive timeout (200ms)
            std::thread::sleep(Duration::from_millis(300));

            // Server should have closed the connection due to idle timeout
            assert_connection_eof(
                &mut stream,
                "server to close idle connection after keepalive timeout",
            );

            camber::runtime::request_shutdown();
        })
        .unwrap();
}

#[test]
fn connection_close_header_prevents_keepalive() {
    common::test_runtime()
        .keepalive_timeout(Duration::from_millis(200))
        .run(|| {
            let mut router = camber::http::Router::new();
            router.get("/hello", |_req| async {
                camber::http::Response::text(200, "Hello")
            });

            let listener = camber::net::listen("127.0.0.1:0").expect("bind");
            let addr = listener.local_addr().expect("addr").tcp().unwrap();

            camber::spawn(move || -> Result<(), camber::RuntimeError> {
                camber::http::serve_listener(listener, router)
            });
            let mut stream = crate::http::connect(addr).expect("connect");

            // Send request with Connection: close
            send_request(&mut stream, "/hello", Some("close"));
            let response = crate::http::read_http_response_bounded(&mut stream).expect("response");
            assert_eq!(response.status, 200);
            assert_eq!(response.header("connection"), Some("close"));

            // Server should have closed the connection
            assert_connection_eof(
                &mut stream,
                "server to close connection after Connection: close",
            );

            camber::runtime::request_shutdown();
        })
        .unwrap();
}