reqres 1.0.0

A pure Rust async HTTP client library based on Tokio with HTTP/2, connection pooling, proxy, cookie, compression, benchmarks, and comprehensive tests
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

use reqres::Client;
use std::time::Instant;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== reqres v0.4.0 Connection Pool Demo ===\n");

    // 测试 1: 启用连接池 + HTTP/1.1（强制使用 HTTP/1.1）
    println!("\nTest 1: Pooling with HTTP/1.1\n");
    let client_h1 = Client::builder()
        .enable_pooling()
        .http1_only()  // 强制使用 HTTP/1.1
        .build()?;

    let url = "https://httpbin.org/get";
    let iterations = 10;
    let start = Instant::now();

    for i in 1..=iterations {
        println!("  Request {}...", i);
        
        match client_h1.get(url).await {
            Ok(response) => {
                println!("    ✓ Status: {}", response.status());
            }
            Err(e) => {
                eprintln!("    ✗ Request {} failed: {}", i, e);
            }
        }
    }

    let elapsed = start.elapsed();
    println!("  Total time: {:.2}s", elapsed.as_secs_f64());
    
    if let Some(stats) = client_h1.pool_stats().await {
        println!("  Pool Hit Rate: {:.2}%", stats.total_hits as f64 / (stats.total_hits + stats.total_misses) as f64 * 100.0);
        println!("  Total hits: {}, Total misses: {}", stats.total_hits, stats.total_misses);
    }

    // 测试 2: 禁用连接池
    println!("\n{}", "=".repeat(50));
    println!("Test 2: Without pooling (new connection each request)\n");
    let client_no_pool = Client::builder()
        .disable_pooling()  // 禁用连接池
        .http1_only()
        .build()?;

    let start2 = Instant::now();
    for i in 1..=iterations {
        println!("  Request {}...", i);
        
        match client_no_pool.get(url).await {
            Ok(response) => {
                println!("    ✓ Status: {}", response.status());
            }
            Err(e) => {
                eprintln!("    ✗ Request {} failed: {}", i, e);
            }
        }
    }

    let elapsed2 = start2.elapsed();
    println!("  Total time: {:.2}s", elapsed2.as_secs_f64());

    // 测试 3: HTTP/2 (不使用连接池）
    println!("\n{}", "=".repeat(50));
    println!("Test 3: HTTP/2 (no pooling as HTTP/2 already supports multiplexing)\n");
    let client_h2 = Client::new()?;  // 默认启用 HTTP/2

    let start3 = Instant::now();
    for i in 1..=5 {
        println!("  Request {}...", i);
        
        match client_h2.get(url).await {
            Ok(response) => {
                println!("    ✓ Status: {} ({})", response.status(), response.version);
            }
            Err(e) => {
                eprintln!("    ✗ Request {} failed: {}", i, e);
            }
        }
    }

    let elapsed3 = start3.elapsed();
    println!("  Total time: {:.2}s", elapsed3.as_secs_f64());

    println!("\n{}", "=".repeat(50));
    println!("Summary:");
    println!("  Test 1 (HTTP/1.1 + Pooling): {:.2}s ({:.2}ms per request)", 
              elapsed.as_secs_f64(), elapsed.as_millis() as f64 / iterations as f64);
    println!("  Test 2 (HTTP/1.1 + No Pooling): {:.2}s ({:.2}ms per request)", 
              elapsed2.as_secs_f64(), elapsed2.as_millis() as f64 / iterations as f64);
    println!("  Test 3 (HTTP/2 + No Pooling): {:.2}s ({:.2}ms per request)", 
              elapsed3.as_secs_f64(), elapsed3.as_millis() as f64 / 5.0);

    println!("\n=== Demo completed ===");
    Ok(())
}