frakt 0.1.0

Ergonomic platform HTTP client bindings for Rust
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

//! Example demonstrating proxy configuration with httpbin

use frakt::{Client, Result};

#[tokio::main]
async fn main() -> Result<()> {
    // Example 1: Basic HTTP proxy
    println!("1. Testing HTTP proxy configuration...");
    let client = Client::builder()
        .http_proxy("proxy.example.com", 8080)
        .proxy_auth("username", "password")
        .build()?;

    // This would normally use the proxy, but since proxy.example.com doesn't exist,
    // we'll get a connection error - which proves the proxy config is working
    match client.get("https://httpbin.org/ip")?.send().await {
        Ok(response) => {
            println!("Response (unexpected success): {}", response.status());
            let text = response.text().await?;
            println!("Response body: {}", text);
        }
        Err(e) => {
            println!("Expected proxy connection error: {}", e);
        }
    }

    // Example 2: HTTPS proxy
    println!("\n2. Testing HTTPS proxy configuration...");
    let https_client = Client::builder()
        .https_proxy("secure-proxy.example.com", 8443)
        .proxy_auth("admin", "secret")
        .build()?;

    match https_client
        .get("https://httpbin.org/headers")?
        .send()
        .await
    {
        Ok(response) => {
            println!("Response (unexpected success): {}", response.status());
        }
        Err(e) => {
            println!("Expected HTTPS proxy connection error: {}", e);
        }
    }

    // Example 3: SOCKS proxy
    println!("\n3. Testing SOCKS proxy configuration...");
    let socks_client = Client::builder()
        .socks_proxy("socks-proxy.example.com", 1080)
        .proxy_auth("socks_user", "socks_pass")
        .build()?;

    match socks_client
        .get("https://httpbin.org/user-agent")?
        .send()
        .await
    {
        Ok(response) => {
            println!("Response (unexpected success): {}", response.status());
        }
        Err(e) => {
            println!("Expected SOCKS proxy connection error: {}", e);
        }
    }

    // Example 4: Multiple proxy types
    println!("\n4. Testing multiple proxy configuration...");
    let multi_client = Client::builder()
        .http_proxy("http-proxy.example.com", 8080)
        .https_proxy("https-proxy.example.com", 8443)
        .socks_proxy("socks-proxy.example.com", 1080)
        .proxy_auth("multi_user", "multi_pass")
        .build()?;

    match multi_client.get("https://httpbin.org/get")?.send().await {
        Ok(response) => {
            println!("Response (unexpected success): {}", response.status());
        }
        Err(e) => {
            println!("Expected multi-proxy connection error: {}", e);
        }
    }

    // Example 5: No proxy (direct connection) - this should work
    println!("\n5. Testing direct connection (no proxy)...");
    let direct_client = Client::builder()
        .user_agent("frakt-proxy-example/1.0")
        .build()?;

    match direct_client.get("https://httpbin.org/get")?.send().await {
        Ok(response) => {
            println!(
                "Direct connection successful! Status: {}",
                response.status()
            );
            let text = response.text().await?;
            println!("Response shows no proxy was used:");

            // Parse the JSON to show relevant parts
            if let Ok(json) = serde_json::from_str::<serde_json::Value>(&text) {
                if let Some(headers) = json.get("headers") {
                    println!("User-Agent: {:?}", headers.get("User-Agent"));
                    println!("Host: {:?}", headers.get("Host"));
                }
                if let Some(origin) = json.get("origin") {
                    println!("Origin IP: {}", origin);
                }
            }
        }
        Err(e) => {
            println!("Direct connection failed: {}", e);
        }
    }

    println!("\nProxy configuration examples completed!");
    println!("Note: The proxy examples above use non-existent proxy servers,");
    println!("so they demonstrate configuration but will fail to connect.");
    println!("In real usage, replace with actual proxy server details.");

    Ok(())
}