rpcnet 0.1.0

RPC library based on QUIC+TLS encryption
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

#![allow(dead_code)]
#![allow(unused_imports)]
//! Echo client using generated code.

#[path = "generated/echo/mod.rs"]
mod echo;

use echo::client::EchoClient;
use echo::{BinaryEchoRequest, EchoRequest};
use rpcnet::RpcConfig;
use std::net::SocketAddr;
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Echo Client (Generated Code) ===");

    let config = RpcConfig::new("certs/test_cert.pem", "127.0.0.1:0")
        .with_server_name("localhost")
        .with_keep_alive_interval(Duration::from_secs(30));

    let server_addr: SocketAddr = "127.0.0.1:8081".parse()?;

    println!("Connecting to echo service at {}", server_addr);
    let client = EchoClient::connect(server_addr, config).await?;
    println!("Connected successfully!");

    // Test basic echo
    println!("\n--- Testing Text Echo ---");
    let echo_req = EchoRequest {
        message: "Hello World".to_string(),
        times: 1,
    };
    match client.echo(echo_req).await {
        Ok(response) => println!("Echo: {}", response.echoed_message),
        Err(e) => println!("Echo failed: {}", e),
    }

    // Test multiple echo
    let echo_req = EchoRequest {
        message: "Test".to_string(),
        times: 3,
    };
    match client.echo(echo_req).await {
        Ok(response) => println!("Multiple echo: {}", response.echoed_message),
        Err(e) => println!("Multiple echo failed: {}", e),
    }

    // Test binary echo
    println!("\n--- Testing Binary Echo ---");
    let binary_data = b"Binary test data 123".to_vec();
    let binary_req = BinaryEchoRequest {
        data: binary_data.clone(),
    };
    match client.binary_echo(binary_req).await {
        Ok(response) => {
            if response.data == binary_data {
                println!(
                    "Binary echo successful: {} bytes returned",
                    response.data.len()
                );
            } else {
                println!("Binary echo mismatch!");
            }
        }
        Err(e) => println!("Binary echo failed: {}", e),
    }

    // Test error handling (too many repetitions)
    println!("\n--- Testing Error Handling ---");
    let echo_req = EchoRequest {
        message: "Error".to_string(),
        times: 200,
    };
    match client.echo(echo_req).await {
        Ok(response) => println!("Unexpected success: {}", response.echoed_message),
        Err(e) => println!("Error handling works: {}", e),
    }

    println!("\nAll tests completed!");
    Ok(())
}